Avr: Unterschied zwischen den Versionen

Version vom 10. Dezember 2005, 01:17 Uhr

Hersteller der AVR-Controllerserie ist Atmel.

Beispiel eines Atmel Controllers

Es gibt eine ganze Serie von AVR-Controllern. Sie alle werden ähnlich programmiert bieten jedoch unterschiedliche Features (I/O Leitungem, Timer, Pwm-Ports usw.) Es gibt inzwischen Entwicklungssysteme in den Sprachen Basic, C, Pascal und Assembler für diese Controller. AVR steht angeblich für Advanced Virtual RISC (in einem Paper von Alf Egin Bogen und Vegard Wollan)

• 8 Bit Architektur ist für Hochsprachen (C) optimiert
• Harvard-Architektur (getrennter Befehls- und Datenspeicher)
• 32 Register, kein Akkumulator, 3 Pointerregister
• In-System progammierbar - Das bedeutet der Controller kann sehr einfach über ein Programmierkabel (oft ISP-Kabel genannt ) das mit dem PC verbunden wird programmiert werden, auch dann wenn sich dieser in einer Schaltung befindet
• JTAG (Debugerinterface)
• AVR Typen (AT90, ATtiny, ATmega)
• Viele Entwicklungsboards erhältlich, z.B. das Roboternetzboard RN-Control

Einige Pinbelegungen der populärsten Controller im Roboternetz

(in etwa nach Leistungsfähigkeit sortiert)

• AT90S2313
• Atmel Controller Mega8
• Atmel Controller Mega48 Mega88 Mega168
• Atmel Controller Mega16 und Mega32
• Atmel Controller Mega128 - SMD-Chip

Die AVR-Pin-Bezeichnungen und deren Funktion

Die meisten Ports sind doppelt belegt und besitzen neben der normalen Port-Funktion noch eine Sonderfunktion. Die verschiedenen Pinbezeichnungen und Sonderfunktionen werden hier beschrieben:

Timer der AVR's

Die Mikrocontroller der Firma ATmel (AVR's genannt) besitzen je nach Typ eine unterschiedliche Anzahl an Timern, die sich alle programmieren lassen. Bei den aktuellen ATmega's sind das mindestens ein 8-Bit Timer und bei größeren Ausführungen der Serie auch 16-Bit Timer. Die Timer werden immer Timerx benannt, wobei x für die Timernummer steht (also 0, 1, 2, usw.). Die Konfigurationsmöglichkeiten der Timer schwanken von Timer zu Timer.

Hinweis: Die folgenden Code-Beispiele (in C programmiert) wurden für einen ATmega32 entwickelt. Sie lassen sich also ohne große Änderungen auch auf anderen Mikrocontrollern der Firma ATmel ausführen.

Allgemeine Funktionsweise

Timer funktionieren nach dem allgemeinen Prinzip, dass sie eine Ganzzahl (im weiteren als Zähler bezeichnet) je nach Betriebsmodus auf- oder abwärts erweitern, d.h. inkrementieren bzw. dekrementieren. Angenommen der Timer arbeitet im einfachsten Betriebsmodus, dem normalen Modus (siehe Normaler Modus). Die Zählrichtung des Timers ist aufsteigend gerichtet, und je nach Auflösung, also 8-Bit oder 16-Bit, erreicht der Zähler irgendwann einen bestimmten Zustand. Möglich wäre, dass er überläuft, wenn z.B. bei einem 8-Bit Timer der Wert 255 inkrementiert wird (siehe Grafik).

Der Prescaler

Der Prescaler (eng. = Vorteiler) kann dazu genutzt werden den Takt, der den Timern zugeführt wird, zu verkleinern. U.a. kann man damit die Timer so konfigurieren, damit diese in den unterschiedlichsten Frequenzen takten. Hier eine Grafik die den Prescaler veranschaulicht:

Das obere Diagramm zeigt den Betrieb ohne Prescaler der untere mit Prescaler. Die gestrichelte Linie zeigt wann ein Interrupt eintritt.

Im Teil Die Betriebsmodi wird weiter auf die praktische Verwendung des Prescalers eingegangen.

Die Betriebsmodi

Die AVR-Controller können in unterschiedlichen Timer-Betriebsmodi ausgeführt werden. Diese wären:

• Normaler Modus
• CTC Modus
• PWM

Normaler Modus (Normal Mode)

Der einfachste Betriebsmodus ist der normale Modus. Er funktioniert wie im Abschnitt Allgemeine Funktionsweise Allgemeine Funktionsweise ansatzweise beschrieben. Die Zählrichtung des Timers ist immer aufsteigend gerichtet und irgendwann kommt es zu dem Interrupt Timer-Overflow (welcher in einer passend ISR aufgefangen werden kann). Im einfachsten Fall kann man diesen Modus in folgendem Diagramm darstellen:

Der Zähler des Timers (im Diagramm oben, die aufsteigende und dann wieder zurückgesetzte Linie) ist in dem Register TCNTx gespeichert, wobei x für eine Zahl steht. Soll z.B. auf den Timer0 (siehe Datenblatt des jeweiligen Controllers) des Controllers zugegriffen werden, so ist an TCNT eine 0 anzuhängen, also TCNT0. Wie lange es braucht, bis der Zähler einen Overflow auslöst, ist von der Taktfrequenz des Controllers und von der Timerauflösung abhängig. Nun wäre es ja sehr unpraktisch, wenn wir den Zähler nicht anpassen könnten. Denn sonst müssten wir unsere Software die den Timer benutzt evtl. unpassend anpassen und viel rechnen um z.B. für 1000 ms zu schlafen. Deswegen kann auf den Zähler zugreifen und ihn vorladen bevor dieser wieder vom eigentlichen Timer hochgezählt wird. Dies veranschaulicht folgendes Diagramm:

Dadurch können man den Timer beeinflussen, und damit beeinflussen wie lange es dauert, bis ein Overflow auftritt. Um zu berechnen welchen Wert wir vorladen müssen, kann man dieses Java-Applet verwenden.

Natürlich kann man das auch „von Hand“ rechnen. Die Berechnung des Preloader- sowie Prescalerwerts bei Verwendung der Overflow-Interrupts, eines Prescalers von 64 und eines Quarzes mit der Frequenz von 8 MHz sieht folgendermaßen aus (gesuchte Frequenz beträgt 1000 Hz unter der Verwendung des Timer0 eines ATmega32):

1. [math]Prescale: Frequenz \cdot 1000000[/math]
2. Wir definieren den maximalen Zählerwert. Dieser ist bei einem 8-Bit Timer 256, bei einem 16-Bit Timer 65536. In unserem Fall ist der maximale Zählerwert 256, weil Timer0 verwendet wird [math]Max. Zaehler: 256[/math].
3. Nun wird der Wert Prescale (s.o.) durch den Prescaler geteilt ([math]{8000000 \over 32}[/math]). Das Ergebnis wird abgerundet ([math]=125000[/math]).
4. Als nächstes wird der im dritten Punkt errechnete Wert durch die gesuchte Frequenz geteilt, also [math]={1000 \over 125000}=125[/math].
5. Nun wird mathematisch überprüft, ob der errechnete Wert aus dem vierten Punkt kleiner als die der maximale Zählerwert ist. Trifft dies zu so subtrahiert man den errechneten Wert vom maximalen Zählerwert ([math]=256-125=131[/math]).

Damit hätten wir den Wert errechnet, der bei jedem Interrupt, den der Timer0 auslöst, in TCNTx (in diesem Fall TCNT0) nachgeladen werden muss, damit die Interrupts in dem gewünschten Zeitabstand von einer Millisekunde ausgelöst werden. Allerdings bleibt zu bemerken, dass es bei „ungeraden“ Frequenzen eine gewisse Ungenauigkeit geben würde, würden wir den Timer entsprechend des oben ermittelten Werts nachladen (diese Ungenauigkeit würde z.B. bei einer Quarzfrequenz von 7,3728 MHz gerundet 0,17% betragen). Wird über den Controller über einen langen Zeitraum eine Zeitmessung gemacht, so empfiehlt es sich gerade Quarzfrequenzen zu wählen.

Die Fehlerrate kann natürlich auch ausgerechnet werden. Hier die Rechenschritte (sie sind erweiternd zu der oberen Berechnung):

1. Als erstes wird mathematisch überprüft, ob der Preloaderwert (siehe fünften Schritt oben) größer als 1 ist.
2. Trifft dies zu, so wird als nächstens die resultierende Frequenz errechnet. Die geschieht folgendermaßen. Der errechnete Preloaderwert aus der Rechnung oben wird vom maximalen Zählerwert subtrahiert, anschließend mit dem Prescaler multipliziert und dann das Ganze durch Prescale geteilt ([math]\left( \frac{(256-131) \cdot 64}{8000000} \right) \cdot 1000000=1000[/math]).
3. Nun wird die gesuchte Frequenz vom errechneten Wert aus dem dritten Punkt subtrahiert und dann wiederum durch diese geteilt ([math]{1000-1000 \over 1000}=0[/math]). Damit läuft dieser Timer genau mit einer Fehlerrate von 0 %.

Betreibt man den Timer im Overflow-Modus, so muss man, wie bereits erwähnt, nach/bei jedem Overflow-Interrupt den Timer nachladen. Der Interrupt heißt in diesem Fall SIG_OVERFLOWx (x steht für die Nummer des Timers). Dieser muss in einer ISR abgefangen werden.

Zusammenfassend ein Beispielprogramm:

/* Es wird der Timer2 (8-Bit) eines ATmega32 verwendet, der mit einem Quarz mit 7,3728 MHz
betrieben wird. Im Abstand von 0,001 ms erzeugt der Timer einen Interrupt, also eine
Frequenz von 1000000 Hz (oder 100 kHz). Der Timer wird auf einen Prescaler von 1 und
einem Preloader von  183 konfiguriert.*/

volatile uint8_t countTimer2;	// Speichert den aktuellen Zählerwert

// ISR zum auffangen der Interrupts:
SIGNAL(SIG_SIG_OVERFLOW2)
{
	countTimer2++;
	TCNT2 = 183;		// Nachladen
}

// Initialisierung:
TCCR2 = (1<<CS22);		// Prescaler von 1
TCNT2  = 183;			// Vorladen
TIMSK |= (1<<TOIE2);		// Interrupts aktivieren und damit Timer starten
sei();

// Funktionen zum benutzen der Timer:
/** Diese Funktion nicht aufrufen. Wird von sleep_millisec aufgerufen.
Bei t=100 schläft die Funktion 1 ms. */
inline void sleep(uint8_t t)
{
	// countTimer2 wird in der ISR oben inkrementiert
	countTimer2 = 0;
	while (countTimer2 < t);
}

/** Schläft x-Millisekunden. */
inline void sleep_millisec(uint16_t msec)
{
	uint16_t i;
	for(i=0; i<msec; i++) {
		sleep(100);
	}
}

Allerdings wird auf diese leicht veraltete Technik nun nicht weiter eingegangen. Der Artikel wendet sich nun dem neueren „Compare Output“-Betriebsmodus zu.

Beim „Compare Output“-Betriebsmodus wird genauso ein Zähler hoch gezählt. Allerdings wird der Zählerwert nach jeder Inkrementierung mit einem, vom Benutzer festgelegten, Wert verglichen. Entspricht der Zählerwert dem gespeicherten Wert, so kommt es zu einem Interrupt. Dieser Wert wird in den Register OCRx (x steht für die Timernummer, z.B. bei Timer0 OCR0) gespeichert. Je nach Auflösung des Timers ist dieser Register 8-Bit oder 16-Bit breit. Hinweis: Siehe CTC Modus unten. Dieser wird benötigt um den Timer entsprechend im „Compare Output“-Betriebsmodus vernünftig zu betreiben.

Hier ein typisches Diagramm dieses Betriebsmodus (Hinweis: Das Diagramm wurde unter Verwendung des CTC Modus erstellt. Für Begriffserklärung siehe CTC Modus):

Das ausrechnen des Werts, der in OCRx geschrieben werden muss damit Frequenz x entsteht, ist nicht sonderlich schwer. Man geht wie bei der Berechnung des Werts für den Overflow-Modus vor (s.o.) nur das man das resultierende Ergebnis vom maximalen Zählerwert (bei 8-Bit Auflösung ist dieser 256, bei 16-Bit Auflösung 65536) subtrahiert. Das Ergebnis wird dann einmalig in den Register OCRx geschrieben. Mann muss also nicht wie beim Overflow-Modus den Timer nach jedem Interrupt nachladen. Der enstehende Interrupt heißt in diesem Fall SIG_OUTPUT_COMPAREx (x steht für die Nummer des Timers). Dieser muss in einer ISR abgefangen werden.

Wiederum zusammenfassend ein Beispielprogramm:

/* Es wird der Timer2 (8-Bit) eines ATmega32 verwendet, der mit einem Quarz mit 7,3728 MHz
betrieben wird. Im Abstand von 0,001 ms erzeugt der Timer einen Interrupt, also eine Frequenz
von 1000000 Hz (oder 100 kHz). Der Timer wird auf einen Prescaler von 1 und einem OCR2-Wert
von 73 konfiguriert.*/

volatile uint8_t countTimer2;	// Speichert den aktuellen Zählerwert

// ISR zum auffangen der Interrupts:
SIGNAL(SIG_OUTPUT_COMPARE2)
{
  countTimer2++;
}

// Initialisierung:
TCCR2 = (1<<CS22) | (1<<WGM21);	// Prescaler von 1 | CTC-Modus (siehe unten für Beschreibung)
OCR2  = 73;			// Vergleichswert
TIMSK |= (1<<OCIE2);		// Interrupts aktivieren und damit Timer starten
sei();

// Funktionen zum benutzen der Timer:
/** Diese Funktion nicht aufrufen. Wird von sleep_millisec aufgerufen.
Bei t=100 schläft die Funktion 1 ms. */
inline void sleep(uint8_t t)
{
	// countTimer2 wird in der ISR oben inkrementiert
	countTimer2 = 0;
	while (countTimer2 < t);
}

/** Schläft x-Millisekunden. */
inline void sleep_millisec(uint16_t msec)
{
	uint16_t i;
	for(i=0; i<msec; i++) {
		sleep(100);
	}
}

CTC Modus (Clear Timer on Compare Match mode)

Der CTC Modus ist eine Erweiterung zum „Compare Output“-Betriebsmodus. Der CTC Modus wird z.B. für das obere Beispielprogramm benötigt. Wird der Timer nämlich im normalen Betriebsmodus betrieben, so ist seine Zählergrenze je nach Auflösung 255 oder entsprechend für die 16-Bit Timer. Erst wenn diese Grenze erreicht wurde, wird der Timer zurückgesetzt (also auf 0). Durch den CTC Modus wird der Timer augenblicklich automatisch nachdem ein „Compare Output“-Interrupt auftrat zurückgesetzt. Man kann also die maximalen Zählergrenze selber definieren. Dieses Diagramm veranschaulicht den CTC Modus. Nach dem Interrupt wird der Timer sofort wieder zurückgesetzt.

PWM

Für PWM siehe Pwm.

Registerübersicht

--Luma 01:17, 10. Dez 2005 (CET)

Die Fusebits

Fusebits nennt man bestimmte Bits zur Konfigurierung eines AVR-Controllers. Bei der Auslieferung neuer AVR Controller sind die Fusebits bereits vorkonfiguriert. In vielen Fällen kann man die Konfiguration unverändert belassen, je nach Controllertyp. Bei den Typen Mega xxx bestimmen einige Fusebits beispielsweise, dass der interne Taktgeber aktiviert ist. Möchte man dagegen einen externen Quarz anschließen oder die Taktfrequenz ändern, so müssen auch die Fusebits geändert werden. Auch das Deaktivieren des "On Chip Debugging" Modus ist oft notwendig, wenn man alle Ports ausnutzen möchte.

Die Fusebits werden in der Regel über die Software eingestellt, welche auch für das Übertragen des Programmcodes zuständig ist. Besonders einfach geht dies beispielsweise mit der Entwicklungsumgebung Bascom. Aber auch andere Programme wie PonyProg können für die Umstellung der Fusebits genutzt werden. Einmal eingestellte Fusebits bleiben bis zur erneuten Fusebit-Änderung erhalten. Der normale Programmiermodus verändert die Fusebits nicht.

Je nach AVR Controllertyp sind unterschiedliche Fusebits (Einstellungen) vorhanden. Die genaue Beschreibung findet man im jeweiligen Datenblatt. Da aber falsch gesetzte Fusebit-Einstellungen zu den häufigsten Problemen gehören, liste ich hier die Funktion der üblichen Fusebits nochmals genauer auf:

Wie man die Fusebits mit Bascom einstellt, wird im Beitrag Bascom - Erstes Programm in den AVR Controller übertragen erläutert.

--Frank 19:49, 29. Nov 2005 (CET)

Siehe auch

• AVR-ISP Programmierkabel - Bauanleitung für die AVR Controller Programmierkabel
• RN-Control - Eines der beliebtestet AVR-Boards im Roboternetz
• RNBFRA-Board - Größeres Board mit zwei Atmel Controllern
• Bascom - Sehr gutes Basic-Entwicklungssystem
• Bascom - Erstes Programm in den AVR Controller übertragen
• avr-gcc - Leistungsfähiger AVR-Port des freien Compilers GCC
• On Chip Debugging
• Bootloader

Weblinks

• Aktuelle AVR Vergleichstabelle]
• Die Datenblätter zu Atmel Controllern

Siehe auch

• Atmel