Mikrocontroller.net - Benutzerbeiträge [de]

Halbleiter

2004-11-25T14:28:44Z

Oxygene: Umlaute sind von der Rechtschreibreform noch nicht betroffen ;)

== Eigenschaften ==

Halbleiter besitzen eine geringere Leitfähigkeit als normale Metalle, was an der viel niedrigeren Ladungsträgerkonzentration liegt. Ein weiteres Merkmal ist, dass die Leitfähigkeit im Gegensatz zu Metallen mit der Temperatur steigt (Heissleiter), da durch die Temperaturerhöhung mehr Ladungsträger aktiviert werden.

Wichtige Halbleitermaterialien:
* Si, GaAs, InP, Ge, GaP, InSb, SiC, GaN

== Dotieren ==

Um die Ladungsträgerkonzentration und damit die Leitfähigkeit von Halbleitern zu erhöhen, bringt man gezielt Fremdatome in das Material ein; diesen Vorgang nennt man "Dotieren". Bei den Fremdatomen unterscheidet man zwischen "Donatoren", die ein Elektron zur Verfügung stellen, und "Akzeptoren", die ein Elektron aufnehmen können (bzw. ein "Loch" zur Verfügung stellen. Einen überwiegend mit Donatoren dotierten Halbleiter bezeichnet man als n-Halbleiter, einen überwiegend mit Akzeptoren dotierten als p-Halbleiter. Undotierte Halbleiter werden auch "intrinsische Halbleiter" genannt.

Üblicherweise zum Dotieren verwendete Elemente:

*Donatoren: P, As, Sb, Si, S
*Akzeptoren: B, Al, Ga, C, Si, Mn

(Si kann in GaAs je nach Einbauplatz als Donator oder Akzeptor wirken)

== Anwendung ==

Die gesamte Halbleiterelektronik beruht auf Halbleitern - daher wohl auch der Name. Nahezu alle aktiven Bauelemente sind Halbleiter:

*[[Diode]]
*[[Transistor]]
*hochintegrierte Schaltungen [[IC]]
*und natürlich die hier besonders interessierenden [[Mikrocontroller]]

AVR-GCC-Tutorial

2004-11-18T16:50:17Z

Oxygene: /* EEPROM */ typos

[[Category:AVR]]

= Vorwort =

Dieses Tutorial soll Einsteigern helfen, mit der Programmiersprache '''C''' die Mikrocontroller der Atmel AVR-Reihe zu programmieren.


Die ursprüngliche Version stammt von Christian Schifferle, die meisten aktuellen Anpassungen von [[Benutzer:Mthomas]]. Viele der im Original-Dokument verwendeten Funktionen sind in
aktuellen Versionen des avr-gcc C-Compilers und der avr-libc zwar noch enthalten,
aber als überholt (''deprecated'') ausgewiesen. D.h. diese Funktionen sollten nicht mehr verwendet
werden und existieren in zukünftigen Versionen des Compilers/der Library nicht mehr
(z.B. sbi(), cbi(), outp(), inp()). Der Artikel wurde auf die neuen Funktionen/Methoden
angepasst.

In diesem Text wird häufig auf die Standardbibliothek für den avr-gcc-Compiler, die avr-libc, verwiesen. Die '''Dokumentation der avr-libc''' findet sich
[http://www.nongnu.org/avr-libc/user-manual/index.html hier]. Bei WinAVR gehört diese Dokumentation zum Lieferumfang und wird mitinstalliert.

= Benötigte Werkzeuge =

Um die Übungen in diesem Tutorial nachvollziehen zu können benötigen wir folgende Hard- und Software:

* Testboard für die Aufnahme eines AVR Controllers, der vom gcc Compiler untersützt wird (alle ATmegas und die meisten AT90). Dieses Testboard kann durchaus auch selber zusammen gelötet werden. So arbeite ich mit einem Testboard, welches ich mir auf einer Veroboard-Platine zusammen gestellt habe. Für die Versuche bzw. Übungen in diesem Tutorial habe ich jeweils einen AT90S2313 verwendet. Eine brauchbare Testplattform ist auch der [[AVR Butterfly]].
* AVRGCC-Compiler. Kostenlos erhältlich für nahezu alle Plattformen/Betriebssysteme. Für MS-Windows im Packet [[WinAVR]]; für Unix/Linx siehe auch Hinweise im Artikel [[AVR-GCC]].
* Programmiersoftware und Hardware z.B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], [[AVR-Studio]]).
* Nicht unbedingt erforderlich aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Abschnitt Exkurs: makefiles).

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.
* Die [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently Asked Questions = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.
* Das gcc-Forum auf [http://www.mikrocontroller.net www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.
* Das avr-gcc-Forum bei [http://www.avrfreaks.net avrfreaks] nach vergleichbaren Problemen absuchen.
* Das [http://www.avr1.org/pipermail/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.
* Nach Beispielcode suchen. Vor allem in der Academy von [http://www.avrfreaks.net AVRFREAKS] (anmelden).
* Google oder alltheweb befragen schadet nie.
* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal)
* einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei mgl. viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode, genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z.B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: [http://www.lugbz.org/documents/smart-questions_de.html "Wie man Fragen stellt"].

= Exkurs: makefiles =

Wenn man bisher gewohnt ist, mit integrierten Entwicklungsumgebung à la Visual-C Programme zu erstellen, wirkt das makefile-Konzept auf den ersten Blick etwas kryptisch. Nach kurzer Einarbeitung ist diese Vorgehensweise jedoch sehr praktisch. Diese Dateien (üblicher Name: 'Makefile' ohne Dateiendung) dienen der Ablaufsteuerung des Programms make, das auf allen Unix/Linux-Systemen installiert sein sollte, und in einer Fassung fuer MS-Windows auch in [[WinAVR]] (Unterverzeichnis utils/bin) enthalten ist.

Im Unterverzeichnis ''sample'' einer WinAVR-Installation findet man eine sehr brauchbare Vorlage, die sich einfach an das eigene Projekt anpassen lässt ([[Media:Makefile|lokale Kopie Stand Sept. 2004]]). Wahlweise kann man auch [http://www.sax.de/~joerg/mfile/ mfile] von Jörg Wunsch nutzen. mfile erzeugt ein makefile nach Einstellungen in einer grafischen Nutzeroberfläche, wird bei WinAVR mitinstalliert, ist aber als TCL/TK-Programm auf nahezu allen Platformen lauffähig.

''Die folgenden Ausführungen beziehen sich auf das WinAVR Beispiel-Makefile.''

Ist im Makefile alles richtig eingestellt genügt es, sich drei Parameter zu merken, die über die shell bzw. die Windows-Kommandozeile (cmd.exe/command.exe) als Parameter an "make" übergeben werden. Das Programm make sucht sich "automatisch" das makefile im aktuellen Arbeitsverzeichnis und führt die darin definierten Operationen für den entsprechenden Aufrufparameter durch.

{| border=1
| ''make all''
| Erstellt aus den in im makefile angegebenen Quellcodes eine ''hex''-Datei (und ggf. auch ''eep''-Datei).
|-
| ''make program''
| Überträgt die hex-Datei (und wahlweise auch die eep-Datei für den EEPROM) zum AVR.
|-
| ''make clean''
| löscht alle temporären Dateien, also auch die hex-Datei
|}

Diese Aufrufe können in die allermeisten Editoren in "Tool-Menüs" eingebunden werden. Dies erspart den Kontakt mit der Kommandozeile. (Bei WinAVR sind die Aufrufe bereits im Tools-Menü des mitgelieferten Editors Programmers-Notepad eingefügt.)

Üblicherweise sind folgende Daten im makefile anzupassen:
* Controllertyp
* Quellcode-Dateien (c-Dateien)
* Typ und Anschluss des Programmiergeräts

seltener sind folgende Einstellungen durchzuführen:
* Grad der Optimierung
* Methode zur Erzeugung der Debug-Symbole (Debug-Format)
* Assembler-Quellcode-Dateien (S-Dateien)

Die in den folgenden Unterabschnitten gezeigten makefile-Ausschnitte sind für ein Programm, das auf einem ATmega8 ausgeführt werden soll. Der Quellcode besteht aus den c-Dateien superprog.c (darin main()), uart.c, lcd.c und 1wire.c. Im Quellcodeverzeichnis befinden sich diese Dateien: superprog.c, uart.h, uart.c, lcd.h, lcd.c, 1wire.h, 1wire.c und das makefile (die angepasste Kopie des WinAVR-Beispiels).

Der Controller wird mittels [[AVRDUDE]] über ein [[STK200]]-Programmierdongle an der Schnittstelle lpt1 (bzw. /dev/lp0) programmiert. Im Quellcode sind auch Daten für die ''section .eeprom'' definiert (siehe Abschnitt Speicherzugriffe TODO: nach unten verlinken), diese sollen beim Programmieren gleich mit ins EEPROM geschrieben werden.

== Controllertyp setzen ==

Dazu wird die "make-Variable" MCU entsprechend dem Namen des verwendenten Controllers gesetzt. Ein Liste der von avr-gcc und der avr-libc untersützten Typen findet sich in der [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc].

<pre class="code">
# Kommentare in Makefiles beginnen mit einem Doppelkreuz
...

# ATmega8 at work
MCU = atmega8
# oder MCU = atmega16
# oder MCU = at90s8535
# oder ...
...
</pre>

== Quellcode-Dateien einstellen ==

Den Namen der Quellcodedatei welche die Funktion main enthält, wird hinter TARGET eingetragen. Dies jedoch ohne die Endung ''.c''.

<pre class="code">
...
TARGET = superprog
...
</pre>

Besteht das Projekt wie im Beispiel aus mehr als einer Quellcodedatei, sind die weiteren c-Dateien (nicht die Header-Dateien, vgl. [[Include-Files (C)]]) durch Leerzeichen getrennt bei SRC einzutragen. Die bei TARGET definierte Datei ist schon in der SRC-Liste enthalten. Diesen Eintrag nicht löschen!

<pre class="code">
...
SRC = $(TARGET).c uart.c lcd.c 1wire.c
...
</pre>

Alternativ kann man die Liste der Quellcodedateien auch mit dem Operator += erweitern.

<pre class="code">
SRC = $(TARGET).c uart.c 1wire.c
# lcd-Code fuer Controller xyz123 (auskommentiert)
# SRC += lcd_xyz.c
# lcd-Code fuer "Standard-Controller" (genutzt)
SRC += lcd.c
</pre>

== Programmiergerät einstellen ==

Die Vorlagen sind auf die Programmiersoftware [[AVRDUDE]] angepasst, jedoch lässt sich auch andere Programmiersoftware einbinden, sofern diese über Kommandozeile gesteuert werden kann (z.B. stk500.exe, uisp, sp12).

<pre class="code">
...
# Einstellung fuer STK500 an com1 (auskommentiert)
# AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
# AVRDUDE_PORT = com1 # programmer connected to serial device

# Einstellung fuer STK200-Dongle an lpt1
AVRDUDE_PROGRAMMER = stk200
AVRDUDE_PORT = lpt1
...
</pre>

Sollen Flash(=.hex) und EEPROM(=.eep) zusammen auf den Controller programmiert werden, ist das Kommentarzeichen vor AVRDUDE_WRITE_EEPROM zu löschen.

<pre class="code">
...
#Auskommentiert: EERPOM-Inhalt wird nicht mitgeschrieben
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

#Nich-auskommentiert EERPOM-Inhalt wird mitgeschrieben
AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
...
</pre>

== Anwendung ==

Die Eingabe von ''make all'' im Arbeitsverzeichnis mit dem makefile und den Quellcodedateien erzeugt (unter anderem) die Dateien superprog.hex und superprog.eep. Abhängigkeiten zwischen den einzelnen c-Dateien werden dabei automatisch berücksichtigt. Die ''superprog.hex'' und ''superprog.eep'' werden mit ''make program'' zum Controller übertragen. Mit ''make clean'' werden alle temporären Dateien gelöscht (="aufgeräumt").

== Sonstige Einstellungen ==

=== Optimierungsgrad ===

Der gcc-Compiler kennt verschiedene Stufen der Optimierung. Nur zu Testzwecken sollte die Optimierung ganz deaktiviert werden (''OPT = 0''). Die weiteren möglichen Optionen weisen den Compiler an, möglichst kompakten oder möglichst schnellen Code zu erzeugen. In den weitaus meisten Fällen ist ''OPT = s'' die optimale (sic) Einstellung, damit wird kompakter und oft auch der "schnellste" Maschinencode erzeugt.

=== Debug-Format ===

Unterstützt werden die Formate stabs und dwarf-2. Das Format wir hinter ''DEBUG ='' eingestellt. Siehe dazu Abschnitt ''Eingabedateien zur Simulation''.

=== Assembler-Dateien ===

Die im Projekt genutzten Assembler-Dateien werden hinter ASRC durch Leerzeichen getrennt aufgelistet. Assembler-Dateien haben immer die Endung .S (grosses S). Ist zum Beispiel der Assembler-Quellcode eines Software-UARTs in einer Datei softuart.S enthalten lautet die Zeile: ''ASRC = softuart.S''

== Eingabedateien zur Simulation in AVR-Studio ==

Mit älteren AVR-Studio-Versionen kann man nur auf Grundlage sogenannter ''coff''-Dateien simulieren. Neuere Versionen von AVR-Studio (ab 4.10.356) unterstützen zudem das modernere aber noch experimentelle dwarf-2-Format, das ab WinAVR 20040722 (avr-gcc 3.4.1/Binutils inkl. Atmel add-ons) "direkt" vom Compiler erzeugt wird.

; Vorgehensweise bei extcoff:
* im Makefile bei DEBUG: <pre class="code">DEBUG=stabs</pre>
* ''make extcoff'' (evtl. vorher ''make clean'')
* die erzeugte ''cof''-Datei (im Beispiel oben ''superprog.cof'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

; Vorgehensweise bei dwarf-2:
* im Makefile bei DEBUG: <pre class="code">DEBUG=dwarf-2</pre>
* ''make all'' (evtl. vorher ''make clean'')
* die erzeugte ''elf''-Datei (im Beispiel oben ''superprog.elf'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

Beim Simulieren scheinen oft "Variablen zu fehlen". Ursache dafür ist, dass der Compiler die "Variablen" direkt Registern zuweist. Dies kann vermieden werden, indem die Optimierung abgeschaltet wird (im makefile). Man simuliert dann jedoch ein vom optimierten Code stark abweichendes Programm. Das Abschalten der Optimierung wird nicht empfohlen.

Statt des Software-Simulators kann das AVR-Studio auch genutzt werden, um mit dem ATMEL JTAGICE, ein Nachbau davon (BootICE, Evertool o.ä.) oder dem ATMEL JTAGICE MKII "im System" zu debuggen. Dazu sind keine speziellen Einstellungen im makefile erforderlich. Debugging bzw. "In-System-Emulation" mit dem JTAGICE und JTAGICE MKII sind in der AVR-Studio Online-Hilfe beschrieben.

= Definition einiger Datentypen =

Für die Programmierung von Mikrocontrollern ist es sinnvoll, dass wir uns
vorerst einige Datentypen definieren, welche den Zugriff auf die verschiedenen
Komponenten des Controllers vereinfachen oder wenigstens das Programm lesbarer
machen können.

<pre class="code">
typedef unsigned char BYTE;
typedef unsigned short WORD;
</pre>

== BYTE ==

Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 255.

== WORD ==

Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 65535.

== DWORD ==

Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

== QWORD ==

Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

Bei allen vorgenannten Datentypen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z.B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich daher, die im folgenden Abschnitt beschriebenen standardisierten Datentypen zu nutzen und damit "Missverständnissen" vorzubeugen, die z.B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

= Standardisierte Integer(Ganzzahl)-Typen =

Standardisierte Datentypen werden in der Header-Datei inttypes.h definiert.
Will man diese Typen benutzen, bindet man die "Definitionsdatei" wie folgt ein:

<pre class="code">
#include <inttypes.h>
</pre>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<pre class="code">
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
</pre>

Ein Vierfach-Wort (64Bit) entspricht beim AVR ''uint64_t'', ein Doppel-[[Word|Wort]] (32bit) entspricht ''uint32_t'', ein Wort (16bit) entspricht ''uint16_t'' und ein [[Byte]] (8bit) entspricht ''uint8_t''.
Die Typen ohne vorangestelltes ''u'' können auch vorzeichenbehaftete Zahlen speichern. ''int8_t'' geht also von -128 bis 127, ''uint8_t'' dagegen geht von 0 bis 255.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Integer Types

== '''Bitfelder''' ==

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bit breit ist. 
Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in einer einzelnen Bytevariable zusammen fassen und (fast) wie
8 einzelne Variablen ansprechen können. 
Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente
definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<pre class="code">
struct {
unsigned char bStatus_1:1; // 1 Bit für bStatus_1
unsigned char bStatus_2:1; // 1 Bit für bStatus_2
unsigned char bNochNBit:1; // Und hier noch mal ein Bit
unsigned char b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</pre>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<pre class="code">
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</pre>

(mt Empfehlung: Bitfelder sparen zwar Platz, verschlechtern aber unter
Umständen die Les- und Wartbarkeit des Codes. Anfängern wird geraten,
ein "ganzes" ein Byte (uint8_t) zu nutzen auch wenn nur ein Bitwert gespeichert
werden soll.)

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten
Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher
Dinge erledigt werden können, welche nicht zeitkritisch sind. 
Wenn ein Interrupt ausgelöst wird so wird automatisch die zugeordnete
Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Allgemeiner Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heisst, das Programm kann die
Inhalte der Register auslesen und beschreiben. 
Einige Register haben spezielle Funktionen, andere wiederum könne für
allgemeine Zwecke (Speichern von Datenwerten) verwendet werden.

Einzelne Register sind bei allen AVR's vorhanden, andere wiederum nur bei
bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff
auf den UART notwendig sind selbstverständlich nur bei denjenigen Modellen
vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden
AVR-Typen definiert. 

Wenn im Makefile der MCU-Typ definiert ist, wird vom System automatisch die
zum Typen passende Definitionsdatei genutzt, sobald man im Code die allgemeine
"io.h" Header-Datei einbinden.

<pre class="code">
#include <avr/io.h>
</pre>

Ist im Makefile der MCU Type z.B. mit dem Inhalt atmega8 definiert,
wird beim einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit
den Register-Definitionen für den ATmega8 eingelesen.



== I/O-Register ==

Die I/O-Register haben einen besonderen Stellenwert bei den AVR Controllern.
Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. 
Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir mal
die 8-Bit Register.


=== Lesen eines I/O-Registers ===



Zum Lesen kann man auf I/O Register einfach wie auf eine
Variable zugreifen. Die spezielle Funktion inp() ist nicht mehr
notwendig und veraltet.

Beispiel:

<pre class="code">
#include <avr/io.h>
uint8_t foo;
...
int main(void)
{
foo=PINB; /* kopiert den Status der Eingabepins an PortB in die Variable foo */
...
}
</pre>

==== Lesen eines Bits ====

Die AVR-Bibliothek stellt auch Funktionen zur Abfrage eines einzelnen Bits
eines Registers zur Verfügung:

;bit_is_set (<Register>,<Bitnummer>) : Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 4 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>) : Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen bit_is_clear bzw. bit_is_set sind nicht unbedingt erfoderlich, man kann auch "einfachen" C-Syntax verwenden. Der universell verwendbar ist. ''bit_is_set'' entspricht dabei z.B. (Variable & (1<<Bitnummer)). Das Ergebnis ist <>0 wenn das Bit gesetzt und 0 wenn nicht gesetzt ist.

* siehe auch [[Bitmanipulation]]

=== Schreiben eines I/O-Registers ===



Zum Schreiben kann man I/O Register einfach wie eine
Variable setzen. Die spezielle Funktion outp() ist nicht mehr
notwendig, veraltet und sollte nicht mehr genutzt werden.

Beispiel:

<pre class="code">
#include <avr/io.h>
...
int main(void)
{
DDRA=0xff; /* Setzt das Richtungsregister des Ports A auf 0xff (alle Pins als Ausgang) */
PORTA=0x03; /* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low" */
...
}
</pre>

==== Schreiben eines Bits ====



Einzelne Bits setzt man "Standard-C-Konform" mittels logischen (bit-) Operationen.

mit dem Ausduck |=(1<<Bitnummer) wird ein Bit gesetzt, mit dem Ausdruck
&=~(1<<Bitnummer) wird ein Bit geloescht. Die Funktionen sbi und cbi sind
dazu nicht notwendig, veraltet und sollten nicht mehr genutzt werden.

Beispiel:
<pre class="code">
...
#define MEINBIT 2
...
PORTA |= (1<<MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1<<MEINBIT); /* loescht Bit 2 an PortA */
</pre>

* siehe auch:
** [[Bitmanipulation]]
** [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

=== Warten auf einen bestimmten Zustand ===

Es gibt in der Bibliothek sogar Funktionen, die Warten, bis ein bestimmter
Zustand auf einem Bit erreicht ist. 
Es ist allerdings normalerweise eine eher unschöne Programmiertechnik.

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das
definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits
gesetzt ist wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT 2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1<<WARTEBIT)) ) ;
</pre>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das
definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits
gelöscht ist wird die Funktion sofort wieder verlassen. 
Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT 4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// ungleich 0 ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
</pre>

Universeller und auch auf andere Platformen besser übertragbar ist die Verwendung von C-Standardoperationen.

siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]



= Zugriff auf Ports =

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind
jedem Port 3 Register zugeordnet:

{| border="1"
|-
| '''DDRx'''
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (anhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
| '''PORTx'''
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Wird ein Port als Eingang geschaltet, so können mit diesem Register
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|-
| '''PINx'''
| Eingangadresse für Port'''x'''.

Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der Portspins. Bit gesetzt (1) wenn Pin "high/an", Bit gelöscht (0) wenn Portpin "low/aus".
|}

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.


Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Wollen wir also beispielsweise Pin 0 bis 4 von Port B als Ausgänge
definieren so schreiben wir folgende Zeile:


<pre class="code">
#include <avr/io.h>
...
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F

DDRB=0x1F; /* direkte Zuweisung - unuebersichtlich */
/* mehr Tipparbeit aber uebersichtlicher: */
DDRB=(1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3)|(1<<DDB4);
...
</pre>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet.

=== Ganze Ports ===

Um einen ganzen Port als Ausgang zu definieren, kann der folgende Befehl
verwendet werden:

<pre class="code">
DDRB=0xff;
</pre>

Im Beispiel wird der Port B als Ganzes als Ausgang geschaltet.

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen
bzw. auszugeben.

== Ausgänge ==

Wir wollen nun einen als Ausgang definierten Pin auf Logisch 1 setzen. Dazu schreiben wir den entsprechenden Wert in das Portregister des entsprechenden Ports.

Mit dem Befehl

<pre class="code">
PORTB=0x04; /* besser PORTB=(1<<DDB2) */
</pre>

wird also der Ausgang an Pin 2 gesetzt (Beachte, dass die Bits immer ''von 0 an''
gezählt werden, das niederwertigste Bit ist also Bit 0 und nicht etwa Bit 1).

Man beachte bitte, dass bei der Zuweisung mittels '''='''  immer alle Pins gleichzeitig angegeben werden. Man sollte also zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfliessen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an PortB auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<pre class="code">
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<DDB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<DDB2)
</pre>


Die Funktionen cbi und sbi sind dazu nicht notwendig, veraltet und sollten
nicht mehr genutzt werden.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wird den Pegel über entsprechende Hardware (z.B. Optokoppler, Spannunsteiler "Levelshifter") anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unserer Controllers eine logische 1 (Vcc) oder eine logische 0 (Masse) anliegt.

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.



Wobei es hier sehr wichtig ist, zur Abfrage der Eingänge nicht etwa das Portregister '''PORTx''' zu verwenden, sondern die Porteingangsadresse '''PINx'''. Dies ist
ein oft gemachter Fehler!

Wollen wir also die aktuellen Signalzustände von Port D abfragen und in einer
Variable namens bPortD abspeichern so schreiben wir dazu folgende Befehlszeile:

<pre class="code">
#include <avr/io.h>
...
bPortD = PIND;
...
</pre>


=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen (''Active Low'' und ''Active High''):

{| border="1"
|-
| '''Active Low'''
| '''Active High'''
|-
| [[Image:Active Low.gif]]
| [[Image:Active High.gif]]
|-
| Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet.

Damit bei offenem Schalter der Controller kein undefiniertes Signal
bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein
sogenannter Pull-Up Widerstand geschaltet. Dieser dient dazu, den Pegel
bei geöffnetem Schalter auf logisch 1 zu ziehen. 
Der Widerstandswert des Pull-Up Widerstands ist an sich nicht kritisch. Es
muss jedoch beachtet werden, dass über den Widerstand ein Strom in den
Eingang fliesst, also sollte er nicht zu klein gewählt werden um den
Controller nicht zu zerstören. Wird er allerdings zu hoch gewählt ist
die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10
Kiloohm eingebürgert.

Die AVR's haben sogar an den meisten Pins softwaremässig zuschaltbare
interne Pull-Up Widerstände, welche wir natürlich auch verwenden
können.
| Hier wird der Kontakt zwischen die Versorgungsspannung und Masse geschaltet.

Damit bei offener Schalterstellung kein undefiniertes Signal am Controller
ansteht, wird zwischen den Eingangspin und die Masse ein Pull-Down
Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter
Schalterstellung auf logisch 0 zu halten.
|}

==== Pull-Up Widerstände aktivieren ====

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden
über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang'''
geschaltet ist. 

Wird der Wert des entsprechenden Portpins auf 1 gesetzt so ist
der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up
Widerstand nicht aktiv. 
Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand
verwenden, aber nicht beide zusammen.



<pre class="code">
#include <avr/io.h>
...
DDRD=0x00; /* alle Pins von Port D als Eingang */
PORTD=0xff: /* interer Pull-Up an allen Port-Pins aktivieren */
...
</pre>

Im Beispiel wird der gesamte Port D als Eingang geschaltet und alle Pull-Up
Widerstände aktiviert.

===== Tastenentprellung =====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von
Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim
Schliessen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern
mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes. 
Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein
solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen
als mehrfache Impulse gezählt wird. 
Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen
werden.

ToDo Bsp Quellcode

== Analog ==

Leider können wir mit unseren Controllern keine analogen Werte direkt
ausgeben oder einlesen. Dazu müssen wir Umwege gehen, doch dies wird in einem späteren
Kapitel behandelt.

=== 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1) ===

Einige der Portregister in den AVR-Controllern sind 16 Bit breit, Man spricht
dann von einem '''Wort'''.


Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<pre class="code">
#include <avr/io.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8

= Der UART, Teil 1 =

Wir werden in zukünftigen Übungen in die Situation kommen, dass wir
Informationen vom Controller auswerten bzw. anzeigen müssen wobei es vielleicht
dann nicht mehr reicht, ein paar Leuchtdioden anzusteuern. 
Somit brauchen wir eine Verbindung vom AVR zu unserem PC, und dies am besten
über die serielle Schnittstelle.

== Allgemeines zum UART ==

Einige AVR-Controller haben einen vollduplexfähigen UART ('''U'''niversal
'''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut.
Dies ist eine wirklich feine Sache, haben wir doch damit schon das nötige
Werkzeug, um mit anderen Geräten, welche über eine serielle Schnittstelle
verfügen (insbesondere mit unserem PC), zu kommunizieren.

Übrigens: Vollduplex heisst nichts anderes, als dass der Baustein gleichzeitig
senden und empfangen kann.

Neuere AVRs (ATmega) verfügen über einen oder zwei U'''S'''ART(s), dieser unterschiedet sich vom UART häuptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

Der UART wird über vier separate Register angesprochen. USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurations/Datenregister. Das Datenblatt gibt darüber Auskunft. Die Folgende Tabelle gibt nur die Register für die (veralteten) UARTs wieder.

{| border="1"
|-
| '''UCR   '''
| '''U'''ART '''C'''ontrol '''R'''egister. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXCIE'''
| align="center" | '''TXCIE'''
| align="center" | '''UDRIE'''
| align="center" | '''RXEN'''
| align="center" | '''TXEN'''
| align="center" | '''CHR9'''
| align="center" | '''RXB8'''
| align="center" | '''TXB8'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''CHR9''' (9 Bit Characters)
:Wenn dieses Bit gesetzt ist, können 9 Bit lange Zeichen übertragen und empfangen werden. Das 9. Bit kann bei Bedarf als zusätzliches Stopbit oder als Paritätsbit verwendet werden. Man spricht dann von einem 11-Bit Zeichenrahmen:
:1 Startbit + 8 Datenbits + 1 Stopbit + 1 Paritätsbit = 11 Bits

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.

|-
| '''USR   '''
| '''U'''ART '''S'''tatus '''R'''egister. 
Hier teilt uns der UART mit, was er gerade so macht.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXC'''
| align="center" | '''TXC'''
| align="center" | '''UDRE'''
| align="center" | '''FE'''
| align="center" | '''OR'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt bevor ein weiteres Zeichen komplett empfangen wurde wird eine Überlauf-Fehlersituation eintreffen. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, wenn die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit wird vom AVR gesetzt, wenn ein Zeichen vom Sendedatenregister in das Send-Schieberegister übernommen wurde und der UART nun wieder bereit ist, ein neues Zeichen zum Senden aufzunehmen.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''OR''' ('''O'''ver'''R'''un) 
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne
kommunizieren möchten. Der Wert, der in dieses Register geschrieben
werden muss, errechnet sich nach folgender Formel:

<math>
\begin{matrix}
UBRR = \frac{Taktfrequenz}{Baudrate * 16} - 1
\end{matrix}
</math>

Es sind Baudraten bis zu 115200 Baud und höher möglich.
|}

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (LOW) und 5V (HIGH). Die
Schnittstellenspezifikation für RS232 definiert jedoch -3V ... -12V (LOW) und
+3 ... +12V (HIGH). Zudem muss der Signalaustausch zwischen AVR und
Partnergerät invertiert werden. Für die Anpassung der Pegel und das
Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste
davon ist wohl der MAX232. Allerdings kostet der auch wieder Geld und benötigt
zusätzlich immerhin 4 externe Elkos.

Die in den PC eingebauten Schnittstellen vertragen ohne Klagen auch den
TTL-Pegel vom AVR. Allerdings müssen wir immer noch die Signale invertieren. Im
einfachtesn Fall verwenden wir dazu jeweils einen einfachen NPN-Transistor und 2
Widerstände. Näheres dazu erfahrt ihr in den folgenden Übungen.

Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z.B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfielt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Senden mit dem UART ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. 
Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach
gewünschter Funktionsweise die
benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister. 
Da wir vorerst nur senden möchten und (noch) keine Interrupts auswerten wollen,
gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das
'''Transmitter Enable''' Bit setzen müssen:


<pre class="code">
UCR |= (1<<TXEN);
</pre>

Der Atmega16 hat mehrere Konfigurationsregister für USART und erfordert eine etwas andere Konfiguration

<pre class="code">
UCSRB |= (1<<TXEN); //UART TX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1
</pre>

Nun müssen wir noch die Baudrate festlegen. Gemäß unserer Formel brauchen
wir dazu die Taktfrequenz des angeschlossenen Oszillators bzw. Quarz in die
Formel einzufügen und das Resultat der Berechnung in das Baudratenregister des
UART einzuschreiben:

<pre class="code">
/* UART-Init beim AT90S2313 */
#define F_CPU 4000000; // Zum Beispiel 4Mhz-Quarz
#define UART_BAUD_RATE 9600 // Wir versuchen mal mit 9600 Baud
UBRR = F_CPU / (UART_BAUD_RATE * 16L) - 1;
</pre>

Wieder für den Mega16 mit einem 16bit-Register eine andere Programmierung

<pre class="code">
/* USART-Init beim ATmegaXX */
#define F_OSC 3686400 /* Oszillator-Frequenz in Hz */
#define UART_BAUD_RATE 9600
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)

UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

/* alternativ bei der avr-libc "direkt 16bit" : */
UBRR=UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);
</pre>

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben.

<pre class="code">
while (!(USR & (1<<UDRE))); /* warten bis Senden moeglich */
UDR = 'x'; /* Schreibt das Zeichen x auf die Schnittstelle */
</pre>

=== Schreiben einer Zeichenkette (String) ===

Es ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

Zu diesem Zweck können wir uns für's Erste eine einfache Funktion basteln:

<pre class="code">
void
uart_putc(unsigned char c)
{
while(!(USR & (1 << UDRE)))
; /* warte, bis UDR bereit */

UDR = c; /* sende Zeichen */
}

void
uart_puts (char *s)
{
while (*s)
{ /* so lange *s != NULL */
uart_putc(*s);
s++;
}
}
</pre>

Warteschleifen sind insofern etwas kritisch, da während des Sendens eines
Strings nicht mehr auf andere Ereignisse reagieren werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. emfangenen Zeichen/Bytes zwischengespeichert und mittels Interruptroutinen an den U(S)ART weitergebgen bzw. ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

* siehe auch: Weiterführende Informationen inkl. Beispielen für die Nutzung von stdio-Funktionen (prinf etc.) im [[AVR-Tutorial - UART]].
* [http://homepage.sunrise.ch/mysunrise/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc

= Analoge Ein- und Ausgabe =

Leider können wir mit unseren Controllern keine analogen Werte direkt
verarbeiten. Dazu bedarf es jeweils einer Umwandlung des analogen Signals in
einen digitalen Zahlenwert. Je nachdem, ob wir Daten einlesen oder ausgeben
wollen reden wir dabei von '''ADC''' oder '''DAC'''.

== ADC (Analog Digital Converter) ==

Der '''ADC''' wandelt analoge Signale in digitale Werte um, welche vom Controller
interpretiert werden können. Einige AVR-Typen haben bereits einen oder mehrere
solcher '''ADC''''s eingebaut, bei den kleineren AVR's müssen wir uns anders aus der
Affäre ziehen. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst
werden kann, wird durch die Auflösung des '''ADC''' in Anzahl Bits angegeben, man
hört bzw. liest jeweils von 8-Bit '''ADC''' oder 10-Bit ''' ADC''' oder noch höher. 
Ein '''ADC''' mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit
von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten
eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

<div align="center"><center>

{| border="1"
|-
| align="center" | '''Eingangsspannung am ADC'''
| align="center" | '''Entsprechender Messwert'''
|-
| align="center" | 0...<0.625V
| align="center" | 0
|-
| align="center" | 0.625...<1.25V
| align="center" | 1
|-
| align="center" | 1.25...<1.875V
| align="center" | 2
|-
| align="center" | 1.875...<2.5V
| align="center" | 3
|-
| align="center" | 2.5...<3.125V
| align="center" | 4
|-
| align="center" | 3.125...<3.75V
| align="center" | 5
|-
| align="center" | 3.75...<4.375V
| align="center" | 6
|-
| align="center" | 4.375...5V
| align="center" | 7
|}

</center>
</div>

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des '''
ADC''' ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Messen eines Widerstandes ===

Wir wollen hier einmal die wohl einfachste Methode zur Erfassung eines
analogen Wertes realisieren und zwar das Messen eines veränderlichen
Widerstandes wie z.B. eines Potentiometers.

Man stelle sich vor, wir schalten einen Kondensator in Reihe zu einem
Widerstand zwischen die Versorgungsspannung und Masse und dazwischen nehmen wir
das Signal ab und führen es auf einen der Pins an unserem Controller, genau so
wie es in folgender Grafik dargestellt ist.

[[Image:Poti.gif]]

Wenn wir nun den Pin des AVR als Ausgang schalten und auf
Logisch 1 (HIGH) legen, dann liegt an beiden Platten des Kondensators ''' Vcc''' an und
dieser wird entladen (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen). 
Nachdem nun der Kondensator genügend entladen ist schalten wir einfach den Pin
als Eingang wodurch dieser hochohmig wird. Der Kondensator lädt sich jetzt
über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und
derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti
unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), dann schaltet der
Eingang von HIGH auf LOW um. Wenn wir nun messen (zählen), wie lange es dauert,
bis der Kondensator so weit geladen ist, dann haben wir einen ungefähren Wert
der Potentiometerstellung. 
Der 220 Ohm Widerstand dient dem Schutz des Controllers. Wenn nämlich sonst die
Potentiometerstellung auf Maximum steht (0 Ohm), dann würde in den Eingang des
Controllers ein viel zu hoher Strom fliessen und der AVR würde in Rauch
aufgehen.

Dies ist meines Wissens die einzige Schaltung zur Erfassung von
Analogwerten, welche mit nur einem einzigen Pin auskommt. 
Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine
Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B:
0...100 % oder so) umzurechnen.

Wer Lust hat, sich selber mal an ein solches Programm
heranzuwagen, der sollte das jetzt tun. Für diejenigen, die es gern schnell
mögen, hier das Beispielprogramm, welches den UART-Printf aus den
vorangegangenen Kapiteln benötigt, inkl. Makefile:

{| border="0"
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Poti.c Poti.c ]
| Hauptprogramm.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.c Pot.c]
| Separate Routine zur Ermittlung des Messwertes.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.h Pot.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c UartPrintF.c]
| Für die Debugausgabe auf den UART.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h UartPrintF.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile Makefile]
| Makefile.
|}

Nachdem das Programm auf den AVR geladen wurde, muss dieser
kalibriert werden. Dazu wird der Kalibrierungsschalter geschlossen und das Poti
einige Male zwischen minimaler und maximaler Stellung hin und her gedreht. Dabei
werden die jeweiligen Maximalwerte bestimmt. Wenn der Kalibrierschalter wieder
geöffnet wird werden die Kalibrierungsdaten in's EEPROM des AVR geschrieben,
damit die Prozedur nicht nach jedem Reset wiederholt werden muss.

Auf Pin 4 habe ich noch ein Triggersignal gelegt, welches auf
HIGH geht wenn die Messung beginnt und auf LOW, wenn der Messvorgang beendet
wird. Mit Hilfe dieses Signals kann der Vorgang wunderschön auf einem
Oszillographen dargestellt werden.

=== ADC über Komparator ===

Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

[[Image:ADC ueber Komparator.gif]]

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert. 
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

=== Der ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem '''ADC-Wandler''' zurückgreifen. Wir wollen hier einmal den AT90S8535 besprechen, welcher über 8 ADC-Kanäle verfügt. (TODO: nur ein Wandler, Mulitiplexbetrieb, nur eine Pin zur gleichen Zeit)

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung.

Verfügt der AVR über eine interne Referenzspannung (Datenblatt typisch 2,56 oder 1,1V je nach AVR), bleibt der ''Anschluss AREF'' unbeschaltet und man stellt die ADC-Register so ein, dass die interne Referenzspannung als "AREF" genutzt wird. Ansonsten ist eine externe Referenzspannung von maximal '''Vcc''' an den Abschluss '''AREF''' anzulegen. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden.

==== Einfache Wandlung (Single Conversion) ====

In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestossen für jeweils eine Messung.

==== Frei laufend (Free Running) ====

In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register, welche hier aufgelistet werden.

{| border="1"
|-
| '''ADCSR   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ADEN'''
| align="center" | '''ADSC'''
| align="center" | '''ADFR'''
| align="center" | '''ADIF'''
| align="center" | '''ADIE'''
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt, ist können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''Fr'''ee Running Select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Eine logische 1 aktiviert den frei laufenden Modus. Der ''' ADC''' misst nun ständig den ausgewählten Kanal und schreibt den gemessenen Wert in das '''ADC Data Register'''.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, wenn eine Umwandlung erfolgt und das '''ADC Data Register''' aktualisiert ist.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird (So steht es in der AVR-Dokumentation).

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200kHz}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50kHz}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.
<dl><dd>
{| style="" border="1"
|-
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
| align="center" | '''Teilungsfaktor'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 2
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 2
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 4
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 8
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 16
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 32
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 64
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 128
|}
</dd></dl>
|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<pre class="code">
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
C-Operatorprioritaet sichergestellt)
</pre>

oder

<pre class="code">
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</pre>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''MUX2'''
| align="center" | '''MUX1'''
| align="center" | '''MUX0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''MUX2...MUX0'''
:Mit diesem 3 Bits wird der zu messende Kanal bestimmt. Es wird einfach die entsprechende Pinnummer des Ports eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Meine Empfehlung ist deswegen klar diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Aktivieren des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register
setzen. Im gleichen Schritt legen wir auch gleich die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls mit Spannungsteiler konditionieren. Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1024 für V_ref-Volt.

<pre class="code">

#define CHANNELOFFSET 4

uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result;

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler setzen auf 8 (1)
ADCSRA |= (1<<ADEN); // ADC aktivieren (1)

ADMUX = CHANNELOFFSET+channel; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)

result = 0;

/* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
for(i=0;i<4;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)
result += ADC; // Wandlungsergebnisse aufaddieren
}

ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)

result >>= 2; // Summe durch vier teilen = arithm. Mittelwert

return result;
}
</pre>

Im Beispiel wird bei jedem Aufruf der ADC aktiviert und nach der Wandlung wieder abgeschaltet, das spart Strom. Will man dies nicht, verschiebt man die mit (1) gekenntzeichneten Zeilen in eine Funktion adc_init() o.ä. und löscht die mit (2) markierten Zeilen.



== DAC (Digital Analog Converter) ==

Mit Hilfe eines ''' DAC''' können wir nun auch Analogsignale ausgeben. Es gibt hier
mehrere Verfahren. Wenn wir beim ''' ADC''' die Möglichkeit haben, mit externen
Komponenten zu operieren, müssen wir bei der '''DAC'''-Wandlung mit dem auskommen, was
der Controller selber zu bieten hat.

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie ''' PWM''' eigentlich funktioniert.

Wie wir alle wissen ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber
wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. 
Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen
HIGH und LOW umschalten? 
Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen geometrischen Mittelwert, der je nach Pulsbreite
kleiner oder grösser ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein
RC-Glied filtern dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVR's können wir direkt '''PWM'''-Signale erzeugen. Dazu
dient der 16-Bit Zähler, welcher im sogenannten '''PWM'''-Modus betrieben werden
kann.

Hinweis:
:In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist allerdings bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt.

Um den '''PWM'''-Modus zu aktivieren müssen im Timer/Counter1 Control
Register A '''TCCR1A''' die Pulsweiten-Modulatorbits '''PWM10''' bzw. '''PWM11''' entsprechend
nachfolgender Tabelle gesetzt werden:

{| border="1"
|-
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| PWM-Modus des Timers ist nicht aktiv.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM.
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben. Die
Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| border="1"
|-
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden heisst dann:

<pre class="code">
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</pre>

Damit der Timer/Counter überhaupt läuft müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorzähler) einstellen, und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| border="1"
|-
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<pre class="code">
TCCR1B = (1<<CS12) | (1<<CS10);
</pre>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<pre class="code">
OCR1A = xxx;
</pre>

Die folgende Grafik soll den Zusammenhang zwischen dem
Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren.

= Die Timer/Counter des AVR =

Die heutigen Mikrocontroller und insbesondere die RISC-AVR's sind für viele
Steuerungsaufgaben natürlich viel zu schnell. Wenn wir beispielsweise eine LED
oder Lampe blinken lassen wollen, können wir selbstverständlich nicht die
CPU-Frequenz verwenden da ja dann nichts mehr vom Blinken zu bemerken wäre.

Wir brauchen also eine Möglichkeit, die Taktfrequenz auf vernünftige Werte
herunter zu brechen. Selbstverständlich sollte die resultierende Frequenz dann
auch noch einigermassen genau und stabil sein.

Hier kommen die im AVR vorhandenen Timer/Counter zum Einsatz.

Ein anderes Anwendungsgebiet ist die Zählung von Signalen, welche über
einen I/O-Pin zugeführt werden können.

Die folgenden Ausführungen beziehen sich auch den AT90S2313. Für andere
Modelltypen müsst ihr euch die allenfalls notwendigen Anpassungen aus den
Datenblättern der entsprechenden Controller herauslesen.

Wir unterscheiden grundsätzlich zwischen 8-Bit Timern, welche eine
Auflösung von 256 aufweisen und 16-Bit Timern mit (logischerweise) einer
Auflösung von 65536.

Als Eingangstakt für die Timer/Counter kann entweder die CPU-Taktfrequenz,
der Vorteiler-Ausgang oder ein an einen I/O-Pin angelegtes Signal verwendet
werden. Wenn ein externes Signal verwendet wird, so darf dessen Frequenz nicht
höher sein als die Hälfte des CPU-Taktes.

=== Der Vorzähler (Prescaler) ===

Beide Timer/Counter werden im Timerbetrieb über den gleichen Vorzähler
versorgt.

Der Vorzähler dient dazu, den CPU-Takt vorerst mal runter zu brechen auf eine
wählbare Teilung. Die so geteilte Frequenz wird den Eingängen der Timer
zugeführt.

Wenn wir mit einer einem CPU-Takt von 4 MHz arbeiten und den Vorteiler auf 1024
einstellen wird also der Timer mit einer Frequenz von 4 MHz / 1024, also mit ca.
4 kHz versorgt. Wenn also der Timer läuft, so wird das Daten- bzw.
Zählregister mit dieser Frequenz inkrementiert.

== 8-Bit Timer/Counter ==

Alle AVR-Modelle weisen mindestens einen, teilweise sogar zwei, 8-Bit Timer
auf.

Der 8-Bit Timer wird über folgende Register angesprochen:

{| border="1"
|-
| '''TCCR0'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
Timer '''0'''

In diesem Register stellen wir ein, wie wir den Timer/Counter verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CS02'''
| align="center" | '''CS01'''
| align="center" | '''CS00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''CS02, CS01, CS00''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS02
| align="center" | CS01
| align="center" | CS00
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin '''TO''', fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin '''TO''', steigende Flanke
|}
</dd>
</dl>
:Wenn als Quelle der externe Pin '''TO''' verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin '''TO''' als Ausgang geschaltet ist.

|-
| '''TCNT0'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer '''0''' 
Dieses ist als 8-Bit Aufwärtszähler mit Schreib- und Lesezugriff
realisiert. Wenn der Zähler den Wert 255 erreicht hat beginnt er beim
nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}
|}

Um nun also den Timer0 in Betrieb zu setzen und ihn mit einer Frequenz von 1/1024-tel des CPU-Taktes zählen zu lassen, schreiben wir die folgende Befehlszeile:

<pre class="code">
TCCR0 = (1<<CS00)|(1<<CS02);
</pre>

Der Zähler zählt nun aufwärts bis 255, um dann wieder bei 0 zu beginnen. Der aktuelle Zählerstand steht in TCNT0. Bei jedem Überlauf von 255 auf 0 wird das Timer Overflow Flag '''TOV0''' im Timer Interrupt Flag '''TIFR'''-Register gesetzt und, falls so konfiguriert, ein entsprechender Timer-Overflow-Interrupt ausgelöst.

== 16-Bit Timer/Counter ==

Viele AVR-Modelle besitzen ausser den 8-Bit Timers auch einen oder sogar zwei
(einige ATmega-Modelle) 16-Bit Timer.

Die 16-Bit Timer/Counter sind wesentlich komplexer aufgebaut als die 8-Bit
Timer/Counter, bieten dafür aber auch viel mehr Möglichkeiten, als da sind:

* Die [[PWM]]-Betriebsart Erzeugung eines pulsweitenmodulierten Ausgangssignals.
* Vergleichswert-Überprüfung mit Erzeugung eines Ausgangssignals (Output Compare Match).
* Einfangen eines Eingangssignals mit Speicherung des aktuellen Zählerwertes (Input Capturing), mit zuschaltbarer Rauschunterdrückung (Noise Filtering).

Folgende Register sind dem Timer/Counter 1 zugeordnet:

{| border="1"
|-
| '''TCCR1A'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''A''' Timer '''1''' 
In diesem und dem folgenden Register stellen wir ein, wie wir den Timer/Counter verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''COM1A1''', '''COM1A0''' ('''Co'''mpare '''M'''atch Control Bits)
:Diese 2 Bits bestimmen die Aktion, welche am Output-Pin '''OC1''' ausgeführt werden soll, wenn der Wert des Datenregisters des Timer/Counter 1 den Wert des Vergleichsregisters erreicht, also ein so genannter Compare Match auftritt.
:Der Pin '''OC1''' ('''PB3''' beim 2313) muss mit dem Datenrichtungsregister als Ausgang konfiguriert werden.

<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Das Signal am Pin '''OC1''' wird invertiert (Toggle).
|-
| align="center" | 1
| align="center" | 0
| Der Output Pin '''OC1''' wird auf 0 gesetzt.
|-
| align="center" | 1
| align="center" | 1
| Der Output Pin '''OC1''' wird auf 1 gesetzt.
|}
</dd></dl>
:In der PWM-Betriebsart haben diese Bits eine andere Funktion.
<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 1
| align="center" | 0
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 0 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 1 gesetzt.

Man nennt dies ''nicht invertierende PWM''.
|-
| align="center" | 1
| align="center" | 1
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 1 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 0 gesetzt.

Man nennt dies ''invertierende PWM''.
|}
</dd></dl>

'''PWM11''', '''PWM10''' ('''PWM''' Mode Select Bits)
:Mit diesen 2 Bits wird die PWM-Betriebsart des Timer/Counter 1 gesteuert.
<dl><dd>
{| border="1"
|-
| align="center" | PWM11
| align="center" | PWM10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Die PWM-Betriebsart ist nicht aktiviert. Timer/Counter 1 arbeitet als normaler Timer bzw. Zähler.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM Betriebsart aktivieren.
|}
</dd></dl>
|-
| '''TCCR1B'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''B''' Timer '''1'''

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ICNC1'''
| align="center" | '''ICES1'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CTC1'''
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''ICNC1''' ('''I'''nput '''C'''apture '''N'''oise '''C'''anceler (4 CKs) Timer/Counter 1
:oder auf Deutsch Rauschunterdrückung des Eingangssignals.
:Wenn dieses Bit gesetzt ist und mit dem Input Capture Signal gearbeitet wird so werden nach der Triggerung des Signals mit der entsprechenden Flanke (steigend oder fallend) am Input Capture Pin '''ICP''' jeweils 4 Messungen mit der CPU-Frequenz des Eingangssignals abgefragt. Nur dann, wenn alle 4 Messungen den gleichen Zustand aufweisen gilt das Signal als erkannt.

'''ICES1''' ('''I'''nput '''C'''apture '''E'''dge '''S'''elect Timer/Counter '''1''')
:Mit diesem Bit wird bestimmt, ob die steigende ('''ICES1'''=1) oder fallende ('''ICES1'''=0) Flanke zur Auswertung des Input Capture Signals an Pin '''ICP''' heran gezogen wird.

'''CTC1''' ('''C'''lear '''T'''imer/'''C'''ounter on Compare Match Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, so wird nach einer Übereinstimmung des Datenregisters '''TCNT1H'''/'''TCNT1L''' mit dem Vergleichswert in '''OCR1H'''/'''OCR1L''' das Datenregister '''TCNT1H'''/'''TCNT1L''' auf 0 gesetzt.
:Da die Übereinstimmung im Takt nach dem Vergleich behandelt wird, ergibt sich je nach eingestelltem Vorzähler ein etwas anderes Zählverhalten:
:Wenn der Vorteiler auf 1 gestellt ist und C der jeweilige Zählerwert ist, dann nimmt das Datenregister, im CPU-Takt betrachtet, folgende Werte an:
:... | C-2 | C-1 | C | 0 | 1 |...
:Wenn der Vorteiler z.B. auf 8 eingestellt ist, dann nimmt das Datenregister folgende Werte an:
:... | C-2, C-2, C-2, C-2, C-2, C-2, C-2, C-2 | C-1, C-1, C-1, C-1, C-1, C-1, C-1, C-1 | C, 0, 0, 0, 0, 0, 0, 0 |...
:In der PWM-Betriebsart hat dieses Bit keine Funktion.

'''CS12''', '''CS11''', '''CS10''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS12
| align="center" | CS11
| align="center" | CS10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin TO, fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin T0, steigende Flanke
|}
</dd></dl>
:Wenn als Quelle der externe Pin T0 verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin T0 als Ausgang geschaltet ist.
|-
| '''TCNT1H''' '''TCNT1L'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer/Counter '''1'''
Dieses ist als 16-Bit Aufwärtszähler mit Schreib- und Lesezugriff realisiert. Wenn der Zähler den Wert 65535 erreicht hat, beginnt er beim nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''TCNT1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''TCNT1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

In der PWM-Betriebsart wird das Register als Auf/Ab-Zähler verwendet, d.h. der Wert steigt zuerst von 0 bis er den Überlauf von 65535 auf 0 erreicht hat. Dann zählt das Register rückwärts wiederum bis 0.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.

Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''OCR1H''' '''OCR1L'''
| Timer/Counter '''O'''utput '''C'''ompare '''R'''egister Timer/Counter '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''OCR1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''OCR1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Der Wert im Output Compare Register wird ständig mit dem aktuellen Wert im Datenregister TCNT1H/TCNT1L verglichen. Stimmen die beiden Werte überein, so wird ein sogenannter Output Compare Match ausgelöst. Die entsprechenden Aktionen werden über die Timer/Counter 1 Control und Status Register eingestellt.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''ICR1H''' '''ICR1L'''
| Timer/Counter '''I'''nput '''C'''apture '''R'''egister Timer/Counter '''1''' 
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''ICR1''''''H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''ICR1''''''L'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Das Input Capture Register ist ein 16-Bit Register mit Lesezugriff. Es kann nicht beschrieben werden.

Wenn am Input Capture Pin '''ICP''' die gemäß Einstellungen im '''TCCR1B''' definierte Flanke erkannt wird, so wird der aktuelle Inhalt des Datenregisters '''TCNT1H'''/'''TCNT1L''' sofort in dieses Register kopiert und das Input Capture Flag '''ICF1''' im Timer Interrupt Flag Register '''TIFR''' gesetzt.

Wie bereits oben erwähnt, müssen vor dem Zugriff auf dieses Register alle Interrupts gesperrt werden. Zudem müssen Low- und Highbyte des Registers in der richtigen Reihenfolge bearbeitet werden:

{| border="0"
|-
| Lesen:
| '''ICR1L''' -> '''ICR1H'''
|-
| Schreiben:
| '''ICR1H''' -> '''ICR1L'''
|}
|}

=== Die PWM-Betriebsart ===

Wenn der Timer/Counter 1 in der PWM-Betriebsart betrieben wird, so bilden das Datenregister '''TCNT1H'''/'''TCNT1L''' und das Vergleichsregister '''OCR1H'''/'''OCR1L''' einen 8-, 9- oder 10-Bit, frei laufenden PWM-Modulator, welcher als PWM-Signal am '''OC1'''-Pin ('''PB3''' beim 2313) abgegriffen werden kann. Das Datenregister '''TCNT1H'''/'''TCNT1L''' wird dabei als Auf-/Ab-Zähler betrieben, welcher von 0 an aufwärts zählt bis zur Obergrenze und danach wieder zurück auf 0.
Die Obergrenze ergibt sich daraus, ob 8-, 9- oder 10-Bit PWM verwendet wird, und zwar gemäss folgender Tabelle:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Wenn nun der Zählerwert im Datenregister den in '''OCR1H'''/'''OCR1L''' gespeicherten Wert erreicht, wird der Ausgabepin '''OC1''' gesetzt bzw. gelöscht, je nach Einstellung von '''COM1A1''' und '''COM1A0''' im '''TCCR1A'''-Register.

Ich habe versucht, die entsprechenden Signale in der folgenden Grafik zusammenzufassen

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

=== Vergleichswert-Überprüfung ===

Hier wird in ein spezielles Vergleichswertregister ('''OCR1H'''/'''OCR1L''') ein Wert eingeschrieben, welcher ständig mit dem aktuellen Zählerwert verglichen wird.
Erreicht der Zähler den in diesem Register eingetragenen Wert, so kann ein Signal (0 oder 1) am Pin '''OC1''' erzeugt und/oder ein Interrupt ausgelöst werden.

=== Einfangen eines Eingangssignals (Input Capturing) ===

Bei dieser Betriebsart wird an den Input Capturing Pin (ICP) des Controllers eine Signalquelle angeschlossen.
Nun kann je nach Konfiguration entweder ein Signalwechsel von 0 nach 1 (steigende Flanke) oder von 1 nach 0 (fallende Flanke) erkannt werden und der zu diesem Zeitpunkt aktuelle Zählerstand in ein spezielles Register abgelegt werden. Gleichzeitig kann auch ein entsprechender Interrupt ausgelöst werden.
Wenn die Signalquelle ein starkes Rauschen beinhaltet, kann die Rauschunterdrückung eingeschaltet werden. Dann wird beim Erkennen der konfigurierten Flanke über 4 Taktzyklen das Signal überwacht und nur dann, wenn alle 4 Messungen gleich sind, wird die entsprechende Aktion ausgelöst.

== Gemeinsame Register ==

Verschiedene Register beinhalten Zustände und Einstellungen, welche sowohl
für den 8-Bit, als auch für den 16-Bit Timer/Counter in ein und demselben
Register zu finden sind.

{| border="1"
|-
| '''TIMSK'''
| '''T'''imer/Counter '''I'''nterrupt '''M'''a'''sk'''
Register

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOIE1'''
| align="center" | '''OCIE1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''TICIE'''
| align="center" | '''-'''
| align="center" | '''TOIE0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOIE1''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 1 ein Timer Overflow 1 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''OCIE1A''' ('''O'''utput '''C'''ompare Match '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Beim Timer/Counter 1 kann zusätzlich zum Überlauf ein Vergleichswert definiert werden.

:Wenn dieses Bit gesetzt ist, wird beim Erreichen des Vergleichswertes ein Compare Match Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TICIE''' ('''T'''imer/Counter '''I'''nput '''C'''apture '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein Capture Event Interrupt ausgelöst, wenn ein entsprechendes Signalereignis am Pin PD6(ICP) auftritt. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein, wenn auch ein entsprechender Interrupt ausgelöst werden soll.

'''TOIE0''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''0''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 0 ein Timer Overflow 0 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

|-
| '''TIFR'''
| '''T'''imer/Counter '''I'''nterrupt '''F'''lag '''R'''egister

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOV1'''
| align="center" | '''OCF1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''ICF1'''
| align="center" | '''-'''
| align="center" | '''TOV0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOV1''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''1''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 1 ein Überlauf des Datenregisters stattfindet.

:In der PWM-Betriebsart wird das Bit gesetzt, wenn die Zählrichtung von auf- zu abwärts und umgekehrt geändert wird (Zählerwert = 0).

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''OCF1A''' ('''O'''utput '''C'''ompare '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn der aktuelle Wert des Datenregisters von Timer/Counter 1 mit demjenigen im Vergleichsregister '''OCR1''' übereinstimmt.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''ICF1''' ('''I'''nput '''C'''apture '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn ein Capture-Ereignis aufgetreten ist, welches anzeigt, dass der Wert des Datenregisters des Timer/Counter 1 in das Input Capture Register ICR1 übertragen wurde.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''TOV0''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''0''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 0 ein Überlauf des Datenregisters stattfindet.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.
|}

 

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sog. ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comperators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrups den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

* '''set_sleep_mode(uint8_t mode)'''
:Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z.B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
* '''sleep_mode()'''
:Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus.

<pre class="code">
#include <avr/io.h>
#include <avr/sleep.h>
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach auftreten eines entsprechenden "Aufwach-Interrupts" verarbeitet
...
</pre>

Vorsicht: Nicht alle AVR-Controller (v.a. nicht die "Brandneuen") werden von den avr-libc sleep-Funktionen richtig angesteuert. Bei nicht-untersützten Typen erreicht man die gewollte Funktionalität durch direkte "Bitmanipulation" der ensprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler:

<pre class="code">
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep");
...
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes

= Der Watchdog =

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der Watchdog.

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln.

Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

Betrachten wir doch einmal folgende Codesequenz:

<pre class="code">
uint8_t x;

x = 10;

while (x >= 0) {
// tu was

x--;
}
</pre>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm würde sich also hier aufhängen und auf ewig in der Schleife drehen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde beginnt der Counter von 0 an hochzuzählen. Wenn nun die je nach Vorteiler eingestellte Anzahl Zyklen erreicht wurde, löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern müssen wir den Watchdog regelmässig wieder neu starten bzw. Rücksetzen (Watchdog Reset). Dies sollte innerehalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern muss ein spezielles Prozedere verwendet werden, um den WD auszuschalten und zwar müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden. Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| border="1"
|-
| '''WDTCR'''
| '''W'''atchog '''T'''imer  '''C'''ontrol '''R'''egister

In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''WDTOE'''
| align="center" | '''WDE'''
| align="center" | '''WDP2'''
| align="center" | '''WDP1'''
| align="center" | '''WDP0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''WDTOE''' ('''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable)
:Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
:Wenn das Bit einmal gesetzt ist wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.

'''WDE''' ('''W'''atch'''d'''og '''E'''nable)
:Wenn dieses Bit gesetzt wird, so wird der Watchdog aktiviert.
:Das Bit kann nur gelöscht werden, solange das Bit '''WDTOE''' auf 1 steht.

'''WDP2''', '''WDP1''', '''WDP0''' ('''W'''atch'''d'''og Timer '''P'''rescaler Bits)
:Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:
<dl><dd>
{| border="1"
|-
| align="center" | WDP2
| align="center" | WDP1
| align="center" | WDP0
| align="center" | Anzahl Zyklen
| align="center" | Typ. Timeoutzeit bei Vcc = 3V
| align="center" | Typ. Timeoutzeit bei Vcc = 5V
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 16K
| align="center" | 47ms
| align="center" | 15ms
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 32K
| align="center" | 94ms
| align="center" | 30ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 64K
| align="center" | 0.19s
| align="center" | 60ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 128K
| align="center" | 0.38s
| align="center" | 0.12s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 256K
| align="center" | 0.75s
| align="center" | 0.24s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 512K
| align="center" | 1.5s
| align="center" | 0.49s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 1024K
| align="center" | 3s
| align="center" | 0.97s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 2048K
| align="center" | 6s
| align="center" | 1.9s
|}
</dd></dl>
|}

Um den Watchdog mit dem AVR-GCC Compiler zu verwenden, muss die Headerdatei wdt.h in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

* '''wdt_enable(uint8_t timeout)'''
:Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert (z.B. WDTO_30MS).
* '''wdt_disable()'''
:Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
* '''wdt_reset()'''
:Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Ein paar grundsätzliche Gedanken ==

Ob nun so ein Watchdog überhaupt verwendet werden soll, ist wohl eher eine
philosophische Frage und hängt vom Geschmack jedes einzelnen Entwicklers ab.

Ich persönlich habe es lieber, wenn ich auch merke, dass in meine Programm
etwas noch nicht in Ordnung ist, als dass mir ein Watchdog einfach die CPU immer
wieder zurücksetzt, denn immerhin kann es so passieren, dass ein Programm über
Jahre hinweg so einigermassen läuft, obwohl noch ein voll krasser Bock drin
liegt.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Watchdog timer handling

= Programmieren mit Interrupts =

Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

[[Image:Interrupt Programme.gif]]

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

== Anforderungen an die Interrupt-Routine ==

Um unliebsamen Überraschungen vorzubeugen sollten einige Grundregeln bei
der Gestaltung der Interruptroutinen beachtet werden.

* Die Interruptroutine soll möglichst kurz und schnell abarbeitbar sein, daraus folgt:
* Keine unfangreichen Berechnungen innerhalb der Interruptroutine.
* Keine endlos langen Programmschleifen.
* Obschon es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen rate ich dringend von solchen Spielen ab.

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf dem AVR auslösen, wobei
die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

== Register ==

Der AT90S2313 verfügt über 2 Register welche mit den
Interrupts zusammen hängen.

{| border="1"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INT1'''
| align="center" | '''INT0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INT1''' (External '''Int'''errupt Request '''1''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

'''INT0''' (External '''Int'''errupt Request '''0''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INTF1'''
| align="center" | '''INTF0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INTF1''' (External '''Int'''errupt Flag '''1''')
:Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.

'''INTF0''' (External '''Int'''errupt Flag '''0''')
:Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister.

Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''SE'''
| align="center" | '''SM'''
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''SE''' ('''S'''leep '''E'''nable)
:Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl in den Schlafzustand versetzen zu können.
:Um den Schlafmodus nicht irrtümlich einzuschalten, wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.

'''SM''' ('''S'''leep '''M'''ode)
:Dieses Bit bestimmt der Schlafmodus.
:Ist das Bit gelöscht, so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt, so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")

'''ISC11''', '''ISC10''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.
<dl><dd>
{| border="1"
|-
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}
</dd></dl>
'''ISC01''', '''ISC00''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

<dl><dd>
{| border="1"
|-
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}
</dd></dl>
|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft, wird automatisch das '''Global
Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle
weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem
Zeitpunkt bereits wieder das GIE-bit zu setzen, rate ich dringend davon ab. Dieses
wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn
in der Zwischenzeit weitere Interrupts eintreffen, werden die zugehörigen
Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden
Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt
ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle
anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe,
weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.

=== Das Status-Register ===

Es gilt auch zu beachten, dass das Status-Register während der Abarbeitung
einer Interruptroutine nicht automatisch gesichert wird. Falls notwendig, muss dies vom
Programmierer selber vorgesehen werden.

== Interrupts mit dem AVR GCC Compiler (WinAVR) ==

Selbstverständlich können alle Interruptspezifischen Registerzugriffe wie gewohnt über I/O-Adressierung vorgenommen werden. Etwas einfacher geht es jedoch, wenn wir die vom Compiler zur Verfügung gestellten Mittel einsetzen.

Damit diese Mittel zur Verfügung stehen, müssen wir die Includedatei ''interrupt.h'' und evtl. ''signal.h'' einbinden mittels:

<pre class="code">
// fuer sei(), cli() und INTERRUPT():
#include <avr/interrupt.h>

// fuer SIGNAL() auch:
#include <avr/signal.h>
</pre>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird
nichts anderes gemacht, als das '''Global Interrupt Enable''' Bit im Status
Register gesetzt.

<pre class="code">
sei();
</pre>

Das Makro '''cli()''' schaltet die Interrupts aus, oder anders
gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird
gelöscht.
<pre class="code">
cli();
</pre>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf.
Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen.
Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren
und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen
Zustands die Interrups aktivieren, was zu unerwünschten Seiteneffekten führen kann.
Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern */

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD); // 2 mal in Folge , vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
...

}
</pre>



Nachdem nun die Interrupts aktiviert sind, braucht es selbstverständlich noch den auszuführenden Code, der ablaufen soll, wenn ein Interrupt eintrifft. Dazu gibt es zwei Definitionen: '''SIGNAL''' und '''INTERRUPT''', welche allerdings AVR-GCC spezifisch sind und bei anderen Compilern womöglich anders heissen können.

=== SIGNAL ===

<pre class="code">
#include <avr/signal.h>
...
SIGNAL (siglabel)
{
/* Interrupt Code */
}
</pre>

Mit ''SIGNAL'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektoren angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Vor Nutzung von SIGNAL muss die Header-Datei signal.h eingebunden werden. Mögliche Funktionsrümpfe für solche Interruptfunktionen sind zum Beispiel:

<pre class="code">
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

SIGNAL (SIG_OVERFLOW1)
{
/* Interrupt Code */
}

SIGNAL (SIG_UART_RECV)
{
/* Interrupt Code */
}

// und so weiter und so fort...
</pre>

Während der Ausführung des Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten, so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== INTERRUPT ===

<pre class="code">
#include <avr/interrupt.h>
...
INTERRUPT (signame)
{
/* Interrupt Code */
}
</pre>

Mit INTERRUPT wird genau gleich gearbeitet wie mit SIGNAL. Der Unterschied ist derjenige, dass bei INTERRUPT beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit automatisch wieder gesetzt und somit weitere Interrupts zugelassen werden. Dies kann zu nicht unerheblichen Problemen von im einfachsten Fall einem Stack overflow bis zu sonstigen unerwarteten Effekten führen und sollte wirklich '''nur dann''' angewendet werden, wenn man sich absolut sicher ist, das Ganze auch im Griff zu haben. Vor Nutzung von INTERRUPT muss die Header-Datei interrupt.h eingebunden werden.

Interruptroutinen (ISRs) sollten möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern des Zustands aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen, s.u.). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

siehe auch: Hinweise in [[AVR-GCC]]

== Datenaustausch mit Interrupt-Routinen ==

Variablen auf die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen wird und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte die Code-Optimierung "greifen" und der Wert der Variablen nur in Prozessorregistern zwischenspeichert werden, die "nichts von der Änderung woanders mitbekommen".

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z.B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt z.B. alle 10ms
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
// hier wird gKeyCounter veraendert, die uebrigen
// Programmteile muessen diese Aenderung "sehen"
// (volatile -> aktuellen Wert immer in den Speicher schreiben)
if ( !(KEY_PIN & (1<<KEY_PINNO)) )
if (gKeyCouter < CNTREPEAT) gKeyCounter++;
else gKeyCounter = 0;
}

...

int main(void)
{
...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
...
// hier wird auf gKeyCounter zugegriffen, dazu muss der in der
// ISR geschrieben Wert bekannt sein.
// (volatile -> aktuellen Wert immer aus dem Speicher lesen)
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt"
}
else {
/* hier: Code fuer "Taste kurz gedrueckt"
}
...
}
</pre>

Bei Variablen größer ein Byte muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes ausserhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<pre class="code">
...
volatile uint16_t gMyCounter16bit
...
SIGNAL(...)
{
...
gMyCounter16Bit++;
...
}

int main(void)
{
uint16_t tmpCnt;
...
// nicht gut: mglw. hier ein Fehler wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor Kopieren des zweiten Bytes
// ein Interrupt auftritt der den Inhalt von MyCounter veraendert
tmpCnt = gMyCounter16bit;

// besser: Aenderungen "ausserhalb" verhindern, alle "Teilbytes"
// bleiben konsistent
cli(); // Interupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren
...
}
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8 (Stand: avr-libc Vers. 1.0.4)

== Was macht das Hauptprogramm ==

Im einfachsten Fall gar nichts mehr.

Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der
main-Funktion lediglich noch die Interrupts aktiviert und dann in eine
Endlosschleife folgender Art verzweigt:

<pre class="code">
...
for (;;) {}
...
</pre>

Normalerweise wird man allerdings in den Interruptroutinen die Interrupts
erfassen und im Hauptprogramm dann gemütlich auswerten.

Wie wir im bisherigen Kursverlauf gesehen haben ist es ohnehin mit so
schnellen Controller meistens gar nicht unbedingt notwendig mit
Interruptfunktionen zu arbeiten. 
Es ist allerdings auch zu bemerken, dass mit den Interruptroutinen ein Programm
sehr schön strukturiert werden kann, wenn man es richtig macht.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (eigentlich [[SRAM]]) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als [[FLASH]]-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z.B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin wenig Sinn macht und auch nur bei einigen RAM-losen Typen nach "Bastelarbeiten" möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory). Die Standard-Laufzeitbibliothek des avr-gcc, die [[avr-libc]], stellt diese Funktionen nach einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Einige Beispiele:

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray1 };
...
</pre>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<pre class="code">
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte...
}
</pre>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel, jedoch mit der Funktion pgm_read_word.

<pre class="code">
uint16_t myWord;

myWord = pgm_read_word(&pgmFooWord);
</pre>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "gross". (Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.) Pointer müssen gegebenenfalls "gecastet" werden.

<pre class="code">
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray1

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray2
// da im zweiteb Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmPointerToArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</pre>

=== Floats und Structs lesen ===

Um komplexe Datentypen (structs), nicht-integer Datentypen (floats) aus dem Flash auszulesen, sind Hilfsfunktionen erforderlich. Einige Beispiele:

<pre class="code">

/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
...

/* liest float von Flash-Addresse addr und gibt diese als return-value zurueck */
inline float pgm_read_float(const float *addr)
{
union
{
uint16_t i[2]; // 2 16-bit-Worte
float f;
} u;

u.i[0]=pgm_read_word((PGM_P)addr);
u.i[1]=pgm_read_word((PGM_P)addr+2);

return u.f;
}
...

void egal(void)
{
int i;
float f;

for (i=0;i<3;i++) {
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach' was mit f
}
}
</pre>

TODO: Beispiele fuer structs und pointer aus flash auf struct im flash (menues, state-machines etc.)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuerht, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
...
</pre>

Aber Achtung: Ersetzt man zum Beispiel
<pre class="code">
const char textImFlash[] PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
durch
<pre class="code">
const char textImFlash* PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der textImFlash zu den Konstanten ans Ende des Programmcodes gelegt wird, von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte. Da der lesende Code trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein Bug des AVR-GCC (gesehen bei 3.4.1) zu sein.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<pre class="code">
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
...
</pre>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z.B. 0x01fe), "weiss" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, dass der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000), wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z.B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmässig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, dass vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgegeben sind, die innerhalb weniger Taktzyklen aufeinanderfolgen müssen ("timed sequence"). Auch dies muss bei Nutzung der Funktionen aus der avr-libc/eeprom.h-Datei nicht selbst implementiert werden. Innerhalb der Funktionen werden Interrupts vor der "EEPROM-Sequenz" global deaktiviert und im Anschluss, falls vorher auch schon eingeschaltet, wieder aktiviert.


Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Die Nutzung einer [[C-Präprozessor]]-Ersetzung bringt etwas Bequemlichkeit. Siehe dazu folgendes Beispiel.

<pre class="code">
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h>

// alle Textstellen EEPROM im Quellcode durch __attribute__ ... ersetzen
#define EEPROM __attribute__ ((section (".eeprom")))

...

/* Byte */
uint8_t eeFooByte EEPROM = 123;

/* Wort */
uint16_t eeFooWort EEPROM = 12345;

/* float */
float eeFooFloat EEPROM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEPROM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEPROM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */

uint16_t eeFooWordArray1[4] EEPROM;
...
</pre>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heisst eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:


<pre class="code">
...
uint8_t myByte;

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
...
</pre>

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<pre class="code">
...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
...
</pre>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprueft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und mglw. noch mehr.

<pre class="code">
...
unit8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes aber der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnuetze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray[0],3);

/* dito mit etwas Absicherung betr. der Laenge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));

/* Datenlock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));
...
</pre>

"Nicht-Integer"-Datentypen wie z.B. Fliesskommazahlen lassen sich recht praktisch ueber eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<pre class="code">
...
float myFloat = 12.34;

union {
float r;
uint8_t n[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */
...
</pre>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<pre class="code">
...
typedef struct {
uint8_t label[8];
unin8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEPROM;

...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
...
}
...
</pre>

=== EEPROM-Speicherabbild in .eep-Datei ===

Eine besondere Funktion des avr-gcc ist, dass mit einem entsprechenden makefile aus den Initialisierungswerten der Variablen im Quellcode eine Datei erzeugt werden kann, die man auf den Controller programmieren kann (.eep-Datei). Damit können sehr elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Die Vorgehensweise wird aus dem WinAVR-Beispielmakefile ersichtlich. Siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles.

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Nicht alle neuen AVR Controller werden von avr-libc/eeprom.h untersützt (Stand Version 1.0.4). Insbesondere beim ATMega169 funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register) Etwas ältere Typen, oder zu den "etablierten" Controllern kompatible, bereiten jedoch hier keine Proleme. Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Der dort gezeigt Code kann direkt auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste").

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gcc-Toolchain" bietet dazu zwei Möglichkeiten:

;Inline-Assembler:
Die Assembleranweisungen werden in direkt in den C-Code integriert. Eine Quellcode-Datei enhält somit C- und Assembleranweisungen

;Assembler-Dateien:
Der Assembler-Codecode befindet sich in eigenen Quellcodedateien. Dieser werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z.B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben.

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen einer NOP-Anweisung. NOP steht für '''NO'''-O'''P'''eration. Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=warte)-Funktionen.

<pre class="code">
...
/* Verzoegern der weiteren Programmausfuehrung um
genau 3 Taktzyklen */
asm volatile ("nop"::);
asm volatile ("nop"::);
asm volatile ("nop"::);
...
</pre>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeindlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<pre class="code">
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i=0;i<1000;i++);

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i=0;i<1000;i++) asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j=0;j<1000;j++);
</pre>

Ein weiterer nützliche "Assembler-Einzeiler" ist der Auruf von sleep (''asm volatile ("sleep"::);''), da hierzu keine eigene Funktion in der avr-libc existiert.

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil des die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<pre class="code">
static inline void delayloop16(uint16_t count)
{
asm volatile ( "cp %A0,__zero_reg__ \n\t" \
"cpc %B0,__zero_reg__ \n\t" \
"breq L_Exit_%= \n\t" \
"L_LOOP_%=: \n\t" \
"sbiw %0,1 \n\t" \
"brne L_LOOP_%= \n\t" \
"L_Exit_%=: \n\t" \
: "=w" (count)
: "0" (count)
);
}
</pre>

* Jede Zeile wird mit '''\n\t''' abgeschlossen, alle Zeilen mit '''\''' verbunden.
* Sprung-Marken (labels) werden mit einm Prozentzeichen abgeschlossen, der Präprozessor (Assembler?) setzt an dieser Stelle eine laufende Nummer ein, die Doppelbezeichnungen bei mehrmaliger Verwendung somit verhindert.

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc.

* siehe auch: Dokumentation der avr-libc/Related Pages/Inline Asm
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

...TODO: Beispiele, Parameteruebergabe, globale Variablen für Datenaustausch

= TODO =

stdio.h, malloc() ???, Code-Optimierungen ("tricks"), "naked"-Functionen ??, IO-Register als Parameter/"Variablen" (volatile uint8_t *mybusport; mybusport=&PORTB; void sendbus(uint8_t *parm)...)

= C-Code und Bibliotheken für externe Baugrupen =
(TODO: sollte in avr-gcc verschoben werden)
[[Linksammlung#Avr]]

==LCD==
=== Text (character-mode) HD44870 ===
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray

=== Grafik-LCD ===
==== Nokia3310 ====
==== Nokia 6100 LCD ====
Das Nokia ist ein 132x132x4096 Farben Display das bei eBay ziemlich preiswert ersteigert werden kann.
[http://www.apetech.de/nokia6100.php Nokia 6100 LCD Library]
==== KS0108 ====
* Procyon avrlib (GPL)
* avrfreaks UP
* apetech.de
==Schnittstellen==
===I2C===
====Master====
[http://jump.to/fleury/ P. Fleurys I2C Master library]
====Slave====

===CAN===
* [http://www.atmel.com] Codesammlung zum AT90CAN128

=== DS18S20/1-Wire ===
* avrfreaks Projekt 59
* mikrocontroller.net/codesammlung (P. Dannegger)

=== UART ===
* Procyon avrlib (GPL)
* avrfreaks UP (viele viele)
* P. Fleury

== Speicherkarten/IDE/FAT ==
* avrfreaks UP (IDE/FAT read write)
== CRC ==
* avrfreaks-forum (O'Flynn)
* avr-hal (GPL)

AVR-GCC-Tutorial

2004-11-15T15:36:44Z

Oxygene: /* Optimierungsgrad */ typo

[[Category:AVR]]

= Vorwort =

Dieses Tutorial soll Einsteigern helfen, mit der Programmiersprache '''C''' die Mikrocontroller der Atmel AVR-Reihe zu programmieren.


Die ursprüngliche Version stammt von Christian Schifferle, die meisten aktuellen Anpassungen von [[Benutzer:Mthomas]]. Viele der im Original-Dokument verwendeten Funktionen sind in
aktuellen Versionen des avr-gcc C-Compilers und der avr-libc zwar noch enthalten,
aber als überholt (''deprecated'') ausgewiesen. D.h. diese Funktionen sollten nicht mehr verwendet
werden und existieren in zukünftigen Versionen des Compilers/der Library nicht mehr
(z.B. sbi(), cbi(), outp(), inp()). Der Artikel wurde auf die neuen Funktionen/Methoden
angepasst.

In diesem Text wird häufig auf die Standardbibliothek für den avr-gcc-Compiler, die avr-libc, verwiesen. Die '''Dokumentation der avr-libc''' findet sich
[http://www.nongnu.org/avr-libc/user-manual/index.html hier]. Bei WinAVR gehört diese Dokumentation zum Lieferumfang und wird mitinstalliert.

= Benötigte Werkzeuge =

Um die Übungen in diesem Tutorial nachvollziehen zu können benötigen wir folgende Hard- und Software:

* Testboard für die Aufnahme eines AVR Controllers, der vom gcc Compiler untersützt wird (alle ATmegas und die meisten AT90). Dieses Testboard kann durchaus auch selber zusammen gelötet werden. So arbeite ich mit einem Testboard, welches ich mir auf einer Veroboard-Platine zusammen gestellt habe. Für die Versuche bzw. Übungen in diesem Tutorial habe ich jeweils einen AT90S2313 verwendet. Eine brauchbare Testplattform ist auch der [[AVR Butterfly]].
* AVRGCC-Compiler. Kostenlos erhältlich für nahezu alle Plattformen/Betriebssysteme. Für MS-Windows im Packet [[WinAVR]]; für Unix/Linx siehe auch Hinweise im Artikel [[AVR-GCC]].
* Programmiersoftware und Hardware z.B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], [[AVR-Studio]]).
* Nicht unbedingt erforderlich aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Abschnitt Exkurs: makefiles).

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.
* Die [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently Asked Questions = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.
* Das gcc-Forum auf [http://www.mikrocontroller.net www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.
* Das avr-gcc-Forum bei [http://www.avrfreaks.net avrfreaks] nach vergleichbaren Problemen absuchen.
* Das [http://www.avr1.org/pipermail/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.
* Nach Beispielcode suchen. Vor allem in der Academy von [http://www.avrfreaks.net AVRFREAKS] (anmelden).
* Google oder alltheweb befragen schadet nie.
* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal)
* einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei mgl. viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode, genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z.B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: [http://www.lugbz.org/documents/smart-questions_de.html "Wie man Fragen stellt"].

= Exkurs: makefiles =

Wenn man bisher gewohnt ist, mit integrierten Entwicklungsumgebung à la Visual-C Programme zu erstellen, wirkt das makefile-Konzept auf den ersten Blick etwas kryptisch. Nach kurzer Einarbeitung ist diese Vorgehensweise jedoch sehr praktisch. Diese Dateien (üblicher Name: 'Makefile' ohne Dateiendung) dienen der Ablaufsteuerung des Programms make, das auf allen Unix/Linux-Systemen installiert sein sollte, und in einer Fassung fuer MS-Windows auch in [[WinAVR]] (Unterverzeichnis utils/bin) enthalten ist.

Im Unterverzeichnis ''sample'' einer WinAVR-Installation findet man eine sehr brauchbare Vorlage, die sich einfach an das eigene Projekt anpassen lässt ([[Media:Makefile|lokale Kopie Stand Sept. 2004]]). Wahlweise kann man auch [http://www.sax.de/~joerg/mfile/ mfile] von Jörg Wunsch nutzen. mfile erzeugt ein makefile nach Einstellungen in einer grafischen Nutzeroberfläche, wird bei WinAVR mitinstalliert, ist aber als TCL/TK-Programm auf nahezu allen Platformen lauffähig.

''Die folgenden Ausführungen beziehen sich auf das WinAVR Beispiel-Makefile.''

Ist im Makefile alles richtig eingestellt genügt es, sich drei Parameter zu merken, die über die shell bzw. die Windows-Kommandozeile (cmd.exe/command.exe) als Parameter an "make" übergeben werden. Das Programm make sucht sich "automatisch" das makefile im aktuellen Arbeitsverzeichnis und führt die darin definierten Operationen für den entsprechenden Aufrufparameter durch.

{| border=1
| ''make all''
| Erstellt aus den in im makefile angegebenen Quellcodes eine ''hex''-Datei (und ggf. auch ''eep''-Datei).
|-
| ''make program''
| Überträgt die hex-Datei (und wahlweise auch die eep-Datei für den EEPROM) zum AVR.
|-
| ''make clean''
| löscht alle temporären Dateien, also auch die hex-Datei
|}

Diese Aufrufe können in die allermeisten Editoren in "Tool-Menüs" eingebunden werden. Dies erspart den Kontakt mit der Kommandozeile. (Bei WinAVR sind die Aufrufe bereits im Tools-Menü des mitgelieferten Editors Programmers-Notepad eingefügt.)

Üblicherweise sind folgende Daten im makefile anzupassen:
* Controllertyp
* Quellcode-Dateien (c-Dateien)
* Typ und Anschluss des Programmiergeräts

seltener sind folgende Einstellungen durchzuführen:
* Grad der Optimierung
* Methode zur Erzeugung der Debug-Symbole (Debug-Format)
* Assembler-Quellcode-Dateien (S-Dateien)

Die in den folgenden Unterabschnitten gezeigten makefile-Ausschnitte sind für ein Programm, das auf einem ATmega8 ausgeführt werden soll. Der Quellcode besteht aus den c-Dateien superprog.c (darin main()), uart.c, lcd.c und 1wire.c. Im Quellcodeverzeichnis befinden sich diese Dateien: superprog.c, uart.h, uart.c, lcd.h, lcd.c, 1wire.h, 1wire.c und das makefile (die angepasste Kopie des WinAVR-Beispiels).

Der Controller wird mittels [[AVRDUDE]] über ein [[STK200]]-Programmierdongle an der Schnittstelle lpt1 (bzw. /dev/lp0) programmiert. Im Quellcode sind auch Daten für die ''section .eeprom'' definiert (siehe Abschnitt Speicherzugriffe TODO: nach unten verlinken), diese sollen beim Programmieren gleich mit ins EEPROM geschrieben werden.

== Controllertyp setzen ==

Dazu wird die "make-Variable" MCU entsprechend dem Namen des verwendenten Controllers gesetzt. Ein Liste der von avr-gcc und der avr-libc untersützten Typen findet sich in der [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc].

<pre class="code">
# Kommentare in Makefiles beginnen mit einem Doppelkreuz
...

# ATmega8 at work
MCU = atmega8
# oder MCU = atmega16
# oder MCU = at90s8535
# oder ...
...
</pre>

== Quellcode-Dateien einstellen ==

Den Namen der Quellcodedatei welche die Funktion main enthält, wird hinter TARGET eingetragen. Dies jedoch ohne die Endung ''.c''.

<pre class="code">
...
TARGET = superprog
...
</pre>

Besteht das Projekt wie im Beispiel aus mehr als einer Quellcodedatei, sind die weiteren c-Dateien (nicht die Header-Dateien, vgl. [[Include-Files (C)]]) durch Leerzeichen getrennt bei SRC einzutragen. Die bei TARGET definierte Datei ist schon in der SRC-Liste enthalten. Diesen Eintrag nicht löschen!

<pre class="code">
...
SRC = $(TARGET).c uart.c lcd.c 1wire.c
...
</pre>

Alternativ kann man die Liste der Quellcodedateien auch mit dem Operator += erweitern.

<pre class="code">
SRC = $(TARGET).c uart.c 1wire.c
# lcd-Code fuer Controller xyz123 (auskommentiert)
# SRC += lcd_xyz.c
# lcd-Code fuer "Standard-Controller" (genutzt)
SRC += lcd.c
</pre>

== Programmiergerät einstellen ==

Die Vorlagen sind auf die Programmiersoftware [[AVRDUDE]] angepasst, jedoch lässt sich auch andere Programmiersoftware einbinden, sofern diese über Kommandozeile gesteuert werden kann (z.B. stk500.exe, uisp, sp12).

<pre class="code">
...
# Einstellung fuer STK500 an com1 (auskommentiert)
# AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
# AVRDUDE_PORT = com1 # programmer connected to serial device

# Einstellung fuer STK200-Dongle an lpt1
AVRDUDE_PROGRAMMER = stk200
AVRDUDE_PORT = lpt1
...
</pre>

Sollen Flash(=.hex) und EEPROM(=.eep) zusammen auf den Controller programmiert werden, ist das Kommentarzeichen vor AVRDUDE_WRITE_EEPROM zu löschen.

<pre class="code">
...
#Auskommentiert: EERPOM-Inhalt wird nicht mitgeschrieben
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

#Nich-auskommentiert EERPOM-Inhalt wird mitgeschrieben
AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
...
</pre>

== Anwendung ==

Die Eingabe von ''make all'' im Arbeitsverzeichnis mit dem makefile und den Quellcodedateien erzeugt (unter anderem) die Dateien superprog.hex und superprog.eep. Abhängigkeiten zwischen den einzelnen c-Dateien werden dabei automatisch berücksichtigt. Die ''superprog.hex'' und ''superprog.eep'' werden mit ''make program'' zum Controller übertragen. Mit ''make clean'' werden alle temporären Dateien gelöscht (="aufgeräumt").

== Sonstige Einstellungen ==

=== Optimierungsgrad ===

Der gcc-Compiler kennt verschiedene Stufen der Optimierung. Nur zu Testzwecken sollte die Optimierung ganz deaktiviert werden (''OPT = 0''). Die weiteren möglichen Optionen weisen den Compiler an, möglichst kompakten oder möglichst schnellen Code zu erzeugen. In den weitaus meisten Fällen ist ''OPT = s'' die optimale (sic) Einstellung, damit wird kompakter und oft auch der "schnellste" Maschinencode erzeugt.

=== Debug-Format ===

Unterstützt werden die Formate stabs und dwarf-2. Das Format wir hinter ''DEBUG ='' eingestellt. Siehe dazu Abschnitt ''Eingabedateien zur Simulation''.

=== Assembler-Dateien ===

Die im Projekt genutzten Assembler-Dateien werden hinter ASRC durch Leerzeichen getrennt aufgelistet. Assembler-Dateien haben immer die Endung .S (grosses S). Ist zum Beispiel der Assembler-Quellcode eines Software-UARTs in einer Datei softuart.S enthalten lautet die Zeile: ''ASRC = softuart.S''

== Eingabedateien zur Simulation in AVR-Studio ==

Mit älteren AVR-Studio-Versionen kann man nur auf Grundlage sogenannter ''coff''-Dateien simulieren. Neuere Versionen von AVR-Studio (ab 4.10.356) unterstützen zudem das modernere aber noch experimentelle dwarf-2-Format, das ab WinAVR 20040722 (avr-gcc 3.4.1/Binutils inkl. Atmel add-ons) "direkt" vom Compiler erzeugt wird.

; Vorgehensweise bei extcoff:
* im Makefile bei DEBUG: <pre class="code">DEBUG=stabs</pre>
* ''make extcoff'' (evtl. vorher ''make clean'')
* die erzeugte ''cof''-Datei (im Beispiel oben ''superprog.cof'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

; Vorgehensweise bei dwarf-2:
* im Makefile bei DEBUG: <pre class="code">DEBUG=dwarf-2</pre>
* ''make all'' (evtl. vorher ''make clean'')
* die erzeugte ''elf''-Datei (im Beispiel oben ''superprog.elf'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

Beim Simulieren scheinen oft "Variablen zu fehlen". Ursache dafür ist, dass der Compiler die "Variablen" direkt Registern zuweist. Dies kann vermieden werden, indem die Optimierung abgeschaltet wird (im makefile). Man simuliert dann jedoch ein vom optimierten Code stark abweichendes Programm. Das Abschalten der Optimierung wird nicht empfohlen.

Statt des Software-Simulators kann das AVR-Studio auch genutzt werden, um mit dem ATMEL JTAGICE, ein Nachbau davon (BootICE, Evertool o.ä.) oder dem ATMEL JTAGICE MKII "im System" zu debuggen. Dazu sind keine speziellen Einstellungen im makefile erforderlich. Debugging bzw. "In-System-Emulation" mit dem JTAGICE und JTAGICE MKII sind in der AVR-Studio Online-Hilfe beschrieben.

= Definition einiger Datentypen =

Für die Programmierung von Mikrocontrollern ist es sinnvoll, dass wir uns
vorerst einige Datentypen definieren, welche den Zugriff auf die verschiedenen
Komponenten des Controllers vereinfachen oder wenigstens das Programm lesbarer
machen können.

<pre class="code">
typedef unsigned char BYTE;
typedef unsigned short WORD;
</pre>

== BYTE ==

Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 255.

== WORD ==

Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 65535.

== DWORD ==

Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

== QWORD ==

Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

Bei allen vorgenannten Datentypen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z.B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich daher, die im folgenden Abschnitt beschriebenen standardisierten Datentypen zu nutzen und damit "Missverständnissen" vorzubeugen, die z.B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

= Standardisierte Integer(Ganzzahl)-Typen =

Standardisierte Datentypen werden in der Header-Datei inttypes.h definiert.
Will man diese Typen benutzen, bindet man die "Definitionsdatei" wie folgt ein:

<pre class="code">
#include <inttypes.h>
</pre>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<pre class="code">
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
</pre>

Ein Vierfach-Wort (64Bit) entspricht beim AVR ''uint64_t'', ein Doppel-[[Word|Wort]] (32bit) entspricht ''uint32_t'', ein Wort (16bit) entspricht ''uint16_t'' und ein [[Byte]] (8bit) entspricht ''uint8_t''.
Die Typen ohne vorangestelltes ''u'' können auch vorzeichenbehaftete Zahlen speichern. ''int8_t'' geht also von -128 bis 127, ''uint8_t'' dagegen geht von 0 bis 255.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Integer Types

== '''Bitfelder''' ==

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bit breit ist. 
Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in einer einzelnen Bytevariable zusammen fassen und (fast) wie
8 einzelne Variablen ansprechen können. 
Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente
definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<pre class="code">
struct {
unsigned char bStatus_1:1; // 1 Bit für bStatus_1
unsigned char bStatus_2:1; // 1 Bit für bStatus_2
unsigned char bNochNBit:1; // Und hier noch mal ein Bit
unsigned char b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</pre>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<pre class="code">
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</pre>

(mt Empfehlung: Bitfelder sparen zwar Platz, verschlechtern aber unter
Umständen die Les- und Wartbarkeit des Codes. Anfängern wird geraten,
ein "ganzes" ein Byte (uint8_t) zu nutzen auch wenn nur ein Bitwert gespeichert
werden soll.)

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten
Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher
Dinge erledigt werden können, welche nicht zeitkritisch sind. 
Wenn ein Interrupt ausgelöst wird so wird automatisch die zugeordnete
Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Allgemeiner Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heisst, das Programm kann die
Inhalte der Register auslesen und beschreiben. 
Einige Register haben spezielle Funktionen, andere wiederum könne für
allgemeine Zwecke (Speichern von Datenwerten) verwendet werden.

Einzelne Register sind bei allen AVR's vorhanden, andere wiederum nur bei
bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff
auf den UART notwendig sind selbstverständlich nur bei denjenigen Modellen
vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden
AVR-Typen definiert. 

Wenn im Makefile der MCU-Typ definiert ist, wird vom System automatisch die
zum Typen passende Definitionsdatei genutzt, sobald man im Code die allgemeine
"io.h" Header-Datei einbinden.

<pre class="code">
#include <avr/io.h>
</pre>

Ist im Makefile der MCU Type z.B. mit dem Inhalt atmega8 definiert,
wird beim einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit
den Register-Definitionen für den ATmega8 eingelesen.



== I/O-Register ==

Die I/O-Register haben einen besonderen Stellenwert bei den AVR Controllern.
Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. 
Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir mal
die 8-Bit Register.


=== Lesen eines I/O-Registers ===



Zum Lesen kann man auf I/O Register einfach wie auf eine
Variable zugreifen. Die spezielle Funktion inp() ist nicht mehr
notwendig und veraltet.

Beispiel:

<pre class="code">
#include <avr/io.h>
uint8_t foo;
...
int main(void)
{
foo=PINB; /* kopiert den Status der Eingabepins an PortB in die Variable foo */
...
}
</pre>

==== Lesen eines Bits ====

Die AVR-Bibliothek stellt auch Funktionen zur Abfrage eines einzelnen Bits
eines Registers zur Verfügung:

;bit_is_set (<Register>,<Bitnummer>) : Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 4 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>) : Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen bit_is_clear bzw. bit_is_set sind nicht unbedingt erfoderlich, man kann auch "einfachen" C-Syntax verwenden. Der universell verwendbar ist. ''bit_is_set'' entspricht dabei z.B. (Variable & (1<<Bitnummer)). Das Ergebnis ist <>0 wenn das Bit gesetzt und 0 wenn nicht gesetzt ist.

* siehe auch [[Bitmanipulation]]

=== Schreiben eines I/O-Registers ===



Zum Schreiben kann man I/O Register einfach wie eine
Variable setzen. Die spezielle Funktion outp() ist nicht mehr
notwendig, veraltet und sollte nicht mehr genutzt werden.

Beispiel:

<pre class="code">
#include <avr/io.h>
...
int main(void)
{
DDRA=0xff; /* Setzt das Richtungsregister des Ports A auf 0xff (alle Pins als Ausgang) */
PORTA=0x03; /* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low" */
...
}
</pre>

==== Schreiben eines Bits ====



Einzelne Bits setzt man "Standard-C-Konform" mittels logischen (bit-) Operationen.

mit dem Ausduck |=(1<<Bitnummer) wird ein Bit gesetzt, mit dem Ausdruck
&=~(1<<Bitnummer) wird ein Bit geloescht. Die Funktionen sbi und cbi sind
dazu nicht notwendig, veraltet und sollten nicht mehr genutzt werden.

Beispiel:
<pre class="code">
...
#define MEINBIT 2
...
PORTA |= (1<<MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1<<MEINBIT); /* loescht Bit 2 an PortA */
</pre>

* siehe auch:
** [[Bitmanipulation]]
** [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

=== Warten auf einen bestimmten Zustand ===

Es gibt in der Bibliothek sogar Funktionen, die Warten, bis ein bestimmter
Zustand auf einem Bit erreicht ist. 
Es ist allerdings normalerweise eine eher unschöne Programmiertechnik.

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das
definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits
gesetzt ist wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT 2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1<<WARTEBIT)) ) ;
</pre>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das
definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits
gelöscht ist wird die Funktion sofort wieder verlassen. 
Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT 4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// ungleich 0 ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
</pre>

Universeller und auch auf andere Platformen besser übertragbar ist die Verwendung von C-Standardoperationen.

siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]



= Zugriff auf Ports =

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind
jedem Port 3 Register zugeordnet:

{| border="1"
|-
| '''DDRx'''
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (anhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
| '''PORTx'''
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Wird ein Port als Eingang geschaltet, so können mit diesem Register
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|-
| '''PINx'''
| Eingangadresse für Port'''x'''.

Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der Portspins. Bit gesetzt (1) wenn Pin "high/an", Bit gelöscht (0) wenn Portpin "low/aus".
|}

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.


Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Wollen wir also beispielsweise Pin 0 bis 4 von Port B als Ausgänge
definieren so schreiben wir folgende Zeile:


<pre class="code">
#include <avr/io.h>
...
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F

DDRB=0x1F; /* direkte Zuweisung - unuebersichtlich */
/* mehr Tipparbeit aber uebersichtlicher: */
DDRB=(1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3)|(1<<DDB4);
...
</pre>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet.

=== Ganze Ports ===

Um einen ganzen Port als Ausgang zu definieren, kann der folgende Befehl
verwendet werden:

<pre class="code">
DDRB=0xff;
</pre>

Im Beispiel wird der Port B als Ganzes als Ausgang geschaltet.

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen
bzw. auszugeben.

== Ausgänge ==

Wir wollen nun einen als Ausgang definierten Pin auf Logisch 1 setzen. Dazu schreiben wir den entsprechenden Wert in das Portregister des entsprechenden Ports.

Mit dem Befehl

<pre class="code">
PORTB=0x04; /* besser PORTB=(1<<DDB2) */
</pre>

wird also der Ausgang an Pin 2 gesetzt (Beachte, dass die Bits immer ''von 0 an''
gezählt werden, das niederwertigste Bit ist also Bit 0 und nicht etwa Bit 1).

Man beachte bitte, dass bei der Zuweisung mittels '''='''  immer alle Pins gleichzeitig angegeben werden. Man sollte also zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfliessen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an PortB auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<pre class="code">
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<DDB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<DDB2)
</pre>


Die Funktionen cbi und sbi sind dazu nicht notwendig, veraltet und sollten
nicht mehr genutzt werden.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wird den Pegel über entsprechende Hardware (z.B. Optokoppler, Spannunsteiler "Levelshifter") anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unserer Controllers eine logische 1 (Vcc) oder eine logische 0 (Masse) anliegt.

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.



Wobei es hier sehr wichtig ist, zur Abfrage der Eingänge nicht etwa das Portregister '''PORTx''' zu verwenden, sondern die Porteingangsadresse '''PINx'''. Dies ist
ein oft gemachter Fehler!

Wollen wir also die aktuellen Signalzustände von Port D abfragen und in einer
Variable namens bPortD abspeichern so schreiben wir dazu folgende Befehlszeile:

<pre class="code">
#include <avr/io.h>
...
bPortD = PIND;
...
</pre>


=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen (''Active Low'' und ''Active High''):

{| border="1"
|-
| '''Active Low'''
| '''Active High'''
|-
| [[Image:Active Low.gif]]
| [[Image:Active High.gif]]
|-
| Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet.

Damit bei offenem Schalter der Controller kein undefiniertes Signal
bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein
sogenannter Pull-Up Widerstand geschaltet. Dieser dient dazu, den Pegel
bei geöffnetem Schalter auf logisch 1 zu ziehen. 
Der Widerstandswert des Pull-Up Widerstands ist an sich nicht kritisch. Es
muss jedoch beachtet werden, dass über den Widerstand ein Strom in den
Eingang fliesst, also sollte er nicht zu klein gewählt werden um den
Controller nicht zu zerstören. Wird er allerdings zu hoch gewählt ist
die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10
Kiloohm eingebürgert.

Die AVR's haben sogar an den meisten Pins softwaremässig zuschaltbare
interne Pull-Up Widerstände, welche wir natürlich auch verwenden
können.
| Hier wird der Kontakt zwischen die Versorgungsspannung und Masse geschaltet.

Damit bei offener Schalterstellung kein undefiniertes Signal am Controller
ansteht, wird zwischen den Eingangspin und die Masse ein Pull-Down
Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter
Schalterstellung auf logisch 0 zu halten.
|}

==== Pull-Up Widerstände aktivieren ====

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden
über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang'''
geschaltet ist. 

Wird der Wert des entsprechenden Portpins auf 1 gesetzt so ist
der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up
Widerstand nicht aktiv. 
Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand
verwenden, aber nicht beide zusammen.



<pre class="code">
#include <avr/io.h>
...
DDRD=0x00; /* alle Pins von Port D als Eingang */
PORTD=0xff: /* interer Pull-Up an allen Port-Pins aktivieren */
...
</pre>

Im Beispiel wird der gesamte Port D als Eingang geschaltet und alle Pull-Up
Widerstände aktiviert.

===== Tastenentprellung =====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von
Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim
Schliessen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern
mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes. 
Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein
solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen
als mehrfache Impulse gezählt wird. 
Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen
werden.

ToDo Bsp Quellcode

== Analog ==

Leider können wir mit unseren Controllern keine analogen Werte direkt
ausgeben oder einlesen. Dazu müssen wir Umwege gehen, doch dies wird in einem späteren
Kapitel behandelt.

=== 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1) ===

Einige der Portregister in den AVR-Controllern sind 16 Bit breit, Man spricht
dann von einem '''Wort'''.


Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<pre class="code">
#include <avr/io.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8

= Der UART, Teil 1 =

Wir werden in zukünftigen Übungen in die Situation kommen, dass wir
Informationen vom Controller auswerten bzw. anzeigen müssen wobei es vielleicht
dann nicht mehr reicht, ein paar Leuchtdioden anzusteuern. 
Somit brauchen wir eine Verbindung vom AVR zu unserem PC, und dies am besten
über die serielle Schnittstelle.

== Allgemeines zum UART ==

Einige AVR-Controller haben einen vollduplexfähigen UART ('''U'''niversal
'''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut.
Dies ist eine wirklich feine Sache, haben wir doch damit schon das nötige
Werkzeug, um mit anderen Geräten, welche über eine serielle Schnittstelle
verfügen (insbesondere mit unserem PC), zu kommunizieren.

Übrigens: Vollduplex heisst nichts anderes, als dass der Baustein gleichzeitig
senden und empfangen kann.

Neuere AVRs (ATmega) verfügen über einen oder zwei U'''S'''ART(s), dieser unterschiedet sich vom UART häuptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

Der UART wird über vier separate Register angesprochen. USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurations/Datenregister. Das Datenblatt gibt darüber Auskunft. Die Folgende Tabelle gibt nur die Register für die (veralteten) UARTs wieder.

{| border="1"
|-
| '''UCR   '''
| '''U'''ART '''C'''ontrol '''R'''egister. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXCIE'''
| align="center" | '''TXCIE'''
| align="center" | '''UDRIE'''
| align="center" | '''RXEN'''
| align="center" | '''TXEN'''
| align="center" | '''CHR9'''
| align="center" | '''RXB8'''
| align="center" | '''TXB8'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''CHR9''' (9 Bit Characters)
:Wenn dieses Bit gesetzt ist, können 9 Bit lange Zeichen übertragen und empfangen werden. Das 9. Bit kann bei Bedarf als zusätzliches Stopbit oder als Paritätsbit verwendet werden. Man spricht dann von einem 11-Bit Zeichenrahmen:
:1 Startbit + 8 Datenbits + 1 Stopbit + 1 Paritätsbit = 11 Bits

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.

|-
| '''USR   '''
| '''U'''ART '''S'''tatus '''R'''egister. 
Hier teilt uns der UART mit, was er gerade so macht.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXC'''
| align="center" | '''TXC'''
| align="center" | '''UDRE'''
| align="center" | '''FE'''
| align="center" | '''OR'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt bevor ein weiteres Zeichen komplett empfangen wurde wird eine Überlauf-Fehlersituation eintreffen. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, wenn die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit wird vom AVR gesetzt, wenn ein Zeichen vom Sendedatenregister in das Send-Schieberegister übernommen wurde und der UART nun wieder bereit ist, ein neues Zeichen zum Senden aufzunehmen.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''OR''' ('''O'''ver'''R'''un) 
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne
kommunizieren möchten. Der Wert, der in dieses Register geschrieben
werden muss, errechnet sich nach folgender Formel:

<math>
\begin{matrix}
UBRR = \frac{Taktfrequenz}{Baudrate * 16} - 1
\end{matrix}
</math>

Es sind Baudraten bis zu 115200 Baud und höher möglich.
|}

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (LOW) und 5V (HIGH). Die
Schnittstellenspezifikation für RS232 definiert jedoch -3V ... -12V (LOW) und
+3 ... +12V (HIGH). Zudem muss der Signalaustausch zwischen AVR und
Partnergerät invertiert werden. Für die Anpassung der Pegel und das
Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste
davon ist wohl der MAX232. Allerdings kostet der auch wieder Geld und benötigt
zusätzlich immerhin 4 externe Elkos.

Die in den PC eingebauten Schnittstellen vertragen ohne Klagen auch den
TTL-Pegel vom AVR. Allerdings müssen wir immer noch die Signale invertieren. Im
einfachtesn Fall verwenden wir dazu jeweils einen einfachen NPN-Transistor und 2
Widerstände. Näheres dazu erfahrt ihr in den folgenden Übungen.

Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z.B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfielt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Senden mit dem UART ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. 
Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach
gewünschter Funktionsweise die
benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister. 
Da wir vorerst nur senden möchten und (noch) keine Interrupts auswerten wollen,
gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das
'''Transmitter Enable''' Bit setzen müssen:


<pre class="code">
UCR |= (1<<TXEN);
</pre>

Der Atmega16 hat mehrere Konfigurationsregister für USART und erfordert eine etwas andere Konfiguration

<pre class="code">
UCSRB |= (1<<TXEN); //UART TX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1
</pre>

Nun müssen wir noch die Baudrate festlegen. Gemäß unserer Formel brauchen
wir dazu die Taktfrequenz des angeschlossenen Oszillators bzw. Quarz in die
Formel einzufügen und das Resultat der Berechnung in das Baudratenregister des
UART einzuschreiben:

<pre class="code">
/* UART-Init beim AT90S2313 */
#define F_CPU 4000000; // Zum Beispiel 4Mhz-Quarz
#define UART_BAUD_RATE 9600 // Wir versuchen mal mit 9600 Baud
UBRR = F_CPU / (UART_BAUD_RATE * 16L) - 1;
</pre>

Wieder für den Mega16 mit einem 16bit-Register eine andere Programmierung

<pre class="code">
/* USART-Init beim ATmegaXX */
#define F_OSC 3686400 /* Oszillator-Frequenz in Hz */
#define UART_BAUD_RATE 9600
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)

UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

/* alternativ bei der avr-libc "direkt 16bit" : */
UBRR=UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);
</pre>

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben.

<pre class="code">
while (USR & (1<<UDRE)); /* warten bis Senden moeglich */
UDR = 'x'; // Schreibt das Zeichen x auf die Schnittstelle
</pre>

=== Schreiben einer Zeichenkette (String) ===

Es ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

Zu diesem Zweck können wir uns für's Erste eine einfache Funktion basteln:

<pre class="code">
void SendeString (char *szBuf)
{
while (*szBuf) {
loop_until_bit_is_set (USR, UDRE); /* warten bis Senden moeglich */
UDR=*szBuf;
szBuf++;
}
}
</pre>

Warteschleifen sind insofern etwas kritisch, da während des Sendens eines
Strings nicht mehr auf andere Ereignisse reagieren werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. emfangenen Zeichen/Bytes zwischengespeichert und mittels Interruptroutinen an den U(S)ART weitergebgen bzw. ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

* siehe auch: Weiterführende Informationen inkl. Beispielen für die Nutzung von stdio-Funktionen (prinf etc.) im [[AVR-Tutorial - UART]].
* [http://homepage.sunrise.ch/mysunrise/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc

= Analoge Ein- und Ausgabe =

Leider können wir mit unseren Controllern keine analogen Werte direkt
verarbeiten. Dazu bedarf es jeweils einer Umwandlung des analogen Signals in
einen digitalen Zahlenwert. Je nachdem, ob wir Daten einlesen oder ausgeben
wollen reden wir dabei von '''ADC''' oder '''DAC'''.

== ADC (Analog Digital Converter) ==

Der '''ADC''' wandelt analoge Signale in digitale Werte um, welche vom Controller
interpretiert werden können. Einige AVR-Typen haben bereits einen oder mehrere
solcher '''ADC''''s eingebaut, bei den kleineren AVR's müssen wir uns anders aus der
Affäre ziehen. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst
werden kann, wird durch die Auflösung des '''ADC''' in Anzahl Bits angegeben, man
hört bzw. liest jeweils von 8-Bit '''ADC''' oder 10-Bit ''' ADC''' oder noch höher. 
Ein '''ADC''' mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit
von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten
eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

<div align="center"><center>

{| border="1"
|-
| align="center" | '''Eingangsspannung am ADC'''
| align="center" | '''Entsprechender Messwert'''
|-
| align="center" | 0...<0.625V
| align="center" | 0
|-
| align="center" | 0.625...<1.25V
| align="center" | 1
|-
| align="center" | 1.25...<1.875V
| align="center" | 2
|-
| align="center" | 1.875...<2.5V
| align="center" | 3
|-
| align="center" | 2.5...<3.125V
| align="center" | 4
|-
| align="center" | 3.125...<3.75V
| align="center" | 5
|-
| align="center" | 3.75...<4.375V
| align="center" | 6
|-
| align="center" | 4.375...5V
| align="center" | 7
|}

</center>
</div>

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des '''
ADC''' ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Messen eines Widerstandes ===

Wir wollen hier einmal die wohl einfachste Methode zur Erfassung eines
analogen Wertes realisieren und zwar das Messen eines veränderlichen
Widerstandes wie z.B. eines Potentiometers.

Man stelle sich vor, wir schalten einen Kondensator in Reihe zu einem
Widerstand zwischen die Versorgungsspannung und Masse und dazwischen nehmen wir
das Signal ab und führen es auf einen der Pins an unserem Controller, genau so
wie es in folgender Grafik dargestellt ist.

[[Image:Poti.gif]]

Wenn wir nun den Pin des AVR als Ausgang schalten und auf
Logisch 1 (HIGH) legen, dann liegt an beiden Platten des Kondensators ''' Vcc''' an und
dieser wird entladen (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen). 
Nachdem nun der Kondensator genügend entladen ist schalten wir einfach den Pin
als Eingang wodurch dieser hochohmig wird. Der Kondensator lädt sich jetzt
über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und
derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti
unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), dann schaltet der
Eingang von HIGH auf LOW um. Wenn wir nun messen (zählen), wie lange es dauert,
bis der Kondensator so weit geladen ist, dann haben wir einen ungefähren Wert
der Potentiometerstellung. 
Der 220 Ohm Widerstand dient dem Schutz des Controllers. Wenn nämlich sonst die
Potentiometerstellung auf Maximum steht (0 Ohm), dann würde in den Eingang des
Controllers ein viel zu hoher Strom fliessen und der AVR würde in Rauch
aufgehen.

Dies ist meines Wissens die einzige Schaltung zur Erfassung von
Analogwerten, welche mit nur einem einzigen Pin auskommt. 
Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine
Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B:
0...100 % oder so) umzurechnen.

Wer Lust hat, sich selber mal an ein solches Programm
heranzuwagen, der sollte das jetzt tun. Für diejenigen, die es gern schnell
mögen, hier das Beispielprogramm, welches den UART-Printf aus den
vorangegangenen Kapiteln benötigt, inkl. Makefile:

{| border="0"
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Poti.c Poti.c ]
| Hauptprogramm.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.c Pot.c]
| Separate Routine zur Ermittlung des Messwertes.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.h Pot.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c UartPrintF.c]
| Für die Debugausgabe auf den UART.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h UartPrintF.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile Makefile]
| Makefile.
|}

Nachdem das Programm auf den AVR geladen wurde, muss dieser
kalibriert werden. Dazu wird der Kalibrierungsschalter geschlossen und das Poti
einige Male zwischen minimaler und maximaler Stellung hin und her gedreht. Dabei
werden die jeweiligen Maximalwerte bestimmt. Wenn der Kalibrierschalter wieder
geöffnet wird werden die Kalibrierungsdaten in's EEPROM des AVR geschrieben,
damit die Prozedur nicht nach jedem Reset wiederholt werden muss.

Auf Pin 4 habe ich noch ein Triggersignal gelegt, welches auf
HIGH geht wenn die Messung beginnt und auf LOW, wenn der Messvorgang beendet
wird. Mit Hilfe dieses Signals kann der Vorgang wunderschön auf einem
Oszillographen dargestellt werden.

=== ADC über Komparator ===

Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

[[Image:ADC ueber Komparator.gif]]

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert. 
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

=== Der ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem '''ADC-Wandler''' zurückgreifen. Wir wollen hier einmal den AT90S8535 besprechen, welcher über 8 ADC-Kanäle verfügt. (TODO: nur ein Wandler, Mulitiplexbetrieb, nur eine Pin zur gleichen Zeit)

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung.

Verfügt der AVR über eine interne Referenzspannung (Datenblatt typisch 2,56 oder 1,1V je nach AVR), bleibt der ''Anschluss AREF'' unbeschaltet und man stellt die ADC-Register so ein, dass die interne Referenzspannung als "AREF" genutzt wird. Ansonsten ist eine externe Referenzspannung von maximal '''Vcc''' an den Abschluss '''AREF''' anzulegen. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden.

==== Einfache Wandlung (Single Conversion) ====

In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestossen für jeweils eine Messung.

==== Frei laufend (Free Running) ====

In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register, welche hier aufgelistet werden.

{| border="1"
|-
| '''ADCSR   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ADEN'''
| align="center" | '''ADSC'''
| align="center" | '''ADFR'''
| align="center" | '''ADIF'''
| align="center" | '''ADIE'''
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt, ist können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''Fr'''ee Running Select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Eine logische 1 aktiviert den frei laufenden Modus. Der ''' ADC''' misst nun ständig den ausgewählten Kanal und schreibt den gemessenen Wert in das '''ADC Data Register'''.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, wenn eine Umwandlung erfolgt und das '''ADC Data Register''' aktualisiert ist.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird (So steht es in der AVR-Dokumentation).

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200kHz}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50kHz}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.
<dl><dd>
{| style="" border="1"
|-
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
| align="center" | '''Teilungsfaktor'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 2
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 2
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 4
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 8
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 16
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 32
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 64
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 128
|}
</dd></dl>
|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<pre class="code">
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
C-Operatorprioritaet sichergestellt)
</pre>

oder

<pre class="code">
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</pre>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''MUX2'''
| align="center" | '''MUX1'''
| align="center" | '''MUX0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''MUX2...MUX0'''
:Mit diesem 3 Bits wird der zu messende Kanal bestimmt. Es wird einfach die entsprechende Pinnummer des Ports eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Meine Empfehlung ist deswegen klar diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Aktivieren des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register
setzen. Im gleichen Schritt legen wir auch gleich die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls mit Spannungsteiler konditionieren. Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1024 für V_ref-Volt.

<pre class="code">

#define CHANNELOFFSET 4

uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result;

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler setzen auf 8 (1)
ADCSRA |= (1<<ADEN); // ADC aktivieren (1)

ADMUX = CHANNELOFFSET+channel; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)

result = 0;

/* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
for(i=0;i<4;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)
result += ADC; // Wandlungsergebnisse aufaddieren
}

ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)

result >>= 2; // Summe durch vier teilen = arithm. Mittelwert

return result;
}
</pre>

Im Beispiel wird bei jedem Aufruf der ADC aktiviert und nach der Wandlung wieder abgeschaltet, das spart Strom. Will man dies nicht, verschiebt man die mit (1) gekenntzeichneten Zeilen in eine Funktion adc_init() o.ä. und löscht die mit (2) markierten Zeilen.



== DAC (Digital Analog Converter) ==

Mit Hilfe eines ''' DAC''' können wir nun auch Analogsignale ausgeben. Es gibt hier
mehrere Verfahren. Wenn wir beim ''' ADC''' die Möglichkeit haben, mit externen
Komponenten zu operieren, müssen wir bei der '''DAC'''-Wandlung mit dem auskommen, was
der Controller selber zu bieten hat.

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie ''' PWM''' eigentlich funktioniert.

Wie wir alle wissen ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber
wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. 
Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen
HIGH und LOW umschalten? 
Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen geometrischen Mittelwert, der je nach Pulsbreite
kleiner oder grösser ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein
RC-Glied filtern dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVR's können wir direkt '''PWM'''-Signale erzeugen. Dazu
dient der 16-Bit Zähler, welcher im sogenannten '''PWM'''-Modus betrieben werden
kann.

Hinweis:
:In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist allerdings bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt.

Um den '''PWM'''-Modus zu aktivieren müssen im Timer/Counter1 Control
Register A '''TCCR1A''' die Pulsweiten-Modulatorbits '''PWM10''' bzw. '''PWM11''' entsprechend
nachfolgender Tabelle gesetzt werden:

{| border="1"
|-
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| PWM-Modus des Timers ist nicht aktiv.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM.
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben. Die
Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| border="1"
|-
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden heisst dann:

<pre class="code">
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</pre>

Damit der Timer/Counter überhaupt läuft müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorzähler) einstellen, und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| border="1"
|-
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<pre class="code">
TCCR1B = (1<<CS12) | (1<<CS10);
</pre>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<pre class="code">
OCR1A = xxx;
</pre>

Die folgende Grafik soll den Zusammenhang zwischen dem
Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren.

= Die Timer/Counter des AVR =

Die heutigen Mikrocontroller und insbesondere die RISC-AVR's sind für viele
Steuerungsaufgaben natürlich viel zu schnell. Wenn wir beispielsweise eine LED
oder Lampe blinken lassen wollen, können wir selbstverständlich nicht die
CPU-Frequenz verwenden da ja dann nichts mehr vom Blinken zu bemerken wäre.

Wir brauchen also eine Möglichkeit, die Taktfrequenz auf vernünftige Werte
herunter zu brechen. Selbstverständlich sollte die resultierende Frequenz dann
auch noch einigermassen genau und stabil sein.

Hier kommen die im AVR vorhandenen Timer/Counter zum Einsatz.

Ein anderes Anwendungsgebiet ist die Zählung von Signalen, welche über
einen I/O-Pin zugeführt werden können.

Die folgenden Ausführungen beziehen sich auch den AT90S2313. Für andere
Modelltypen müsst ihr euch die allenfalls notwendigen Anpassungen aus den
Datenblättern der entsprechenden Controller herauslesen.

Wir unterscheiden grundsätzlich zwischen 8-Bit Timern, welche eine
Auflösung von 256 aufweisen und 16-Bit Timern mit (logischerweise) einer
Auflösung von 65536.

Als Eingangstakt für die Timer/Counter kann entweder die CPU-Taktfrequenz,
der Vorteiler-Ausgang oder ein an einen I/O-Pin angelegtes Signal verwendet
werden. Wenn ein externes Signal verwendet wird, so darf dessen Frequenz nicht
höher sein als die Hälfte des CPU-Taktes.

=== Der Vorzähler (Prescaler) ===

Beide Timer/Counter werden im Timerbetrieb über den gleichen Vorzähler
versorgt.

Der Vorzähler dient dazu, den CPU-Takt vorerst mal runter zu brechen auf eine
wählbare Teilung. Die so geteilte Frequenz wird den Eingängen der Timer
zugeführt.

Wenn wir mit einer einem CPU-Takt von 4 MHz arbeiten und den Vorteiler auf 1024
einstellen wird also der Timer mit einer Frequenz von 4 MHz / 1024, also mit ca.
4 kHz versorgt. Wenn also der Timer läuft, so wird das Daten- bzw.
Zählregister mit dieser Frequenz inkrementiert.

== 8-Bit Timer/Counter ==

Alle AVR-Modelle weisen mindestens einen, teilweise sogar zwei, 8-Bit Timer
auf.

Der 8-Bit Timer wird über folgende Register angesprochen:

{| border="1"
|-
| '''TCCR0'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
Timer '''0'''

In diesem Register stellen wir ein, wie wir den Timer/Counter verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CS02'''
| align="center" | '''CS01'''
| align="center" | '''CS00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''CS02, CS01, CS00''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS02
| align="center" | CS01
| align="center" | CS00
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin '''TO''', fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin '''TO''', steigende Flanke
|}
</dd>
</dl>
:Wenn als Quelle der externe Pin '''TO''' verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin '''TO''' als Ausgang geschaltet ist.

|-
| '''TCNT0'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer '''0''' 
Dieses ist als 8-Bit Aufwärtszähler mit Schreib- und Lesezugriff
realisiert. Wenn der Zähler den Wert 255 erreicht hat beginnt er beim
nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}
|}

Um nun also den Timer0 in Betrieb zu setzen und ihn mit einer Frequenz von 1/1024-tel des CPU-Taktes zählen zu lassen, schreiben wir die folgende Befehlszeile:

<pre class="code">
TCCR0 = (1<<CS00)|(1<<CS02);
</pre>

Der Zähler zählt nun aufwärts bis 255, um dann wieder bei 0 zu beginnen. Der aktuelle Zählerstand steht in TCNT0. Bei jedem Überlauf von 255 auf 0 wird das Timer Overflow Flag '''TOV0''' im Timer Interrupt Flag '''TIFR'''-Register gesetzt und, falls so konfiguriert, ein entsprechender Timer-Overflow-Interrupt ausgelöst.

== 16-Bit Timer/Counter ==

Viele AVR-Modelle besitzen ausser den 8-Bit Timers auch einen oder sogar zwei
(einige ATmega-Modelle) 16-Bit Timer.

Die 16-Bit Timer/Counter sind wesentlich komplexer aufgebaut als die 8-Bit
Timer/Counter, bieten dafür aber auch viel mehr Möglichkeiten, als da sind:

* Die [[PWM]]-Betriebsart Erzeugung eines pulsweitenmodulierten Ausgangssignals.
* Vergleichswert-Überprüfung mit Erzeugung eines Ausgangssignals (Output Compare Match).
* Einfangen eines Eingangssignals mit Speicherung des aktuellen Zählerwertes (Input Capturing), mit zuschaltbarer Rauschunterdrückung (Noise Filtering).

Folgende Register sind dem Timer/Counter 1 zugeordnet:

{| border="1"
|-
| '''TCCR1A'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''A''' Timer '''1''' 
In diesem und dem folgenden Register stellen wir ein, wie wir den Timer/Counter verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''COM1A1''', '''COM1A0''' ('''Co'''mpare '''M'''atch Control Bits)
:Diese 2 Bits bestimmen die Aktion, welche am Output-Pin '''OC1''' ausgeführt werden soll, wenn der Wert des Datenregisters des Timer/Counter 1 den Wert des Vergleichsregisters erreicht, also ein so genannter Compare Match auftritt.
:Der Pin '''OC1''' ('''PB3''' beim 2313) muss mit dem Datenrichtungsregister als Ausgang konfiguriert werden.

<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Das Signal am Pin '''OC1''' wird invertiert (Toggle).
|-
| align="center" | 1
| align="center" | 0
| Der Output Pin '''OC1''' wird auf 0 gesetzt.
|-
| align="center" | 1
| align="center" | 1
| Der Output Pin '''OC1''' wird auf 1 gesetzt.
|}
</dd></dl>
:In der PWM-Betriebsart haben diese Bits eine andere Funktion.
<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 1
| align="center" | 0
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 0 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 1 gesetzt.

Man nennt dies ''nicht invertierende PWM''.
|-
| align="center" | 1
| align="center" | 1
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 1 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 0 gesetzt.

Man nennt dies ''invertierende PWM''.
|}
</dd></dl>

'''PWM11''', '''PWM10''' ('''PWM''' Mode Select Bits)
:Mit diesen 2 Bits wird die PWM-Betriebsart des Timer/Counter 1 gesteuert.
<dl><dd>
{| border="1"
|-
| align="center" | PWM11
| align="center" | PWM10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Die PWM-Betriebsart ist nicht aktiviert. Timer/Counter 1 arbeitet als normaler Timer bzw. Zähler.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM Betriebsart aktivieren.
|}
</dd></dl>
|-
| '''TCCR1B'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''B''' Timer '''1'''

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ICNC1'''
| align="center" | '''ICES1'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CTC1'''
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''ICNC1''' ('''I'''nput '''C'''apture '''N'''oise '''C'''anceler (4 CKs) Timer/Counter 1
:oder auf Deutsch Rauschunterdrückung des Eingangssignals.
:Wenn dieses Bit gesetzt ist und mit dem Input Capture Signal gearbeitet wird so werden nach der Triggerung des Signals mit der entsprechenden Flanke (steigend oder fallend) am Input Capture Pin '''ICP''' jeweils 4 Messungen mit der CPU-Frequenz des Eingangssignals abgefragt. Nur dann, wenn alle 4 Messungen den gleichen Zustand aufweisen gilt das Signal als erkannt.

'''ICES1''' ('''I'''nput '''C'''apture '''E'''dge '''S'''elect Timer/Counter '''1''')
:Mit diesem Bit wird bestimmt, ob die steigende ('''ICES1'''=1) oder fallende ('''ICES1'''=0) Flanke zur Auswertung des Input Capture Signals an Pin '''ICP''' heran gezogen wird.

'''CTC1''' ('''C'''lear '''T'''imer/'''C'''ounter on Compare Match Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, so wird nach einer Übereinstimmung des Datenregisters '''TCNT1H'''/'''TCNT1L''' mit dem Vergleichswert in '''OCR1H'''/'''OCR1L''' das Datenregister '''TCNT1H'''/'''TCNT1L''' auf 0 gesetzt.
:Da die Übereinstimmung im Takt nach dem Vergleich behandelt wird, ergibt sich je nach eingestelltem Vorzähler ein etwas anderes Zählverhalten:
:Wenn der Vorteiler auf 1 gestellt ist und C der jeweilige Zählerwert ist, dann nimmt das Datenregister, im CPU-Takt betrachtet, folgende Werte an:
:... | C-2 | C-1 | C | 0 | 1 |...
:Wenn der Vorteiler z.B. auf 8 eingestellt ist, dann nimmt das Datenregister folgende Werte an:
:... | C-2, C-2, C-2, C-2, C-2, C-2, C-2, C-2 | C-1, C-1, C-1, C-1, C-1, C-1, C-1, C-1 | C, 0, 0, 0, 0, 0, 0, 0 |...
:In der PWM-Betriebsart hat dieses Bit keine Funktion.

'''CS12''', '''CS11''', '''CS10''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS12
| align="center" | CS11
| align="center" | CS10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin TO, fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin T0, steigende Flanke
|}
</dd></dl>
:Wenn als Quelle der externe Pin T0 verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin T0 als Ausgang geschaltet ist.
|-
| '''TCNT1H''' '''TCNT1L'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer/Counter '''1'''
Dieses ist als 16-Bit Aufwärtszähler mit Schreib- und Lesezugriff realisiert. Wenn der Zähler den Wert 65535 erreicht hat, beginnt er beim nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''TCNT1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''TCNT1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

In der PWM-Betriebsart wird das Register als Auf/Ab-Zähler verwendet, d.h. der Wert steigt zuerst von 0 bis er den Überlauf von 65535 auf 0 erreicht hat. Dann zählt das Register rückwärts wiederum bis 0.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.

Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''OCR1H''' '''OCR1L'''
| Timer/Counter '''O'''utput '''C'''ompare '''R'''egister Timer/Counter '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''OCR1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''OCR1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Der Wert im Output Compare Register wird ständig mit dem aktuellen Wert im Datenregister TCNT1H/TCNT1L verglichen. Stimmen die beiden Werte überein, so wird ein sogenannter Output Compare Match ausgelöst. Die entsprechenden Aktionen werden über die Timer/Counter 1 Control und Status Register eingestellt.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''ICR1H''' '''ICR1L'''
| Timer/Counter '''I'''nput '''C'''apture '''R'''egister Timer/Counter '''1''' 
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''ICR1''''''H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''ICR1''''''L'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Das Input Capture Register ist ein 16-Bit Register mit Lesezugriff. Es kann nicht beschrieben werden.

Wenn am Input Capture Pin '''ICP''' die gemäß Einstellungen im '''TCCR1B''' definierte Flanke erkannt wird, so wird der aktuelle Inhalt des Datenregisters '''TCNT1H'''/'''TCNT1L''' sofort in dieses Register kopiert und das Input Capture Flag '''ICF1''' im Timer Interrupt Flag Register '''TIFR''' gesetzt.

Wie bereits oben erwähnt, müssen vor dem Zugriff auf dieses Register alle Interrupts gesperrt werden. Zudem müssen Low- und Highbyte des Registers in der richtigen Reihenfolge bearbeitet werden:

{| border="0"
|-
| Lesen:
| '''ICR1L''' -> '''ICR1H'''
|-
| Schreiben:
| '''ICR1H''' -> '''ICR1L'''
|}
|}

=== Die PWM-Betriebsart ===

Wenn der Timer/Counter 1 in der PWM-Betriebsart betrieben wird, so bilden das Datenregister '''TCNT1H'''/'''TCNT1L''' und das Vergleichsregister '''OCR1H'''/'''OCR1L''' einen 8-, 9- oder 10-Bit, frei laufenden PWM-Modulator, welcher als PWM-Signal am '''OC1'''-Pin ('''PB3''' beim 2313) abgegriffen werden kann. Das Datenregister '''TCNT1H'''/'''TCNT1L''' wird dabei als Auf-/Ab-Zähler betrieben, welcher von 0 an aufwärts zählt bis zur Obergrenze und danach wieder zurück auf 0.
Die Obergrenze ergibt sich daraus, ob 8-, 9- oder 10-Bit PWM verwendet wird, und zwar gemäss folgender Tabelle:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Wenn nun der Zählerwert im Datenregister den in '''OCR1H'''/'''OCR1L''' gespeicherten Wert erreicht, wird der Ausgabepin '''OC1''' gesetzt bzw. gelöscht, je nach Einstellung von '''COM1A1''' und '''COM1A0''' im '''TCCR1A'''-Register.

Ich habe versucht, die entsprechenden Signale in der folgenden Grafik zusammenzufassen

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

=== Vergleichswert-Überprüfung ===

Hier wird in ein spezielles Vergleichswertregister ('''OCR1H'''/'''OCR1L''') ein Wert eingeschrieben, welcher ständig mit dem aktuellen Zählerwert verglichen wird.
Erreicht der Zähler den in diesem Register eingetragenen Wert, so kann ein Signal (0 oder 1) am Pin '''OC1''' erzeugt und/oder ein Interrupt ausgelöst werden.

=== Einfangen eines Eingangssignals (Input Capturing) ===

Bei dieser Betriebsart wird an den Input Capturing Pin (ICP) des Controllers eine Signalquelle angeschlossen.
Nun kann je nach Konfiguration entweder ein Signalwechsel von 0 nach 1 (steigende Flanke) oder von 1 nach 0 (fallende Flanke) erkannt werden und der zu diesem Zeitpunkt aktuelle Zählerstand in ein spezielles Register abgelegt werden. Gleichzeitig kann auch ein entsprechender Interrupt ausgelöst werden.
Wenn die Signalquelle ein starkes Rauschen beinhaltet, kann die Rauschunterdrückung eingeschaltet werden. Dann wird beim Erkennen der konfigurierten Flanke über 4 Taktzyklen das Signal überwacht und nur dann, wenn alle 4 Messungen gleich sind, wird die entsprechende Aktion ausgelöst.

== Gemeinsame Register ==

Verschiedene Register beinhalten Zustände und Einstellungen, welche sowohl
für den 8-Bit, als auch für den 16-Bit Timer/Counter in ein und demselben
Register zu finden sind.

{| border="1"
|-
| '''TIMSK'''
| '''T'''imer/Counter '''I'''nterrupt '''M'''a'''sk'''
Register

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOIE1'''
| align="center" | '''OCIE1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''TICIE'''
| align="center" | '''-'''
| align="center" | '''TOIE0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOIE1''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 1 ein Timer Overflow 1 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''OCIE1A''' ('''O'''utput '''C'''ompare Match '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Beim Timer/Counter 1 kann zusätzlich zum Überlauf ein Vergleichswert definiert werden.

:Wenn dieses Bit gesetzt ist, wird beim Erreichen des Vergleichswertes ein Compare Match Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TICIE''' ('''T'''imer/Counter '''I'''nput '''C'''apture '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein Capture Event Interrupt ausgelöst, wenn ein entsprechendes Signalereignis am Pin PD6(ICP) auftritt. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein, wenn auch ein entsprechender Interrupt ausgelöst werden soll.

'''TOIE0''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''0''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 0 ein Timer Overflow 0 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

|-
| '''TIFR'''
| '''T'''imer/Counter '''I'''nterrupt '''F'''lag '''R'''egister

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOV1'''
| align="center" | '''OCF1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''ICF1'''
| align="center" | '''-'''
| align="center" | '''TOV0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOV1''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''1''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 1 ein Überlauf des Datenregisters stattfindet.

:In der PWM-Betriebsart wird das Bit gesetzt, wenn die Zählrichtung von auf- zu abwärts und umgekehrt geändert wird (Zählerwert = 0).

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''OCF1A''' ('''O'''utput '''C'''ompare '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn der aktuelle Wert des Datenregisters von Timer/Counter 1 mit demjenigen im Vergleichsregister '''OCR1''' übereinstimmt.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''ICF1''' ('''I'''nput '''C'''apture '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn ein Capture-Ereignis aufgetreten ist, welches anzeigt, dass der Wert des Datenregisters des Timer/Counter 1 in das Input Capture Register ICR1 übertragen wurde.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''TOV0''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''0''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 0 ein Überlauf des Datenregisters stattfindet.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.
|}

 

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sog. ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comperators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrups den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

* '''set_sleep_mode(uint8_t mode)'''
:Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z.B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
* '''sleep_mode()'''
:Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus.

<pre class="code">
#include <avr/io.h>
#include <avr/sleep.h>
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach auftreten eines entsprechenden "Aufwach-Interrupts" verarbeitet
...
</pre>

Vorsicht: Nicht alle AVR-Controller (v.a. nicht die "Brandneuen") werden von den avr-libc sleep-Funktionen richtig angesteuert. Bei nicht-untersützten Typen erreicht man die gewollte Funktionalität durch direkte "Bitmanipulation" der ensprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler:

<pre class="code">
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep");
...
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes

= Der Watchdog =

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der Watchdog.

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln.

Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

Betrachten wir doch einmal folgende Codesequenz:

<pre class="code">
uint8_t x;

x = 10;

while (x >= 0) {
// tu was

x--;
}
</pre>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm würde sich also hier aufhängen und auf ewig in der Schleife drehen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde beginnt der Counter von 0 an hochzuzählen. Wenn nun die je nach Vorteiler eingestellte Anzahl Zyklen erreicht wurde, löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern müssen wir den Watchdog regelmässig wieder neu starten bzw. Rücksetzen (Watchdog Reset). Dies sollte innerehalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern muss ein spezielles Prozedere verwendet werden, um den WD auszuschalten und zwar müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden. Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| border="1"
|-
| '''WDTCR'''
| '''W'''atchog '''T'''imer  '''C'''ontrol '''R'''egister

In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''WDTOE'''
| align="center" | '''WDE'''
| align="center" | '''WDP2'''
| align="center" | '''WDP1'''
| align="center" | '''WDP0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''WDTOE''' ('''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable)
:Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
:Wenn das Bit einmal gesetzt ist wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.

'''WDE''' ('''W'''atch'''d'''og '''E'''nable)
:Wenn dieses Bit gesetzt wird, so wird der Watchdog aktiviert.
:Das Bit kann nur gelöscht werden, solange das Bit '''WDTOE''' auf 1 steht.

'''WDP2''', '''WDP1''', '''WDP0''' ('''W'''atch'''d'''og Timer '''P'''rescaler Bits)
:Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:
<dl><dd>
{| border="1"
|-
| align="center" | WDP2
| align="center" | WDP1
| align="center" | WDP0
| align="center" | Anzahl Zyklen
| align="center" | Typ. Timeoutzeit bei Vcc = 3V
| align="center" | Typ. Timeoutzeit bei Vcc = 5V
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 16K
| align="center" | 47ms
| align="center" | 15ms
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 32K
| align="center" | 94ms
| align="center" | 30ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 64K
| align="center" | 0.19s
| align="center" | 60ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 128K
| align="center" | 0.38s
| align="center" | 0.12s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 256K
| align="center" | 0.75s
| align="center" | 0.24s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 512K
| align="center" | 1.5s
| align="center" | 0.49s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 1024K
| align="center" | 3s
| align="center" | 0.97s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 2048K
| align="center" | 6s
| align="center" | 1.9s
|}
</dd></dl>
|}

Um den Watchdog mit dem AVR-GCC Compiler zu verwenden, muss die Headerdatei wdt.h in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

* '''wdt_enable(uint8_t timeout)'''
:Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert (z.B. WDTO_30MS).
* '''wdt_disable()'''
:Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
* '''wdt_reset()'''
:Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Ein paar grundsätzliche Gedanken ==

Ob nun so ein Watchdog überhaupt verwendet werden soll, ist wohl eher eine
philosophische Frage und hängt vom Geschmack jedes einzelnen Entwicklers ab.

Ich persönlich habe es lieber, wenn ich auch merke, dass in meine Programm
etwas noch nicht in Ordnung ist, als dass mir ein Watchdog einfach die CPU immer
wieder zurücksetzt, denn immerhin kann es so passieren, dass ein Programm über
Jahre hinweg so einigermassen läuft, obwohl noch ein voll krasser Bock drin
liegt.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Watchdog timer handling

= Programmieren mit Interrupts =

Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

[[Image:Interrupt Programme.gif]]

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

== Anforderungen an die Interrupt-Routine ==

Um unliebsamen Überraschungen vorzubeugen sollten einige Grundregeln bei
der Gestaltung der Interruptroutinen beachtet werden.

* Die Interruptroutine soll möglichst kurz und schnell abarbeitbar sein, daraus folgt:
* Keine unfangreichen Berechnungen innerhalb der Interruptroutine.
* Keine endlos langen Programmschleifen.
* Obschon es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen rate ich dringend von solchen Spielen ab.

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf dem AVR auslösen, wobei
die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

== Register ==

Der AT90S2313 verfügt über 2 Register welche mit den
Interrupts zusammen hängen.

{| border="1"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INT1'''
| align="center" | '''INT0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INT1''' (External '''Int'''errupt Request '''1''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

'''INT0''' (External '''Int'''errupt Request '''0''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INTF1'''
| align="center" | '''INTF0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INTF1''' (External '''Int'''errupt Flag '''1''')
:Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.

'''INTF0''' (External '''Int'''errupt Flag '''0''')
:Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister.

Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''SE'''
| align="center" | '''SM'''
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''SE''' ('''S'''leep '''E'''nable)
:Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl in den Schlafzustand versetzen zu können.
:Um den Schlafmodus nicht irrtümlich einzuschalten, wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.

'''SM''' ('''S'''leep '''M'''ode)
:Dieses Bit bestimmt der Schlafmodus.
:Ist das Bit gelöscht, so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt, so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")

'''ISC11''', '''ISC10''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.
<dl><dd>
{| border="1"
|-
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}
</dd></dl>
'''ISC01''', '''ISC00''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

<dl><dd>
{| border="1"
|-
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}
</dd></dl>
|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft, wird automatisch das '''Global
Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle
weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem
Zeitpunkt bereits wieder das GIE-bit zu setzen, rate ich dringend davon ab. Dieses
wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn
in der Zwischenzeit weitere Interrupts eintreffen, werden die zugehörigen
Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden
Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt
ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle
anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe,
weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.

=== Das Status-Register ===

Es gilt auch zu beachten, dass das Status-Register während der Abarbeitung
einer Interruptroutine nicht automatisch gesichert wird. Falls notwendig, muss dies vom
Programmierer selber vorgesehen werden.

== Interrupts mit dem AVR GCC Compiler (WinAVR) ==

Selbstverständlich können alle Interruptspezifischen Registerzugriffe wie gewohnt über I/O-Adressierung vorgenommen werden. Etwas einfacher geht es jedoch, wenn wir die vom Compiler zur Verfügung gestellten Mittel einsetzen.

Damit diese Mittel zur Verfügung stehen, müssen wir die Includedatei ''interrupt.h'' und evtl. ''signal.h'' einbinden mittels:

<pre class="code">
// fuer sei(), cli() und INTERRUPT():
#include <avr/interrupt.h>

// fuer SIGNAL() auch:
#include <avr/signal.h>
</pre>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird
nichts anderes gemacht, als das '''Global Interrupt Enable''' Bit im Status
Register gesetzt.

<pre class="code">
sei();
</pre>

Das Makro '''cli()''' schaltet die Interrupts aus, oder anders
gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird
gelöscht.
<pre class="code">
cli();
</pre>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf.
Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen.
Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren
und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen
Zustands die Interrups aktivieren, was zu unerwünschten Seiteneffekten führen kann.
Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern */

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD); // 2 mal in Folge , vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
...

}
</pre>



Nachdem nun die Interrupts aktiviert sind, braucht es selbstverständlich noch den auszuführenden Code, der ablaufen soll, wenn ein Interrupt eintrifft. Dazu gibt es zwei Definitionen: '''SIGNAL''' und '''INTERRUPT''', welche allerdings AVR-GCC spezifisch sind und bei anderen Compilern womöglich anders heissen können.

=== SIGNAL ===

<pre class="code">
#include <avr/signal.h>
...
SIGNAL (siglabel)
{
/* Interrupt Code */
}
</pre>

Mit ''SIGNAL'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektoren angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Vor Nutzung von SIGNAL muss die Header-Datei signal.h eingebunden werden. Mögliche Funktionsrümpfe für solche Interruptfunktionen sind zum Beispiel:

<pre class="code">
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

SIGNAL (SIG_OVERFLOW1)
{
/* Interrupt Code */
}

SIGNAL (SIG_UART_RECV)
{
/* Interrupt Code */
}

// und so weiter und so fort...
</pre>

Während der Ausführung des Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten, so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== INTERRUPT ===

<pre class="code">
#include <avr/interrupt.h>
...
INTERRUPT (signame)
{
/* Interrupt Code */
}
</pre>

Mit INTERRUPT wird genau gleich gearbeitet wie mit SIGNAL. Der Unterschied ist derjenige, dass bei INTERRUPT beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit automatisch wieder gesetzt und somit weitere Interrupts zugelassen werden. Dies kann zu nicht unerheblichen Problemen von im einfachsten Fall einem Stack overflow bis zu sonstigen unerwarteten Effekten führen und sollte wirklich '''nur dann''' angewendet werden, wenn man sich absolut sicher ist, das Ganze auch im Griff zu haben. Vor Nutzung von INTERRUPT muss die Header-Datei interrupt.h eingebunden werden.

Interruptroutinen (ISRs) sollten möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern des Zustands aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen, s.u.). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

siehe auch: Hinweise in [[AVR-GCC]]

== Datenaustausch mit Interrupt-Routinen ==

Variablen auf die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen wird und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte die Code-Optimierung "greifen" und der Wert der Variablen nur in Prozessorregistern zwischenspeichert werden, die "nichts von der Änderung woanders mitbekommen".

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z.B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt z.B. alle 10ms
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
// hier wird gKeyCounter veraendert, die uebrigen
// Programmteile muessen diese Aenderung "sehen"
// (volatile -> aktuellen Wert immer in den Speicher schreiben)
if ( !(KEY_PIN & (1<<KEY_PINNO)) )
if (gKeyCouter < CNTREPEAT) gKeyCounter++;
else gKeyCounter = 0;
}

...

int main(void)
{
...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
...
// hier wird auf gKeyCounter zugegriffen, dazu muss der in der
// ISR geschrieben Wert bekannt sein.
// (volatile -> aktuellen Wert immer aus dem Speicher lesen)
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt"
}
else {
/* hier: Code fuer "Taste kurz gedrueckt"
}
...
}
</pre>

Bei Variablen größer ein Byte muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes ausserhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<pre class="code">
...
volatile uint16_t gMyCounter16bit
...
SIGNAL(...)
{
...
gMyCounter16Bit++;
...
}

int main(void)
{
uint16_t tmpCnt;
...
// nicht gut: mglw. hier ein Fehler wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor Kopieren des zweiten Bytes
// ein Interrupt auftritt der den Inhalt von MyCounter veraendert
tmpCnt = gMyCounter16bit;

// besser: Aenderungen "ausserhalb" verhindern, alle "Teilbytes"
// bleiben konsistent
cli(); // Interupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren
...
}
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8 (Stand: avr-libc Vers. 1.0.4)

== Was macht das Hauptprogramm ==

Im einfachsten Fall gar nichts mehr.

Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der
main-Funktion lediglich noch die Interrupts aktiviert und dann in eine
Endlosschleife folgender Art verzweigt:

<pre class="code">
...
for (;;) {}
...
</pre>

Normalerweise wird man allerdings in den Interruptroutinen die Interrupts
erfassen und im Hauptprogramm dann gemütlich auswerten.

Wie wir im bisherigen Kursverlauf gesehen haben ist es ohnehin mit so
schnellen Controller meistens gar nicht unbedingt notwendig mit
Interruptfunktionen zu arbeiten. 
Es ist allerdings auch zu bemerken, dass mit den Interruptroutinen ein Programm
sehr schön strukturiert werden kann, wenn man es richtig macht.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (eigentlich [[SRAM]]) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als [[FLASH]]-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z.B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin wenig Sinn macht und auch nur bei einigen RAM-losen Typen nach "Bastelarbeiten" möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory). Die Standard-Laufzeitbibliothek des avr-gcc, die [[avr-libc]], stellt diese Funktionen nach einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Einige Beispiele:

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray1 };
...
</pre>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<pre class="code">
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte...
}
</pre>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel, jedoch mit der Funktion pgm_read_word.

<pre class="code">
uint16_t myWord;

myWord = pgm_read_word(&pgmFooWord);
</pre>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "gross". (Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.) Pointer müssen gegebenenfalls "gecastet" werden.

<pre class="code">
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray1

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray2
// da im zweiteb Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmPointerToArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</pre>

=== Floats und Structs lesen ===

Um komplexe Datentypen (structs), nicht-integer Datentypen (floats) aus dem Flash auszulesen, sind Hilfsfunktionen erforderlich. Einige Beispiele:

<pre class="code">

/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
...

/* liest float von Flash-Addresse addr und gibt diese als return-value zurueck */
inline float pgm_read_float(const float *addr)
{
union
{
uint16_t i[2]; // 2 16-bit-Worte
float f;
} u;

u.i[0]=pgm_read_word((PGM_P)addr);
u.i[1]=pgm_read_word((PGM_P)addr+2);

return u.f;
}
...

void egal(void)
{
int i;
float f;

for (i=0;i<3;i++) {
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach' was mit f
}
}
</pre>

TODO: Beispiele fuer structs und pointer aus flash auf struct im flash (menues, state-machines etc.)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuerht, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
...
</pre>

Aber Achtung: Ersetzt man zum Beispiel
<pre class="code">
const char textImFlash[] PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
durch
<pre class="code">
const char textImFlash* PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der textImFlash zu den Konstanten ans Ende des Programmcodes gelegt wird, von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte. Da der lesende Code trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein Bug des AVR-GCC (gesehen bei 3.4.1) zu sein.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<pre class="code">
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
...
</pre>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z.B. 0x01fe), "weiss" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, dass der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000), wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z.B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmässig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, das vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgeben sind ("timed sequence"). Diese Prüfung wird nicht implizit durchgeführt. Im Zweifel kann man Sicherheitshalber bei EEPROM-Zugriffen die Interrupts global deaktivieren, z.B. so:

<pre class="code">
...
uint8_t sreg;
...

sreg = SREG;
cli();

/* hier die eeprom-Zugriffe */

SREG = sreg;
...
</pre>

Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Die Nutzung einer [[C-Präprozessor]]-Ersetzung bringt etwas Bequemlichkeit. Siehe dazu folgendes Beispiel.

<pre class="code">
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h>

// alle Textstellen EEPROM im Quellcode durch __attribute__ ... ersetzen
#define EEPROM __attribute__ ((section (".eeprom")))

...

/* Byte */
uint8_t eeFooByte EEPROM = 123;

/* Wort */
uint16_t eeFooWort EEPROM = 12345;

/* float */
float eeFooFloat EEPROM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEPROM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEPROM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */

uint16_t eeFooWordArray1[4] EEPROM;
...
</pre>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heisst eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<pre class="code">
...
uint8_t myByte;
uint8_t sreg;

sreg = SREG; // (1)
cli(); // (1)

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
...
SREG = sreg; // (1)
</pre>

Die mit (1) markierten Zeilen dienen hierbei dem (möglicherweise übertriebenen) Schutz vor Unterbrechnungen durch Interrupts.

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<pre class="code">
...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
...
</pre>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprueft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und mglw. noch mehr.

<pre class="code">
...
unit8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes aber der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnuetze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray[0],3);

/* dito mit etwas Absicherung betr. der Laenge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));

/* Datenlock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));
...
</pre>

"Nicht-Integer"-Datentypen wie z.B. Fliesskommazahlen lassen sich recht praktisch ueber eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<pre class="code">
...
float myFloat = 12.34;

union {
float r;
uint8_t n[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */
...
</pre>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<pre class="code">
...
typedef struct {
uint8_t label[8];
unin8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEPROM;

...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
...
}
...
</pre>

=== EEPROM-Speicherabbild in .eep-Datei ===

Eine besondere Funktion des avr-gcc ist, dass mit einem entsprechenden makefile aus den Initialisierungswerten der Variablen im Quellcode eine Datei erzeugt werden kann, die man auf den Controller programmieren kann (.eep-Datei). Damit können sehr elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Die Vorgehensweise wird aus dem WinAVR-Beispielmakefile ersichtlich. Siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles.

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Nicht alle neuen AVR Controller werden von avr-libc/eeprom.h untersützt (Stand Version 1.0.4). Insbesondere beim ATMega169 funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register) Etwas ältere Typen, oder zu den "etablierten" Controllern kompatible, bereiten jedoch hier keine Proleme. Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Der dort gezeigt Code kann direkt auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste").

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gcc-Toolchain" bietet dazu zwei Möglichkeiten:

;Inline-Assembler:
Die Assembleranweisungen werden in direkt in den C-Code integriert. Eine Quellcode-Datei enhält somit C- und Assembleranweisungen

;Assembler-Dateien:
Der Assembler-Codecode befindet sich in eigenen Quellcodedateien. Dieser werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z.B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben.

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen einer NOP-Anweisung. NOP steht für '''NO'''-O'''P'''eration. Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=warte)-Funktionen.

<pre class="code">
...
/* Verzoegern der weiteren Programmausfuehrung um
genau 3 Taktzyklen */
asm volatile ("nop"::);
asm volatile ("nop"::);
asm volatile ("nop"::);
...
</pre>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeindlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<pre class="code">
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i=0;i<1000;i++);

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i=0;i<1000;i++) asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j=0;j<1000;j++);
</pre>

Ein weiterer nützliche "Assembler-Einzeiler" ist der Auruf von sleep (''asm volatile ("sleep"::);''), da hierzu keine eigene Funktion in der avr-libc existiert.

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil des die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<pre class="code">
static inline void delayloop16(uint16_t count)
{
asm volatile ( "cp %A0,__zero_reg__ \n\t" \
"cpc %B0,__zero_reg__ \n\t" \
"breq L_Exit_%= \n\t" \
"L_LOOP_%=: \n\t" \
"sbiw %0,1 \n\t" \
"brne L_LOOP_%= \n\t" \
"L_Exit_%=: \n\t" \
: "=w" (count)
: "0" (count)
);
}
</pre>

* Jede Zeile wird mit '''\n\t''' abgeschlossen, alle Zeilen mit '''\''' verbunden.
* Sprung-Marken (labels) werden mit einm Prozentzeichen abgeschlossen, der Präprozessor (Assembler?) setzt an dieser Stelle eine laufende Nummer ein, die Doppelbezeichnungen bei mehrmaliger Verwendung somit verhindert.

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc.

* siehe auch: Dokumentation der avr-libc/Related Pages/Inline Asm
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

...TODO: Beispiele, Parameteruebergabe, globale Variablen für Datenaustausch

= TODO =

stdio.h, malloc() ???, Code-Optimierungen ("tricks"), "naked"-Functionen ??, IO-Register als Parameter/"Variablen" (volatile uint8_t *mybusport; mybusport=&PORTB; void sendbus(uint8_t *parm)...)

= C-Code und Bibliotheken für externe Baugrupen =
(TODO: sollte in avr-gcc verschoben werden)
[[Linksammlung#Avr]]

==LCD==
=== Text (character-mode) HD44870 ===
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray

=== Grafik-LCD ===
==== Nokia3310 ====
==== Nokia 6100 LCD ====
Das Nokia ist ein 132x132x4096 Farben Display das bei eBay ziemlich preiswert ersteigert werden kann.
[http://www.apetech.de/nokia6100.php Nokia 6100 LCD Library]
==== KS0108 ====
* Procyon avrlib (GPL)
* avrfreaks UP
* apetech.de
==Schnittstellen==
===I2C===
====Master====
[http://jump.to/fleury/ P. Fleurys I2C Master library]
====Slave====

===CAN===
* [http://www.atmel.com] Codesammlung zum AT90CAN128

=== DS18S20/1-Wire ===
* avrfreaks Projekt 59
* mikrocontroller.net/codesammlung (P. Dannegger)

=== UART ===
* Procyon avrlib (GPL)
* avrfreaks UP (viele viele)
* P. Fleury

== Speicherkarten/IDE/FAT ==
* avrfreaks UP (IDE/FAT read write)
== CRC ==
* avrfreaks-forum (O'Flynn)
* avr-hal (GPL)

Diskussion:AVR-GCC-Tutorial

2004-11-15T01:21:01Z

Oxygene:

Warum hier im Codebsp. die Frequenz gesetzt wenn man im Einfache Wandlung (Single Conversion)-modus ist?

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteile setzen auf 8 (1)

Weil man immer den Vorteiler entsprechend der Quarzfrequenz setzen muß um den ADC nicht mit einem zu hohen Takt zu versorgen. --[[Benutzer:Matthias|Matthias]] 19:58, 21. Sep 2004 (CEST)

Ich benutze folgenden code der funktioniert. Es wird kein vorteiler gesetzt!!

sbi(ADCSR,ADEN); //ADC An
sbi(ADMUX,MUX0); //kanal wählen
for (;;) { /* loop forever */
sbi(ADCSR,ADSC); //wandlung starten
while(bit_is_set(ADCSR,ADSC)); //warten bis wandlung fertig
num = ADCW;

--- schnipp ---

Der Vorteiler hat nichts mit "funktionieren" oder "nicht funktionieren" zu tun. Man sollte sich eher Gedanken um die Genauigkeit und einzuhaltende Maximalfrequenzen bei der Wandlung machen. Der Abschnitt "ADC/Prescaling and Conversion Time" im Datenblatt gibt eigentlich erschoepfend Auskunft darueber. Das "sbi" in dem Beispielcode oben in einem Diskussionsbeitrag zum gcc-tutorial noch auftaucht ist mir schleierhaft, da kann ich mir die Aktualisierung auch sparen. Falls das im Artikel gezeigte Beispiel nachweislich falsch sein sollte: bitte aendern.
MfG M. Thomas

Butterfly schoen und gut, aber diese beiden Hinweise in letzter Zeit mit der Preisangabe "30Eur"... Ist das irgendwo ein Lager "zu voll" und wird hier versucht "etwas Werbung" zu machen? Der Preis ist "normal" aber wenn man sich umschaut und/oder sich mit ein paar Leuten für eine Sammelbestellung zusammentut gibt es die Teile deutlich guenstiger.

-----
Einige der Links im Kapitel 11.1.1 (Messen eines Widerstandes) funktionieren nicht. Dies wären:
* http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c
* http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h
* http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile

--[[Benutzer:Oxygene|Oxygene]] 12:05, 12. Nov 2004 (CET)

-----
Habe die Tabellen übersichtlicher gemacht, überflüssige Tabellen durch gewöhnliche Einrückungen ersetzt und recht viele Kommafehler bei Konditionalsätzen berichtigt (so um die 762 *g*). Inhaltlich ist alles gleich geblieben.
--[[Benutzer:Oxygene|Oxygene]] 15:01, 12. Nov 2004 (CET)

-----
Danke fuer die Korrekturen, einige der Fehler sind sicher "auf meinem Mist gewachsen". Die Links zu "Messen eines Widerstands" sollten ganz raus, entweder ein aktualisiertes Beispiel direkt im Text oder in einem anderen Wiki-Artikel oder ersatzlos streichen. Schlussendlich ist es ein avr-gcc Tutorial die Beispiele sollten avr-gcc-Spezifisches erläutern und den manchmal etwas "trockenen" Text auflockern. Wie man einzelne Komponenten des AVR ansteuert hat nur in seltenen Fällen mit der Impementierungssprache zu tun. Hier vor allem dann, wenn die avr-libc entsprechende "APIs" zur Verfügung stellt. Alles Andere gehört eigentlich in ein "sprachunabhängiges" AVR-Tutorial. Das avr-gcc Tutorial "schleppt" mein Meinung in dieser Hinsicht noch einige Altlasten mit. [[Benutzer:mthomas]]

Also ich habe das Tut durchgearbeitet und alle mir auffallenden Fehler korrigiert. Man hat da sofort bemerkt, von wo an die Texte von dir geschrieben wurden, da die Kommafehler schlagartig aufhörten ;)
Da sind auch ein paar Formulierungen, die ich persönlich nicht so passend finde ("voll krass"), die wollte ich aber nicht ändern, da das hier eher dein Baby ist, es sei denn, du hast nichts dagegen, dass man da etwas rumbastelt. Will dir hier nicht dazwischenpfuschen und deine Pläne durcheinander bringen.
--[[Benutzer:Oxygene|Oxygene]] 02:21, 15. Nov 2004 (CET)

Hauptseite

2004-11-14T11:18:41Z

Oxygene: werbung gelöscht

{| width="100%"
|-
|style="vertical-align:top" |
<div style="margin: 0; margin-right:10px; border: 1px solid #dfdfdf; padding: 0 1em 1em 1em; background-color:#F8F8FF; align:right;">
== Willkommen beim Mikrocontroller-Wiki ==
Ein Wiki ist eine Informationssammlung, an der jeder mitwirken kann - sogar ohne Anmeldung. Es soll kein Lexikon sein, sondern eher eine Sammlung von informativen Artikeln rund um das Thema Mikrocontroller & Elektronik. Wer eigene Projekte, Anleitungen oder Tipps & Tricks veröffentlichen möchte ist hier genau richtig.

Im Moment existieren {{NUMBEROFARTICLES}} Seiten.
</div>
<div style="margin: 0; margin-top:10px; margin-right:10px; border: 1px solid #dfdfdf; padding: 0em 1em 1em 1em; background-color:#FFfFeF; align:right;">

== Wo geht's los? ==

Ein guter Einstieg ist die [[Mikrocontroller]]-Seite. Wer nicht weiß, nach welchen Kriterien er einen Mikrocontroller auswählen soll, der findet in [[Entscheidung Mikrocontroller]] einige Hinweise. Verschiedene Programmiersprachen werden [[HLL|hier]] verglichen.

Es gibt Erklärungen wie man [[SMD Löten|SMD lötet]] und was die Bezeichnungen auf den [[SMD]]-Bauteilen bedeuten.

An einen Mikrocontroller kann man natürlich vieles anschließen: Man kann ihn per [[USB]] mit dem PC verbinden, man kann ihn an den [[TV-out|Fernseher]] anschließen oder einfach nur einen der zahlreichen [[Temperatursensor]]en benutzen.

Überwältigt von den vielen Abkürzungen und Fachbegriffen? Hier wird natürlich unter anderem auch erklärt, was [[USART]], [[Brownout]], [[I2C|I²C]], [[SPI]], [[JTAG]] und [[CRC]] bedeuten.

Für diverse Dinge rund um den AVR, beginnend bei einem Tutorial, gibt es eine [[AVR-Linkseite]].

Eine Liste interessanter Links zu Web-Seiten für diverse Controller-Architekturen findet sich in der [[Linksammlung]].

Zur Bauteilbeschaffung sind auf der Seite [[Elektronik-Versender]] einige Links zu Anbietern zusammengestellt.

Noch nicht genug? Eine alphabetische Liste mit allen Themen liefert die [http://www.mikrocontroller.net/wikisoftware/index.php?title=Spezial:Allpages&from=0 Artikelübersicht].

</div>

| width="40%" style="vertical-align:top" |
<div style="margin:0; border:1px solid #dfdfdf; padding: 0em 1em 1em 1em; background-color:#efefef; align:left;">

=== Kann ich wirklich "einfach so" irgendetwas an den Seiten ändern? ===

Ja. Um eine Seite zu ändern reicht ein Klick auf den "Seite bearbeiten" Link.
Aber: Bitte lies Dir vorher die [[Uc-wiki:Wie man eine Seite bearbeitet|Bearbeitungshinweise]] durch und schau Dir am besten mal ein paar der anderen Seiten an, um zu sehen wie das Ganze funktioniert.

=== Super, dann kann ich ja gleich mein altes Elektroniklexikon hier reintippen! ===

NEIN! Bitte verwende nur Texte an denen du selber die Rechte hast.

=== Gibt es einen Testbereich, wo man das Ganze mal ausprobieren kann? ===

Ja, dafür gibt es die [[Testseite]].

=== Wie kann ich neue Seiten erstellen? ===

Gib einfach den gewünschten Titel in die Suche ein und klicke auf "Los", falls die Seite noch nicht existiert findest du dann dort einen Link zum Anlegen der Seite. Bitte schau dir erst den Aufbau von ein paar exisiterenden Seiten an (auf "Seite bearbeiten" klicken, dann wird der Quelltext angezeit), um herauszufinden wie das mit den Überschriften und Formatierungen funktioniert.
Mehr Informationen zu den Formatierungsmöglichkeiten gibt es [[Uc-wiki:Wie man eine Seite bearbeitet|hier]].

=== Wozu ist der "Diskussion"-Link? ===

Auf den Diskussionsseiten kann man Kommentare, Kritik oder Fragen zum jeweiligen Artikel unterbringen.
</div>
|}
__NOTOC__

Spannungsreferenz

2004-11-13T19:26:02Z

Oxygene: spielkind

Eine Spannungsreferenz ist eine Schaltung oder ein Bauelement, das eine [[Spannung]] definierter Höhe bereitstellt.

Sehr viele elektronische Schaltungen arbeiten nur "relativ", das heißt zum Beispiel
* ein Netzteil, das eine stabilisierte Betriebsspannung für einen [[Mikrocontroller]] liefern soll, hält diese tatsächlich nur in Relation zu einem Vergleichswert konstant
* ein [[ADC|Analog-Digital-Converter]], der einen analogen Spannungswert messen soll, ermittelt den digitalen Wert tatsächlich nur im Relation zu einer Bezugsgröße

Als Vergleichs- und Bezugsgrößen eignet sich in einfachen Fällen
* eine (oder mehrere) in Durchlassrichtung geschaltete [[Diode]](n)
* eine [[Z-Diode]].
Durch Herstellungstoleranzen und Temperatureinflüsse ist die Genaugkeit hier allerdings recht beschränkt.

Für höhere Ansprüche gibt es spezielle Bauteile in Form [[IC|integrierter Schaltungen]] (z.B. LM336, LM385). Herstellungstoleranzen werden dabei durch einen genauen Abgleich bei (bzw. nach) der Produktion noch im Hause des Herstellers ausgeglichen. Dem Temperaturdrift wirken geeignete Schaltungsmaßnahmen entgegen (oder solche Bauteile heizen sich selbst auf eine bestimmte Temperatur auf, die sie dann konstant halten).

Diskussion:AVR-GCC-Tutorial

2004-11-12T14:01:34Z

Oxygene:

AVR-GCC-Tutorial

2004-11-12T13:49:19Z

Oxygene: /* Assembler und Inline-Assembler */

[[Category:AVR]]

= Vorwort =

Dieses Tutorial soll Einsteigern helfen, mit der Programmiersprache '''C''' die Mikrocontroller der Atmel AVR-Reihe zu programmieren.


Die ursprüngliche Version stammt von Christian Schifferle, die meisten aktuellen Anpassungen von [[Benutzer:Mthomas]]. Viele der im Original-Dokument verwendeten Funktionen sind in
aktuellen Versionen des avr-gcc C-Compilers und der avr-libc zwar noch enthalten,
aber als überholt (''deprecated'') ausgewiesen. D.h. diese Funktionen sollten nicht mehr verwendet
werden und existieren in zukünftigen Versionen des Compilers/der Library nicht mehr
(z.B. sbi(), cbi(), outp(), inp()). Der Artikel wurde auf die neuen Funktionen/Methoden
angepasst.

In diesem Text wird häufig auf die Standardbibliothek für den avr-gcc-Compiler, die avr-libc, verwiesen. Die '''Dokumentation der avr-libc''' findet sich
[http://www.nongnu.org/avr-libc/user-manual/index.html hier]. Bei WinAVR gehört diese Dokumentation zum Lieferumfang und wird mitinstalliert.

= Benötigte Werkzeuge =

Um die Übungen in diesem Tutorial nachvollziehen zu können benötigen wir folgende Hard- und Software:

* Testboard für die Aufnahme eines AVR Controllers, der vom gcc Compiler untersützt wird (alle ATmegas und die meisten AT90). Dieses Testboard kann durchaus auch selber zusammen gelötet werden. So arbeite ich mit einem Testboard, welches ich mir auf einer Veroboard-Platine zusammen gestellt habe. Für die Versuche bzw. Übungen in diesem Tutorial habe ich jeweils einen AT90S2313 verwendet. Eine brauchbare Testplattform ist auch der [[AVR Butterfly]].
* AVRGCC-Compiler. Kostenlos erhältlich für nahezu alle Plattformen/Betriebssysteme. Für MS-Windows im Packet [[WinAVR]]; für Unix/Linx siehe auch Hinweise im Artikel [[AVR-GCC]].
* Programmiersoftware und Hardware z.B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], [[AVR-Studio]]).
* Nicht unbedingt erforderlich aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Abschnitt Exkurs: makefiles).

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.
* Die [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently Asked Questions = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.
* Das gcc-Forum auf [http://www.mikrocontroller.net www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.
* Das avr-gcc-Forum bei [http://www.avrfreaks.net avrfreaks] nach vergleichbaren Problemen absuchen.
* Das [http://www.avr1.org/pipermail/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.
* Nach Beispielcode suchen. Vor allem in der Academy von [http://www.avrfreaks.net AVRFREAKS] (anmelden).
* Google oder alltheweb befragen schadet nie.
* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal)
* einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei mgl. viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode, genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z.B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: [http://www.lugbz.org/documents/smart-questions_de.html "Wie man Fragen stellt"].

= Exkurs: makefiles =

Wenn man bisher gewohnt ist, mit integrierten Entwicklungsumgebung à la Visual-C Programme zu erstellen, wirkt das makefile-Konzept auf den ersten Blick etwas kryptisch. Nach kurzer Einarbeitung ist diese Vorgehensweise jedoch sehr praktisch. Diese Dateien (üblicher Name: 'Makefile' ohne Dateiendung) dienen der Ablaufsteuerung des Programms make, das auf allen Unix/Linux-Systemen installiert sein sollte, und in einer Fassung fuer MS-Windows auch in [[WinAVR]] (Unterverzeichnis utils/bin) enthalten ist.

Im Unterverzeichnis ''sample'' einer WinAVR-Installation findet man eine sehr brauchbare Vorlage, die sich einfach an das eigene Projekt anpassen lässt ([[Media:Makefile|lokale Kopie Stand Sept. 2004]]). Wahlweise kann man auch [http://www.sax.de/~joerg/mfile/ mfile] von Jörg Wunsch nutzen. mfile erzeugt ein makefile nach Einstellungen in einer grafischen Nutzeroberfläche, wird bei WinAVR mitinstalliert, ist aber als TCL/TK-Programm auf nahezu allen Platformen lauffähig.

''Die folgenden Ausführungen beziehen sich auf das WinAVR Beispiel-Makefile.''

Ist im Makefile alles richtig eingestellt genügt es, sich drei Parameter zu merken, die über die shell bzw. die Windows-Kommandozeile (cmd.exe/command.exe) als Parameter an "make" übergeben werden. Das Programm make sucht sich "automatisch" das makefile im aktuellen Arbeitsverzeichnis und führt die darin definierten Operationen für den entsprechenden Aufrufparameter durch.

{| border=1
| ''make all''
| Erstellt aus den in im makefile angegebenen Quellcodes eine ''hex''-Datei (und ggf. auch ''eep''-Datei).
|-
| ''make program''
| Überträgt die hex-Datei (und wahlweise auch die eep-Datei für den EEPROM) zum AVR.
|-
| ''make clean''
| löscht alle temporären Dateien, also auch die hex-Datei
|}

Diese Aufrufe können in die allermeisten Editoren in "Tool-Menüs" eingebunden werden. Dies erspart den Kontakt mit der Kommandozeile. (Bei WinAVR sind die Aufrufe bereits im Tools-Menü des mitgelieferten Editors Programmers-Notepad eingefügt.)

Üblicherweise sind folgende Daten im makefile anzupassen:
* Controllertyp
* Quellcode-Dateien (c-Dateien)
* Typ und Anschluss des Programmiergeräts

seltener sind folgende Einstellungen durchzuführen:
* Grad der Optimierung
* Methode zur Erzeugung der Debug-Symbole (Debug-Format)
* Assembler-Quellcode-Dateien (S-Dateien)

Die in den folgenden Unterabschnitten gezeigten makefile-Ausschnitte sind für ein Programm, das auf einem ATmega8 ausgeführt werden soll. Der Quellcode besteht aus den c-Dateien superprog.c (darin main()), uart.c, lcd.c und 1wire.c. Im Quellcodeverzeichnis befinden sich diese Dateien: superprog.c, uart.h, uart.c, lcd.h, lcd.c, 1wire.h, 1wire.c und das makefile (die angepasste Kopie des WinAVR-Beispiels).

Der Controller wird mittels [[AVRDUDE]] über ein [[STK200]]-Programmierdongle an der Schnittstelle lpt1 (bzw. /dev/lp0) programmiert. Im Quellcode sind auch Daten für die ''section .eeprom'' definiert (siehe Abschnitt Speicherzugriffe TODO: nach unten verlinken), diese sollen beim Programmieren gleich mit ins EEPROM geschrieben werden.

== Controllertyp setzen ==

Dazu wird die "make-Variable" MCU entsprechend dem Namen des verwendenten Controllers gesetzt. Ein Liste der von avr-gcc und der avr-libc untersützten Typen findet sich in der [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc].

<pre class="code">
# Kommentare in Makefiles beginnen mit einem Doppelkreuz
...

# ATmega8 at work
MCU = atmega8
# oder MCU = atmega16
# oder MCU = at90s8535
# oder ...
...
</pre>

== Quellcode-Dateien einstellen ==

Den Namen der Quellcodedatei welche die Funktion main enthält, wird hinter TARGET eingetragen. Dies jedoch ohne die Endung ''.c''.

<pre class="code">
...
TARGET = superprog
...
</pre>

Besteht das Projekt wie im Beispiel aus mehr als einer Quellcodedatei, sind die weiteren c-Dateien (nicht die Header-Dateien, vgl. [[Include-Files (C)]]) durch Leerzeichen getrennt bei SRC einzutragen. Die bei TARGET definierte Datei ist schon in der SRC-Liste enthalten. Diesen Eintrag nicht löschen!

<pre class="code">
...
SRC = $(TARGET).c uart.c lcd.c 1wire.c
...
</pre>

Alternativ kann man die Liste der Quellcodedateien auch mit dem Operator += erweitern.

<pre class="code">
SRC = $(TARGET).c uart.c 1wire.c
# lcd-Code fuer Controller xyz123 (auskommentiert)
# SRC += lcd_xyz.c
# lcd-Code fuer "Standard-Controller" (genutzt)
SRC += lcd.c
</pre>

== Programmiergerät einstellen ==

Die Vorlagen sind auf die Programmiersoftware [[AVRDUDE]] angepasst, jedoch lässt sich auch andere Programmiersoftware einbinden, sofern diese über Kommandozeile gesteuert werden kann (z.B. stk500.exe, uisp, sp12).

<pre class="code">
...
# Einstellung fuer STK500 an com1 (auskommentiert)
# AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
# AVRDUDE_PORT = com1 # programmer connected to serial device

# Einstellung fuer STK200-Dongle an lpt1
AVRDUDE_PROGRAMMER = stk200
AVRDUDE_PORT = lpt1
...
</pre>

Sollen Flash(=.hex) und EEPROM(=.eep) zusammen auf den Controller programmiert werden, ist das Kommentarzeichen vor AVRDUDE_WRITE_EEPROM zu löschen.

<pre class="code">
...
#Auskommentiert: EERPOM-Inhalt wird nicht mitgeschrieben
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

#Nich-auskommentiert EERPOM-Inhalt wird mitgeschrieben
AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
...
</pre>

== Anwendung ==

Die Eingabe von ''make all'' im Arbeitsverzeichnis mit dem makefile und den Quellcodedateien erzeugt (unter anderem) die Dateien superprog.hex und superprog.eep. Abhängigkeiten zwischen den einzelnen c-Dateien werden dabei automatisch berücksichtigt. Die ''superprog.hex'' und ''superprog.eep'' werden mit ''make program'' zum Controller übertragen. Mit ''make clean'' werden alle temporären Dateien gelöscht (="aufgeräumt").

== Sonstige Einstellungen ==

=== Optimierungsgrad ===

Der gcc-Compiler kennt verschiedene Stufen der Optimierung. Nur zu Testzwecken sollte die Optimierung ganz deaktiviert werden (''OPT = 0''). Die weiteren möglichen Optionen weisen den Compiler an, möglichst kompakten oder möglichst schnellen Code zu erzeugen. In den weitaus meisten Fällen ist ''OPT = s'' die optimale (sic) Einstellung, damit wird kompakter und oft auch der "schnellste" Maschienencode erzeugt.

=== Debug-Format ===

Unterstützt werden die Formate stabs und dwarf-2. Das Format wir hinter ''DEBUG ='' eingestellt. Siehe dazu Abschnitt ''Eingabedateien zur Simulation''.

=== Assembler-Dateien ===

Die im Projekt genutzten Assembler-Dateien werden hinter ASRC durch Leerzeichen getrennt aufgelistet. Assembler-Dateien haben immer die Endung .S (grosses S). Ist zum Beispiel der Assembler-Quellcode eines Software-UARTs in einer Datei softuart.S enthalten lautet die Zeile: ''ASRC = softuart.S''

== Eingabedateien zur Simulation in AVR-Studio ==

Mit älteren AVR-Studio-Versionen kann man nur auf Grundlage sogenannter ''coff''-Dateien simulieren. Neuere Versionen von AVR-Studio (ab 4.10.356) unterstützen zudem das modernere aber noch experimentelle dwarf-2-Format, das ab WinAVR 20040722 (avr-gcc 3.4.1/Binutils inkl. Atmel add-ons) "direkt" vom Compiler erzeugt wird.

; Vorgehensweise bei extcoff:
* im Makefile bei DEBUG: <pre class="code">DEBUG=stabs</pre>
* ''make extcoff'' (evtl. vorher ''make clean'')
* die erzeugte ''cof''-Datei (im Beispiel oben ''superprog.cof'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

; Vorgehensweise bei dwarf-2:
* im Makefile bei DEBUG: <pre class="code">DEBUG=dwarf-2</pre>
* ''make all'' (evtl. vorher ''make clean'')
* die erzeugte ''elf''-Datei (im Beispiel oben ''superprog.elf'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

Beim Simulieren scheinen oft "Variablen zu fehlen". Ursache dafür ist, dass der Compiler die "Variablen" direkt Registern zuweist. Dies kann vermieden werden, indem die Optimierung abgeschaltet wird (im makefile). Man simuliert dann jedoch ein vom optimierten Code stark abweichendes Programm. Das Abschalten der Optimierung wird nicht empfohlen.

Statt des Software-Simulators kann das AVR-Studio auch genutzt werden, um mit dem ATMEL JTAGICE, ein Nachbau davon (BootICE, Evertool o.ä.) oder dem ATMEL JTAGICE MKII "im System" zu debuggen. Dazu sind keine speziellen Einstellungen im makefile erforderlich. Debugging bzw. "In-System-Emulation" mit dem JTAGICE und JTAGICE MKII sind in der AVR-Studio Online-Hilfe beschrieben.

= Definition einiger Datentypen =

Für die Programmierung von Mikrocontrollern ist es sinnvoll, dass wir uns
vorerst einige Datentypen definieren, welche den Zugriff auf die verschiedenen
Komponenten des Controllers vereinfachen oder wenigstens das Programm lesbarer
machen können.

<pre class="code">
typedef unsigned char BYTE;
typedef unsigned short WORD;
</pre>

== BYTE ==

Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 255.

== WORD ==

Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 65535.

== DWORD ==

Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

== QWORD ==

Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

Bei allen vorgenannten Datentypen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z.B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich daher, die im folgenden Abschnitt beschriebenen standardisierten Datentypen zu nutzen und damit "Missverständnissen" vorzubeugen, die z.B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

= Standardisierte Integer(Ganzzahl)-Typen =

Standardisierte Datentypen werden in der Header-Datei inttypes.h definiert.
Will man diese Typen benutzen, bindet man die "Definitionsdatei" wie folgt ein:

<pre class="code">
#include <inttypes.h>
</pre>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<pre class="code">
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
</pre>

Ein Vierfach-Wort (64Bit) entspricht beim AVR ''uint64_t'', ein Doppel-[[Word|Wort]] (32bit) entspricht ''uint32_t'', ein Wort (16bit) entspricht ''uint16_t'' und ein [[Byte]] (8bit) entspricht ''uint8_t''.
Die Typen ohne vorangestelltes ''u'' können auch vorzeichenbehaftete Zahlen speichern. ''int8_t'' geht also von -128 bis 127, ''uint8_t'' dagegen geht von 0 bis 255.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Integer Types

== '''Bitfelder''' ==

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bit breit ist. 
Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in einer einzelnen Bytevariable zusammen fassen und (fast) wie
8 einzelne Variablen ansprechen können. 
Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente
definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<pre class="code">
struct {
unsigned char bStatus_1:1; // 1 Bit für bStatus_1
unsigned char bStatus_2:1; // 1 Bit für bStatus_2
unsigned char bNochNBit:1; // Und hier noch mal ein Bit
unsigned char b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</pre>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<pre class="code">
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</pre>

(mt Empfehlung: Bitfelder sparen zwar Platz, verschlechtern aber unter
Umständen die Les- und Wartbarkeit des Codes. Anfängern wird geraten,
ein "ganzes" ein Byte (uint8_t) zu nutzen auch wenn nur ein Bitwert gespeichert
werden soll.)

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten
Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher
Dinge erledigt werden können, welche nicht zeitkritisch sind. 
Wenn ein Interrupt ausgelöst wird so wird automatisch die zugeordnete
Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Allgemeiner Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heisst, das Programm kann die
Inhalte der Register auslesen und beschreiben. 
Einige Register haben spezielle Funktionen, andere wiederum könne für
allgemeine Zwecke (Speichern von Datenwerten) verwendet werden.

Einzelne Register sind bei allen AVR's vorhanden, andere wiederum nur bei
bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff
auf den UART notwendig sind selbstverständlich nur bei denjenigen Modellen
vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden
AVR-Typen definiert. 

Wenn im Makefile der MCU-Typ definiert ist, wird vom System automatisch die
zum Typen passende Definitionsdatei genutzt, sobald man im Code die allgemeine
"io.h" Header-Datei einbinden.

<pre class="code">
#include <avr/io.h>
</pre>

Ist im Makefile der MCU Type z.B. mit dem Inhalt atmega8 definiert,
wird beim einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit
den Register-Definitionen für den ATmega8 eingelesen.



== I/O-Register ==

Die I/O-Register haben einen besonderen Stellenwert bei den AVR Controllern.
Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. 
Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir mal
die 8-Bit Register.


=== Lesen eines I/O-Registers ===



Zum Lesen kann man auf I/O Register einfach wie auf eine
Variable zugreifen. Die spezielle Funktion inp() ist nicht mehr
notwendig und veraltet.

Beispiel:

<pre class="code">
#include <avr/io.h>
uint8_t foo;
...
int main(void)
{
foo=PINB; /* kopiert den Status der Eingabepins an PortB in die Variable foo */
...
}
</pre>

==== Lesen eines Bits ====

Die AVR-Bibliothek stellt auch Funktionen zur Abfrage eines einzelnen Bits
eines Registers zur Verfügung:

;bit_is_set (<Register>,<Bitnummer>) : Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 4 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>) : Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen bit_is_clear bzw. bit_is_set sind nicht unbedingt erfoderlich, man kann auch "einfachen" C-Syntax verwenden. Der universell verwendbar ist. ''bit_is_set'' entspricht dabei z.B. (Variable & (1<<Bitnummer)). Das Ergebnis ist <>0 wenn das Bit gesetzt und 0 wenn nicht gesetzt ist.

* siehe auch [[Bitmanipulation]]

=== Schreiben eines I/O-Registers ===



Zum Schreiben kann man I/O Register einfach wie eine
Variable setzen. Die spezielle Funktion outp() ist nicht mehr
notwendig, veraltet und sollte nicht mehr genutzt werden.

Beispiel:

<pre class="code">
#include <avr/io.h>
...
int main(void)
{
DDRA=0xff; /* Setzt das Richtungsregister des Ports A auf 0xff (alle Pins als Ausgang) */
PORTA=0x03; /* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low" */
...
}
</pre>

==== Schreiben eines Bits ====



Einzelne Bits setzt man "Standard-C-Konform" mittels logischen (bit-) Operationen.

mit dem Ausduck |=(1<<Bitnummer) wird ein Bit gesetzt, mit dem Ausdruck
&=~(1<<Bitnummer) wird ein Bit geloescht. Die Funktionen sbi und cbi sind
dazu nicht notwendig, veraltet und sollten nicht mehr genutzt werden.

Beispiel:
<pre class="code">
...
#define MEINBIT 2
...
PORTA |= (1<<MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1<<MEINBIT); /* loescht Bit 2 an PortA */
</pre>

* siehe auch:
** [[Bitmanipulation]]
** [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

=== Warten auf einen bestimmten Zustand ===

Es gibt in der Bibliothek sogar Funktionen, die Warten, bis ein bestimmter
Zustand auf einem Bit erreicht ist. 
Es ist allerdings normalerweise eine eher unschöne Programmiertechnik.

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das
definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits
gesetzt ist wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT 2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1<<WARTEBIT)) ) ;
</pre>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das
definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits
gelöscht ist wird die Funktion sofort wieder verlassen. 
Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT 4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// ungleich 0 ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
</pre>

Universeller und auch auf andere Platformen besser übertragbar ist die Verwendung von C-Standardoperationen.

siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]



= Zugriff auf Ports =

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind
jedem Port 3 Register zugeordnet:

{| border="1"
|-
| '''DDRx'''
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (anhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
| '''PORTx'''
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Wird ein Port als Eingang geschaltet, so können mit diesem Register
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|-
| '''PINx'''
| Eingangadresse für Port'''x'''.

Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der Portspins. Bit gesetzt (1) wenn Pin "high/an", Bit gelöscht (0) wenn Portpin "low/aus".
|}

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.


Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Wollen wir also beispielsweise Pin 0 bis 4 von Port B als Ausgänge
definieren so schreiben wir folgende Zeile:


<pre class="code">
#include <avr/io.h>
...
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F

DDRB=0x1F; /* direkte Zuweisung - unuebersichtlich */
/* mehr Tipparbeit aber uebersichtlicher: */
DDRB=(1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3)|(1<<DDB4);
...
</pre>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet.

=== Ganze Ports ===

Um einen ganzen Port als Ausgang zu definieren, kann der folgende Befehl
verwendet werden:

<pre class="code">
DDRB=0xff;
</pre>

Im Beispiel wird der Port B als Ganzes als Ausgang geschaltet.

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen
bzw. auszugeben.

== Ausgänge ==

Wir wollen nun einen als Ausgang definierten Pin auf Logisch 1 setzen. Dazu schreiben wir den entsprechenden Wert in das Portregister des entsprechenden Ports.

Mit dem Befehl

<pre class="code">
PORTB=0x04; /* besser PORTB=(1<<DDB2) */
</pre>

wird also der Ausgang an Pin 2 gesetzt (Beachte, dass die Bits immer ''von 0 an''
gezählt werden, das niederwertigste Bit ist also Bit 0 und nicht etwa Bit 1).

Man beachte bitte, dass bei der Zuweisung mittels '''='''  immer alle Pins gleichzeitig angegeben werden. Man sollte also zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfliessen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an PortB auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<pre class="code">
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<DDB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<DDB2)
</pre>


Die Funktionen cbi und sbi sind dazu nicht notwendig, veraltet und sollten
nicht mehr genutzt werden.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wird den Pegel über entsprechende Hardware (z.B. Optokoppler, Spannunsteiler "Levelshifter") anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unserer Controllers eine logische 1 (Vcc) oder eine logische 0 (Masse) anliegt.

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.



Wobei es hier sehr wichtig ist, zur Abfrage der Eingänge nicht etwa das Portregister '''PORTx''' zu verwenden, sondern die Porteingangsadresse '''PINx'''. Dies ist
ein oft gemachter Fehler!

Wollen wir also die aktuellen Signalzustände von Port D abfragen und in einer
Variable namens bPortD abspeichern so schreiben wir dazu folgende Befehlszeile:

<pre class="code">
#include <avr/io.h>
...
bPortD = PIND;
...
</pre>


=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen (''Active Low'' und ''Active High''):

{| border="1"
|-
| '''Active Low'''
| '''Active High'''
|-
| [[Image:Active Low.gif]]
| [[Image:Active High.gif]]
|-
| Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet.

Damit bei offenem Schalter der Controller kein undefiniertes Signal
bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein
sogenannter Pull-Up Widerstand geschaltet. Dieser dient dazu, den Pegel
bei geöffnetem Schalter auf logisch 1 zu ziehen. 
Der Widerstandswert des Pull-Up Widerstands ist an sich nicht kritisch. Es
muss jedoch beachtet werden, dass über den Widerstand ein Strom in den
Eingang fliesst, also sollte er nicht zu klein gewählt werden um den
Controller nicht zu zerstören. Wird er allerdings zu hoch gewählt ist
die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10
Kiloohm eingebürgert.

Die AVR's haben sogar an den meisten Pins softwaremässig zuschaltbare
interne Pull-Up Widerstände, welche wir natürlich auch verwenden
können.
| Hier wird der Kontakt zwischen die Versorgungsspannung und Masse geschaltet.

Damit bei offener Schalterstellung kein undefiniertes Signal am Controller
ansteht, wird zwischen den Eingangspin und die Masse ein Pull-Down
Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter
Schalterstellung auf logisch 0 zu halten.
|}

==== Pull-Up Widerstände aktivieren ====

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden
über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang'''
geschaltet ist. 

Wird der Wert des entsprechenden Portpins auf 1 gesetzt so ist
der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up
Widerstand nicht aktiv. 
Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand
verwenden, aber nicht beide zusammen.



<pre class="code">
#include <avr/io.h>
...
DDRD=0x00; /* alle Pins von Port D als Eingang */
PORTD=0xff: /* interer Pull-Up an allen Port-Pins aktivieren */
...
</pre>

Im Beispiel wird der gesamte Port D als Eingang geschaltet und alle Pull-Up
Widerstände aktiviert.

===== Tastenentprellung =====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von
Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim
Schliessen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern
mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes. 
Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein
solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen
als mehrfache Impulse gezählt wird. 
Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen
werden.

ToDo Bsp Quellcode

== Analog ==

Leider können wir mit unseren Controllern keine analogen Werte direkt
ausgeben oder einlesen. Dazu müssen wir Umwege gehen, doch dies wird in einem späteren
Kapitel behandelt.

=== 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1) ===

Einige der Portregister in den AVR-Controllern sind 16 Bit breit, Man spricht
dann von einem '''Wort'''.


Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<pre class="code">
#include <avr/io.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8

= Der UART, Teil 1 =

Wir werden in zukünftigen Übungen in die Situation kommen, dass wir
Informationen vom Controller auswerten bzw. anzeigen müssen wobei es vielleicht
dann nicht mehr reicht, ein paar Leuchtdioden anzusteuern. 
Somit brauchen wir eine Verbindung vom AVR zu unserem PC, und dies am besten
über die serielle Schnittstelle.

== Allgemeines zum UART ==

Einige AVR-Controller haben einen vollduplexfähigen UART ('''U'''niversal
'''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut.
Dies ist eine wirklich feine Sache, haben wir doch damit schon das nötige
Werkzeug, um mit anderen Geräten, welche über eine serielle Schnittstelle
verfügen (insbesondere mit unserem PC), zu kommunizieren.

Übrigens: Vollduplex heisst nichts anderes, als dass der Baustein gleichzeitig
senden und empfangen kann.

Neuere AVRs (ATmega) verfügen über einen oder zwei U'''S'''ART(s), dieser unterschiedet sich vom UART häuptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

Der UART wird über vier separate Register angesprochen. USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurations/Datenregister. Das Datenblatt gibt darüber Auskunft. Die Folgende Tabelle gibt nur die Register für die (veralteten) UARTs wieder.

{| border="1"
|-
| '''UCR   '''
| '''U'''ART '''C'''ontrol '''R'''egister. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXCIE'''
| align="center" | '''TXCIE'''
| align="center" | '''UDRIE'''
| align="center" | '''RXEN'''
| align="center" | '''TXEN'''
| align="center" | '''CHR9'''
| align="center" | '''RXB8'''
| align="center" | '''TXB8'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''CHR9''' (9 Bit Characters)
:Wenn dieses Bit gesetzt ist, können 9 Bit lange Zeichen übertragen und empfangen werden. Das 9. Bit kann bei Bedarf als zusätzliches Stopbit oder als Paritätsbit verwendet werden. Man spricht dann von einem 11-Bit Zeichenrahmen:
:1 Startbit + 8 Datenbits + 1 Stopbit + 1 Paritätsbit = 11 Bits

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.

|-
| '''USR   '''
| '''U'''ART '''S'''tatus '''R'''egister. 
Hier teilt uns der UART mit, was er gerade so macht.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXC'''
| align="center" | '''TXC'''
| align="center" | '''UDRE'''
| align="center" | '''FE'''
| align="center" | '''OR'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt bevor ein weiteres Zeichen komplett empfangen wurde wird eine Überlauf-Fehlersituation eintreffen. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, wenn die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit wird vom AVR gesetzt, wenn ein Zeichen vom Sendedatenregister in das Send-Schieberegister übernommen wurde und der UART nun wieder bereit ist, ein neues Zeichen zum Senden aufzunehmen.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''OR''' ('''O'''ver'''R'''un) 
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne
kommunizieren möchten. Der Wert, der in dieses Register geschrieben
werden muss, errechnet sich nach folgender Formel:

<math>
\begin{matrix}
UBBR = \frac{Taktfrequenz}{Baudrate * 16} - 1
\end{matrix}
</math>

Es sind Baudraten bis zu 115200 Baud und höher möglich.
|}

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (LOW) und 5V (HIGH). Die
Schnittstellenspezifikation für RS232 definiert jedoch -3V ... -12V (LOW) und
+3 ... +12V (HIGH). Zudem muss der Signalaustausch zwischen AVR und
Partnergerät invertiert werden. Für die Anpassung der Pegel und das
Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste
davon ist wohl der MAX232. Allerdings kostet der auch wieder Geld und benötigt
zusätzlich immerhin 4 externe Elkos.

Die in den PC eingebauten Schnittstellen vertragen ohne Klagen auch den
TTL-Pegel vom AVR. Allerdings müssen wir immer noch die Signale invertieren. Im
einfachtesn Fall verwenden wir dazu jeweils einen einfachen NPN-Transistor und 2
Widerstände. Näheres dazu erfahrt ihr in den folgenden Übungen.

Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z.B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfielt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Senden mit dem UART ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. 
Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach
gewünschter Funktionsweise die
benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister. 
Da wir vorerst nur senden möchten und (noch) keine Interrupts auswerten wollen,
gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das
'''Transmitter Enable''' Bit setzen müssen:


<pre class="code">
UCR |= (1<<TXEN);
</pre>

Der Atmega16 hat mehrere Konfigurationsregister für USART und erfordert eine etwas andere Konfiguration

<pre class="code">
UCSRB |= (1<<TXEN); //UART TX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1
</pre>

Nun müssen wir noch die Baudrate festlegen. Gemäß unserer Formel brauchen
wir dazu die Taktfrequenz des angeschlossenen Oszillators bzw. Quarz in die
Formel einzufügen und das Resultat der Berechnung in das Baudratenregister des
UART einzuschreiben:

<pre class="code">
/* UART-Init beim AT90S2313 */
#define F_CPU 4000000; // Zum Beispiel 4Mhz-Quarz
#define UART_BAUD_RATE 9600 // Wir versuchen mal mit 9600 Baud
UBRR = F_CPU / (UART_BAUD_RATE * 16L) - 1;
</pre>

Wieder für den Mega16 mit einem 16bit-Register eine andere Programmierung

<pre class="code">
/* USART-Init beim ATmegaXX */
#define F_OSC 3686400 /* Oszillator-Frequenz in Hz */
#define UART_BAUD_RATE 9600
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)

UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

/* alternativ bei der avr-libc "direkt 16bit" : */
UBRR=UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);
</pre>

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben.

<pre class="code">
while (USR & (1<<UDRE)); /* warten bis Senden moeglich */
UDR = 'x'; // Schreibt das Zeichen x auf die Schnittstelle
</pre>

=== Schreiben einer Zeichenkette (String) ===

Es ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

Zu diesem Zweck können wir uns für's Erste eine einfache Funktion basteln:

<pre class="code">
void SendeString (char *szBuf)
{
while (*szBuf) {
loop_until_bit_is_set (USR, UDRE); /* warten bis Senden moeglich */
UDR=*szBuf;
szBuf++;
}
}
</pre>

Warteschleifen sind insofern etwas kritisch, da während des Sendens eines
Strings nicht mehr auf andere Ereignisse reagieren werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. emfangenen Zeichen/Bytes zwischengespeichert und mittels Interruptroutinen an den U(S)ART weitergebgen bzw. ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

* siehe auch: Weiterführende Informationen inkl. Beispielen für die Nutzung von stdio-Funktionen (prinf etc.) im [[AVR-Tutorial - UART]].
* [http://homepage.sunrise.ch/mysunrise/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc

= Analoge Ein- und Ausgabe =

Leider können wir mit unseren Controllern keine analogen Werte direkt
verarbeiten. Dazu bedarf es jeweils einer Umwandlung des analogen Signals in
einen digitalen Zahlenwert. Je nachdem, ob wir Daten einlesen oder ausgeben
wollen reden wir dabei von '''ADC''' oder '''DAC'''.

== ADC (Analog Digital Converter) ==

Der '''ADC''' wandelt analoge Signale in digitale Werte um, welche vom Controller
interpretiert werden können. Einige AVR-Typen haben bereits einen oder mehrere
solcher '''ADC''''s eingebaut, bei den kleineren AVR's müssen wir uns anders aus der
Affäre ziehen. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst
werden kann, wird durch die Auflösung des '''ADC''' in Anzahl Bits angegeben, man
hört bzw. liest jeweils von 8-Bit '''ADC''' oder 10-Bit ''' ADC''' oder noch höher. 
Ein '''ADC''' mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit
von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten
eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

<div align="center"><center>

{| border="1"
|-
| align="center" | '''Eingangsspannung am ADC'''
| align="center" | '''Entsprechender Messwert'''
|-
| align="center" | 0...<0.625V
| align="center" | 0
|-
| align="center" | 0.625...<1.25V
| align="center" | 1
|-
| align="center" | 1.25...<1.875V
| align="center" | 2
|-
| align="center" | 1.875...<2.5V
| align="center" | 3
|-
| align="center" | 2.5...<3.125V
| align="center" | 4
|-
| align="center" | 3.125...<3.75V
| align="center" | 5
|-
| align="center" | 3.75...<4.375V
| align="center" | 6
|-
| align="center" | 4.375...5V
| align="center" | 7
|}

</center>
</div>

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des '''
ADC''' ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Messen eines Widerstandes ===

Wir wollen hier einmal die wohl einfachste Methode zur Erfassung eines
analogen Wertes realisieren und zwar das Messen eines veränderlichen
Widerstandes wie z.B. eines Potentiometers.

Man stelle sich vor, wir schalten einen Kondensator in Reihe zu einem
Widerstand zwischen die Versorgungsspannung und Masse und dazwischen nehmen wir
das Signal ab und führen es auf einen der Pins an unserem Controller, genau so
wie es in folgender Grafik dargestellt ist.

[[Image:Poti.gif]]

Wenn wir nun den Pin des AVR als Ausgang schalten und auf
Logisch 1 (HIGH) legen, dann liegt an beiden Platten des Kondensators ''' Vcc''' an und
dieser wird entladen (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen). 
Nachdem nun der Kondensator genügend entladen ist schalten wir einfach den Pin
als Eingang wodurch dieser hochohmig wird. Der Kondensator lädt sich jetzt
über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und
derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti
unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), dann schaltet der
Eingang von HIGH auf LOW um. Wenn wir nun messen (zählen), wie lange es dauert,
bis der Kondensator so weit geladen ist, dann haben wir einen ungefähren Wert
der Potentiometerstellung. 
Der 220 Ohm Widerstand dient dem Schutz des Controllers. Wenn nämlich sonst die
Potentiometerstellung auf Maximum steht (0 Ohm), dann würde in den Eingang des
Controllers ein viel zu hoher Strom fliessen und der AVR würde in Rauch
aufgehen.

Dies ist meines Wissens die einzige Schaltung zur Erfassung von
Analogwerten, welche mit nur einem einzigen Pin auskommt. 
Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine
Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B:
0...100 % oder so) umzurechnen.

Wer Lust hat, sich selber mal an ein solches Programm
heranzuwagen, der sollte das jetzt tun. Für diejenigen, die es gern schnell
mögen, hier das Beispielprogramm, welches den UART-Printf aus den
vorangegangenen Kapiteln benötigt, inkl. Makefile:

{| border="0"
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Poti.c Poti.c ]
| Hauptprogramm.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.c Pot.c]
| Separate Routine zur Ermittlung des Messwertes.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.h Pot.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c UartPrintF.c]
| Für die Debugausgabe auf den UART.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h UartPrintF.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile Makefile]
| Makefile.
|}

Nachdem das Programm auf den AVR geladen wurde, muss dieser
kalibriert werden. Dazu wird der Kalibrierungsschalter geschlossen und das Poti
einige Male zwischen minimaler und maximaler Stellung hin und her gedreht. Dabei
werden die jeweiligen Maximalwerte bestimmt. Wenn der Kalibrierschalter wieder
geöffnet wird werden die Kalibrierungsdaten in's EEPROM des AVR geschrieben,
damit die Prozedur nicht nach jedem Reset wiederholt werden muss.

Auf Pin 4 habe ich noch ein Triggersignal gelegt, welches auf
HIGH geht wenn die Messung beginnt und auf LOW, wenn der Messvorgang beendet
wird. Mit Hilfe dieses Signals kann der Vorgang wunderschön auf einem
Oszillographen dargestellt werden.

=== ADC über Komparator ===

Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

[[Image:ADC ueber Komparator.gif]]

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert. 
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

=== Der ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem '''ADC-Wandler''' zurückgreifen. Wir wollen hier einmal den AT90S8535 besprechen, welcher über 8 ADC-Kanäle verfügt. (TODO: nur ein Wandler, Mulitiplexbetrieb, nur eine Pin zur gleichen Zeit)

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung.

Verfügt der AVR über eine interne Referenzspannung (Datenblatt typisch 2,56 oder 1,1V je nach AVR), bleibt der ''Anschluss AREF'' unbeschaltet und man stellt die ADC-Register so ein, dass die interne Referenzspannung als "AREF" genutzt wird. Ansonsten ist eine externe Referenzspannung von maximal '''Vcc''' an den Abschluss '''AREF''' anzulegen. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden.

==== Einfache Wandlung (Single Conversion) ====

In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestossen für jeweils eine Messung.

==== Frei laufend (Free Running) ====

In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register, welche hier aufgelistet werden.

{| border="1"
|-
| '''ADCSR   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ADEN'''
| align="center" | '''ADSC'''
| align="center" | '''ADFR'''
| align="center" | '''ADIF'''
| align="center" | '''ADIE'''
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt, ist können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''Fr'''ee Running Select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Eine logische 1 aktiviert den frei laufenden Modus. Der ''' ADC''' misst nun ständig den ausgewählten Kanal und schreibt den gemessenen Wert in das '''ADC Data Register'''.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, wenn eine Umwandlung erfolgt und das '''ADC Data Register''' aktualisiert ist.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird (So steht es in der AVR-Dokumentation).

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200kHz}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50kHz}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.
<dl><dd>
{| style="" border="1"
|-
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
| align="center" | '''Teilungsfaktor'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 2
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 2
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 4
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 8
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 16
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 32
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 64
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 128
|}
</dd></dl>
|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<pre class="code">
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
C-Operatorprioritaet sichergestellt)
</pre>

oder

<pre class="code">
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</pre>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''MUX2'''
| align="center" | '''MUX1'''
| align="center" | '''MUX0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''MUX2...MUX0'''
:Mit diesem 3 Bits wird der zu messende Kanal bestimmt. Es wird einfach die entsprechende Pinnummer des Ports eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Meine Empfehlung ist deswegen klar diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Aktivieren des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register
setzen. Im gleichen Schritt legen wir auch gleich die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls mit Spannungsteiler konditionieren. Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1024 für V_ref-Volt.

<pre class="code">

#define CHANNELOFFSET 4

uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result;

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler setzen auf 8 (1)
ADCSRA |= (1<<ADEN); // ADC aktivieren (1)

ADMUX = CHANNELOFFSET+channel; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)

result = 0;

/* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
for(i=0;i<4;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)
result += ADC; // Wandlungsergebnisse aufaddieren
}

ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)

result >>= 2; // Summe durch vier teilen = arithm. Mittelwert

return result;
}
</pre>

Im Beispiel wird bei jedem Aufruf der ADC aktiviert und nach der Wandlung wieder abgeschaltet, das spart Strom. Will man dies nicht, verschiebt man die mit (1) gekenntzeichneten Zeilen in eine Funktion adc_init() o.ä. und löscht die mit (2) markierten Zeilen.



== DAC (Digital Analog Converter) ==

Mit Hilfe eines ''' DAC''' können wir nun auch Analogsignale ausgeben. Es gibt hier
mehrere Verfahren. Wenn wir beim ''' ADC''' die Möglichkeit haben, mit externen
Komponenten zu operieren, müssen wir bei der '''DAC'''-Wandlung mit dem auskommen, was
der Controller selber zu bieten hat.

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie ''' PWM''' eigentlich funktioniert.

Wie wir alle wissen ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber
wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. 
Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen
HIGH und LOW umschalten? 
Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen geometrischen Mittelwert, der je nach Pulsbreite
kleiner oder grösser ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein
RC-Glied filtern dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVR's können wir direkt '''PWM'''-Signale erzeugen. Dazu
dient der 16-Bit Zähler, welcher im sogenannten '''PWM'''-Modus betrieben werden
kann.

Hinweis:
:In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist allerdings bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt.

Um den '''PWM'''-Modus zu aktivieren müssen im Timer/Counter1 Control
Register A '''TCCR1A''' die Pulsweiten-Modulatorbits '''PWM10''' bzw. '''PWM11''' entsprechend
nachfolgender Tabelle gesetzt werden:

{| border="1"
|-
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| PWM-Modus des Timers ist nicht aktiv.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM.
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben. Die
Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| border="1"
|-
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden heisst dann:

<pre class="code">
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</pre>

Damit der Timer/Counter überhaupt läuft müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorzähler) einstellen, und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| border="1"
|-
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<pre class="code">
TCCR1B = (1<<CS12) | (1<<CS10);
</pre>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<pre class="code">
OCR1A = xxx;
</pre>

Die folgende Grafik soll den Zusammenhang zwischen dem
Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren.

= Die Timer/Counter des AVR =

Die heutigen Mikrocontroller und insbesondere die RISC-AVR's sind für viele
Steuerungsaufgaben natürlich viel zu schnell. Wenn wir beispielsweise eine LED
oder Lampe blinken lassen wollen, können wir selbstverständlich nicht die
CPU-Frequenz verwenden da ja dann nichts mehr vom Blinken zu bemerken wäre.

Wir brauchen also eine Möglichkeit, die Taktfrequenz auf vernünftige Werte
herunter zu brechen. Selbstverständlich sollte die resultierende Frequenz dann
auch noch einigermassen genau und stabil sein.

Hier kommen die im AVR vorhandenen Timer/Counter zum Einsatz.

Ein anderes Anwendungsgebiet ist die Zählung von Signalen, welche über
einen I/O-Pin zugeführt werden können.

Die folgenden Ausführungen beziehen sich auch den AT90S2313. Für andere
Modelltypen müsst ihr euch die allenfalls notwendigen Anpassungen aus den
Datenblättern der entsprechenden Controller herauslesen.

Wir unterscheiden grundsätzlich zwischen 8-Bit Timern, welche eine
Auflösung von 256 aufweisen und 16-Bit Timern mit (logischerweise) einer
Auflösung von 65536.

Als Eingangstakt für die Timer/Counter kann entweder die CPU-Taktfrequenz,
der Vorteiler-Ausgang oder ein an einen I/O-Pin angelegtes Signal verwendet
werden. Wenn ein externes Signal verwendet wird, so darf dessen Frequenz nicht
höher sein als die Hälfte des CPU-Taktes.

=== Der Vorzähler (Prescaler) ===

Beide Timer/Counter werden im Timerbetrieb über den gleichen Vorzähler
versorgt.

Der Vorzähler dient dazu, den CPU-Takt vorerst mal runter zu brechen auf eine
wählbare Teilung. Die so geteilte Frequenz wird den Eingängen der Timer
zugeführt.

Wenn wir mit einer einem CPU-Takt von 4 MHz arbeiten und den Vorteiler auf 1024
einstellen wird also der Timer mit einer Frequenz von 4 MHz / 1024, also mit ca.
4 kHz versorgt. Wenn also der Timer läuft, so wird das Daten- bzw.
Zählregister mit dieser Frequenz inkrementiert.

== 8-Bit Timer/Counter ==

Alle AVR-Modelle weisen mindestens einen, teilweise sogar zwei, 8-Bit Timer
auf.

Der 8-Bit Timer wird über folgende Register angesprochen:

{| border="1"
|-
| '''TCCR0'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
Timer '''0'''

In diesem Register stellen wir ein, wie wir den Timer/Counter verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CS02'''
| align="center" | '''CS01'''
| align="center" | '''CS00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''CS02, CS01, CS00''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS02
| align="center" | CS01
| align="center" | CS00
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin '''TO''', fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin '''TO''', steigende Flanke
|}
</dd>
</dl>
:Wenn als Quelle der externe Pin '''TO''' verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin '''TO''' als Ausgang geschaltet ist.

|-
| '''TCNT0'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer '''0''' 
Dieses ist als 8-Bit Aufwärtszähler mit Schreib- und Lesezugriff
realisiert. Wenn der Zähler den Wert 255 erreicht hat beginnt er beim
nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}
|}

Um nun also den Timer0 in Betrieb zu setzen und ihn mit einer Frequenz von 1/1024-tel des CPU-Taktes zählen zu lassen, schreiben wir die folgende Befehlszeile:

<pre class="code">
TCCR0 = (1<<CS00)|(1<<CS02);
</pre>

Der Zähler zählt nun aufwärts bis 255, um dann wieder bei 0 zu beginnen. Der aktuelle Zählerstand steht in TCNT0. Bei jedem Überlauf von 255 auf 0 wird das Timer Overflow Flag '''TOV0''' im Timer Interrupt Flag '''TIFR'''-Register gesetzt und, falls so konfiguriert, ein entsprechender Timer-Overflow-Interrupt ausgelöst.

== 16-Bit Timer/Counter ==

Viele AVR-Modelle besitzen ausser den 8-Bit Timers auch einen oder sogar zwei
(einige ATmega-Modelle) 16-Bit Timer.

Die 16-Bit Timer/Counter sind wesentlich komplexer aufgebaut als die 8-Bit
Timer/Counter, bieten dafür aber auch viel mehr Möglichkeiten, als da sind:

* Die [[PWM]]-Betriebsart Erzeugung eines pulsweitenmodulierten Ausgangssignals.
* Vergleichswert-Überprüfung mit Erzeugung eines Ausgangssignals (Output Compare Match).
* Einfangen eines Eingangssignals mit Speicherung des aktuellen Zählerwertes (Input Capturing), mit zuschaltbarer Rauschunterdrückung (Noise Filtering).

Folgende Register sind dem Timer/Counter 1 zugeordnet:

{| border="1"
|-
| '''TCCR1A'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''A''' Timer '''1''' 
In diesem und dem folgenden Register stellen wir ein, wie wir den Timer/Counter verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''COM1A1''', '''COM1A0''' ('''Co'''mpare '''M'''atch Control Bits)
:Diese 2 Bits bestimmen die Aktion, welche am Output-Pin '''OC1''' ausgeführt werden soll, wenn der Wert des Datenregisters des Timer/Counter 1 den Wert des Vergleichsregisters erreicht, also ein so genannter Compare Match auftritt.
:Der Pin '''OC1''' ('''PB3''' beim 2313) muss mit dem Datenrichtungsregister als Ausgang konfiguriert werden.

<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Das Signal am Pin '''OC1''' wird invertiert (Toggle).
|-
| align="center" | 1
| align="center" | 0
| Der Output Pin '''OC1''' wird auf 0 gesetzt.
|-
| align="center" | 1
| align="center" | 1
| Der Output Pin '''OC1''' wird auf 1 gesetzt.
|}
</dd></dl>
:In der PWM-Betriebsart haben diese Bits eine andere Funktion.
<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 1
| align="center" | 0
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 0 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 1 gesetzt.

Man nennt dies ''nicht invertierende PWM''.
|-
| align="center" | 1
| align="center" | 1
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 1 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 0 gesetzt.

Man nennt dies ''invertierende PWM''.
|}
</dd></dl>

'''PWM11''', '''PWM10''' ('''PWM''' Mode Select Bits)
:Mit diesen 2 Bits wird die PWM-Betriebsart des Timer/Counter 1 gesteuert.
<dl><dd>
{| border="1"
|-
| align="center" | PWM11
| align="center" | PWM10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Die PWM-Betriebsart ist nicht aktiviert. Timer/Counter 1 arbeitet als normaler Timer bzw. Zähler.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM Betriebsart aktivieren.
|}
</dd></dl>
|-
| '''TCCR1B'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''B''' Timer '''1'''

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ICNC1'''
| align="center" | '''ICES1'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CTC1'''
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''ICNC1''' ('''I'''nput '''C'''apture '''N'''oise '''C'''anceler (4 CKs) Timer/Counter 1
:oder auf Deutsch Rauschunterdrückung des Eingangssignals.
:Wenn dieses Bit gesetzt ist und mit dem Input Capture Signal gearbeitet wird so werden nach der Triggerung des Signals mit der entsprechenden Flanke (steigend oder fallend) am Input Capture Pin '''ICP''' jeweils 4 Messungen mit der CPU-Frequenz des Eingangssignals abgefragt. Nur dann, wenn alle 4 Messungen den gleichen Zustand aufweisen gilt das Signal als erkannt.

'''ICES1''' ('''I'''nput '''C'''apture '''E'''dge '''S'''elect Timer/Counter '''1''')
:Mit diesem Bit wird bestimmt, ob die steigende ('''ICES1'''=1) oder fallende ('''ICES1'''=0) Flanke zur Auswertung des Input Capture Signals an Pin '''ICP''' heran gezogen wird.

'''CTC1''' ('''C'''lear '''T'''imer/'''C'''ounter on Compare Match Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, so wird nach einer Übereinstimmung des Datenregisters '''TCNT1H'''/'''TCNT1L''' mit dem Vergleichswert in '''OCR1H'''/'''OCR1L''' das Datenregister '''TCNT1H'''/'''TCNT1L''' auf 0 gesetzt.
:Da die Übereinstimmung im Takt nach dem Vergleich behandelt wird, ergibt sich je nach eingestelltem Vorzähler ein etwas anderes Zählverhalten:
:Wenn der Vorteiler auf 1 gestellt ist und C der jeweilige Zählerwert ist, dann nimmt das Datenregister, im CPU-Takt betrachtet, folgende Werte an:
:... | C-2 | C-1 | C | 0 | 1 |...
:Wenn der Vorteiler z.B. auf 8 eingestellt ist, dann nimmt das Datenregister folgende Werte an:
:... | C-2, C-2, C-2, C-2, C-2, C-2, C-2, C-2 | C-1, C-1, C-1, C-1, C-1, C-1, C-1, C-1 | C, 0, 0, 0, 0, 0, 0, 0 |...
:In der PWM-Betriebsart hat dieses Bit keine Funktion.

'''CS12''', '''CS11''', '''CS10''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS12
| align="center" | CS11
| align="center" | CS10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin TO, fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin T0, steigende Flanke
|}
</dd></dl>
:Wenn als Quelle der externe Pin T0 verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin T0 als Ausgang geschaltet ist.
|-
| '''TCNT1H''' '''TCNT1L'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer/Counter '''1'''
Dieses ist als 16-Bit Aufwärtszähler mit Schreib- und Lesezugriff realisiert. Wenn der Zähler den Wert 65535 erreicht hat, beginnt er beim nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''TCNT1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''TCNT1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

In der PWM-Betriebsart wird das Register als Auf/Ab-Zähler verwendet, d.h. der Wert steigt zuerst von 0 bis er den Überlauf von 65535 auf 0 erreicht hat. Dann zählt das Register rückwärts wiederum bis 0.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.

Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''OCR1H''' '''OCR1L'''
| Timer/Counter '''O'''utput '''C'''ompare '''R'''egister Timer/Counter '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''OCR1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''OCR1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Der Wert im Output Compare Register wird ständig mit dem aktuellen Wert im Datenregister TCNT1H/TCNT1L verglichen. Stimmen die beiden Werte überein, so wird ein sogenannter Output Compare Match ausgelöst. Die entsprechenden Aktionen werden über die Timer/Counter 1 Control und Status Register eingestellt.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''ICR1H''' '''ICR1L'''
| Timer/Counter '''I'''nput '''C'''apture '''R'''egister Timer/Counter '''1''' 
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''ICR1''''''H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''ICR1''''''L'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Das Input Capture Register ist ein 16-Bit Register mit Lesezugriff. Es kann nicht beschrieben werden.

Wenn am Input Capture Pin '''ICP''' die gemäß Einstellungen im '''TCCR1B''' definierte Flanke erkannt wird, so wird der aktuelle Inhalt des Datenregisters '''TCNT1H'''/'''TCNT1L''' sofort in dieses Register kopiert und das Input Capture Flag '''ICF1''' im Timer Interrupt Flag Register '''TIFR''' gesetzt.

Wie bereits oben erwähnt, müssen vor dem Zugriff auf dieses Register alle Interrupts gesperrt werden. Zudem müssen Low- und Highbyte des Registers in der richtigen Reihenfolge bearbeitet werden:

{| border="0"
|-
| Lesen:
| '''ICR1L''' -> '''ICR1H'''
|-
| Schreiben:
| '''ICR1H''' -> '''ICR1L'''
|}
|}

=== Die PWM-Betriebsart ===

Wenn der Timer/Counter 1 in der PWM-Betriebsart betrieben wird, so bilden das Datenregister '''TCNT1H'''/'''TCNT1L''' und das Vergleichsregister '''OCR1H'''/'''OCR1L''' einen 8-, 9- oder 10-Bit, frei laufenden PWM-Modulator, welcher als PWM-Signal am '''OC1'''-Pin ('''PB3''' beim 2313) abgegriffen werden kann. Das Datenregister '''TCNT1H'''/'''TCNT1L''' wird dabei als Auf-/Ab-Zähler betrieben, welcher von 0 an aufwärts zählt bis zur Obergrenze und danach wieder zurück auf 0.
Die Obergrenze ergibt sich daraus, ob 8-, 9- oder 10-Bit PWM verwendet wird, und zwar gemäss folgender Tabelle:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Wenn nun der Zählerwert im Datenregister den in '''OCR1H'''/'''OCR1L''' gespeicherten Wert erreicht, wird der Ausgabepin '''OC1''' gesetzt bzw. gelöscht, je nach Einstellung von '''COM1A1''' und '''COM1A0''' im '''TCCR1A'''-Register.

Ich habe versucht, die entsprechenden Signale in der folgenden Grafik zusammenzufassen

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

=== Vergleichswert-Überprüfung ===

Hier wird in ein spezielles Vergleichswertregister ('''OCR1H'''/'''OCR1L''') ein Wert eingeschrieben, welcher ständig mit dem aktuellen Zählerwert verglichen wird.
Erreicht der Zähler den in diesem Register eingetragenen Wert, so kann ein Signal (0 oder 1) am Pin '''OC1''' erzeugt und/oder ein Interrupt ausgelöst werden.

=== Einfangen eines Eingangssignals (Input Capturing) ===

Bei dieser Betriebsart wird an den Input Capturing Pin (ICP) des Controllers eine Signalquelle angeschlossen.
Nun kann je nach Konfiguration entweder ein Signalwechsel von 0 nach 1 (steigende Flanke) oder von 1 nach 0 (fallende Flanke) erkannt werden und der zu diesem Zeitpunkt aktuelle Zählerstand in ein spezielles Register abgelegt werden. Gleichzeitig kann auch ein entsprechender Interrupt ausgelöst werden.
Wenn die Signalquelle ein starkes Rauschen beinhaltet, kann die Rauschunterdrückung eingeschaltet werden. Dann wird beim Erkennen der konfigurierten Flanke über 4 Taktzyklen das Signal überwacht und nur dann, wenn alle 4 Messungen gleich sind, wird die entsprechende Aktion ausgelöst.

== Gemeinsame Register ==

Verschiedene Register beinhalten Zustände und Einstellungen, welche sowohl
für den 8-Bit, als auch für den 16-Bit Timer/Counter in ein und demselben
Register zu finden sind.

{| border="1"
|-
| '''TIMSK'''
| '''T'''imer/Counter '''I'''nterrupt '''M'''a'''sk'''
Register

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOIE1'''
| align="center" | '''OCIE1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''TICIE'''
| align="center" | '''-'''
| align="center" | '''TOIE0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOIE1''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 1 ein Timer Overflow 1 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''OCIE1A''' ('''O'''utput '''C'''ompare Match '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Beim Timer/Counter 1 kann zusätzlich zum Überlauf ein Vergleichswert definiert werden.

:Wenn dieses Bit gesetzt ist, wird beim Erreichen des Vergleichswertes ein Compare Match Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TICIE''' ('''T'''imer/Counter '''I'''nput '''C'''apture '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein Capture Event Interrupt ausgelöst, wenn ein entsprechendes Signalereignis am Pin PD6(ICP) auftritt. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein, wenn auch ein entsprechender Interrupt ausgelöst werden soll.

'''TOIE0''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''0''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 0 ein Timer Overflow 0 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

|-
| '''TIFR'''
| '''T'''imer/Counter '''I'''nterrupt '''F'''lag '''R'''egister

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOV1'''
| align="center" | '''OCF1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''ICF1'''
| align="center" | '''-'''
| align="center" | '''TOV0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOV1''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''1''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 1 ein Überlauf des Datenregisters stattfindet.

:In der PWM-Betriebsart wird das Bit gesetzt, wenn die Zählrichtung von auf- zu abwärts und umgekehrt geändert wird (Zählerwert = 0).

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''OCF1A''' ('''O'''utput '''C'''ompare '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn der aktuelle Wert des Datenregisters von Timer/Counter 1 mit demjenigen im Vergleichsregister '''OCR1''' übereinstimmt.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''ICF1''' ('''I'''nput '''C'''apture '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn ein Capture-Ereignis aufgetreten ist, welches anzeigt, dass der Wert des Datenregisters des Timer/Counter 1 in das Input Capture Register ICR1 übertragen wurde.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''TOV0''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''0''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 0 ein Überlauf des Datenregisters stattfindet.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.
|}

 

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sog. ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comperators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrups den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

* '''set_sleep_mode(uint8_t mode)'''
:Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z.B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
* '''sleep_mode()'''
:Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus.

<pre class="code">
#include <avr/io.h>
#include <avr/sleep.h>
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach auftreten eines entsprechenden "Aufwach-Interrupts" verarbeitet
...
</pre>

Vorsicht: Nicht alle AVR-Controller (v.a. nicht die "Brandneuen") werden von den avr-libc sleep-Funktionen richtig angesteuert. Bei nicht-untersützten Typen erreicht man die gewollte Funktionalität durch direkte "Bitmanipulation" der ensprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler:

<pre class="code">
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep");
...
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes

= Der Watchdog =

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der Watchdog.

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln.

Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

Betrachten wir doch einmal folgende Codesequenz:

<pre class="code">
uint8_t x;

x = 10;

while (x >= 0) {
// tu was

x--;
}
</pre>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm würde sich also hier aufhängen und auf ewig in der Schleife drehen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde beginnt der Counter von 0 an hochzuzählen. Wenn nun die je nach Vorteiler eingestellte Anzahl Zyklen erreicht wurde, löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern müssen wir den Watchdog regelmässig wieder neu starten bzw. Rücksetzen (Watchdog Reset). Dies sollte innerehalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern muss ein spezielles Prozedere verwendet werden, um den WD auszuschalten und zwar müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden. Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| border="1"
|-
| '''WDTCR'''
| '''W'''atchog '''T'''imer  '''C'''ontrol '''R'''egister

In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''WDTOE'''
| align="center" | '''WDE'''
| align="center" | '''WDP2'''
| align="center" | '''WDP1'''
| align="center" | '''WDP0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''WDTOE''' ('''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable)
:Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
:Wenn das Bit einmal gesetzt ist wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.

'''WDE''' ('''W'''atch'''d'''og '''E'''nable)
:Wenn dieses Bit gesetzt wird, so wird der Watchdog aktiviert.
:Das Bit kann nur gelöscht werden, solange das Bit '''WDTOE''' auf 1 steht.

'''WDP2''', '''WDP1''', '''WDP0''' ('''W'''atch'''d'''og Timer '''P'''rescaler Bits)
:Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:
<dl><dd>
{| border="1"
|-
| align="center" | WDP2
| align="center" | WDP1
| align="center" | WDP0
| align="center" | Anzahl Zyklen
| align="center" | Typ. Timeoutzeit bei Vcc = 3V
| align="center" | Typ. Timeoutzeit bei Vcc = 5V
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 16K
| align="center" | 47ms
| align="center" | 15ms
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 32K
| align="center" | 94ms
| align="center" | 30ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 64K
| align="center" | 0.19s
| align="center" | 60ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 128K
| align="center" | 0.38s
| align="center" | 0.12s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 256K
| align="center" | 0.75s
| align="center" | 0.24s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 512K
| align="center" | 1.5s
| align="center" | 0.49s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 1024K
| align="center" | 3s
| align="center" | 0.97s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 2048K
| align="center" | 6s
| align="center" | 1.9s
|}
</dd></dl>
|}

Um den Watchdog mit dem AVR-GCC Compiler zu verwenden, muss die Headerdatei wdt.h in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

* '''wdt_enable(uint8_t timeout)'''
:Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert (z.B. WDTO_30MS).
* '''wdt_disable()'''
:Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
* '''wdt_reset()'''
:Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Ein paar grundsätzliche Gedanken ==

Ob nun so ein Watchdog überhaupt verwendet werden soll, ist wohl eher eine
philosophische Frage und hängt vom Geschmack jedes einzelnen Entwicklers ab.

Ich persönlich habe es lieber, wenn ich auch merke, dass in meine Programm
etwas noch nicht in Ordnung ist, als dass mir ein Watchdog einfach die CPU immer
wieder zurücksetzt, denn immerhin kann es so passieren, dass ein Programm über
Jahre hinweg so einigermassen läuft, obwohl noch ein voll krasser Bock drin
liegt.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Watchdog timer handling

= Programmieren mit Interrupts =

Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

[[Image:Interrupt Programme.gif]]

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

== Anforderungen an die Interrupt-Routine ==

Um unliebsamen Überraschungen vorzubeugen sollten einige Grundregeln bei
der Gestaltung der Interruptroutinen beachtet werden.

* Die Interruptroutine soll möglichst kurz und schnell abarbeitbar sein, daraus folgt:
* Keine unfangreichen Berechnungen innerhalb der Interruptroutine.
* Keine endlos langen Programmschleifen.
* Obschon es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen rate ich dringend von solchen Spielen ab.

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf dem AVR auslösen, wobei
die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

== Register ==

Der AT90S2313 verfügt über 2 Register welche mit den
Interrupts zusammen hängen.

{| border="1"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INT1'''
| align="center" | '''INT0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INT1''' (External '''Int'''errupt Request '''1''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

'''INT0''' (External '''Int'''errupt Request '''0''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INTF1'''
| align="center" | '''INTF0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INTF1''' (External '''Int'''errupt Flag '''1''')
:Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.

'''INTF0''' (External '''Int'''errupt Flag '''0''')
:Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister.

Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''SE'''
| align="center" | '''SM'''
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''SE''' ('''S'''leep '''E'''nable)
:Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl in den Schlafzustand versetzen zu können.
:Um den Schlafmodus nicht irrtümlich einzuschalten, wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.

'''SM''' ('''S'''leep '''M'''ode)
:Dieses Bit bestimmt der Schlafmodus.
:Ist das Bit gelöscht, so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt, so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")

'''ISC11''', '''ISC10''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.
<dl><dd>
{| border="1"
|-
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}
</dd></dl>
'''ISC01''', '''ISC00''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

<dl><dd>
{| border="1"
|-
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}
</dd></dl>
|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft, wird automatisch das '''Global
Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle
weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem
Zeitpunkt bereits wieder das GIE-bit zu setzen, rate ich dringend davon ab. Dieses
wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn
in der Zwischenzeit weitere Interrupts eintreffen, werden die zugehörigen
Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden
Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt
ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle
anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe,
weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.

=== Das Status-Register ===

Es gilt auch zu beachten, dass das Status-Register während der Abarbeitung
einer Interruptroutine nicht automatisch gesichert wird. Falls notwendig, muss dies vom
Programmierer selber vorgesehen werden.

== Interrupts mit dem AVR GCC Compiler (WinAVR) ==

Selbstverständlich können alle Interruptspezifischen Registerzugriffe wie gewohnt über I/O-Adressierung vorgenommen werden. Etwas einfacher geht es jedoch, wenn wir die vom Compiler zur Verfügung gestellten Mittel einsetzen.

Damit diese Mittel zur Verfügung stehen, müssen wir die Includedatei ''interrupt.h'' und evtl. ''signal.h'' einbinden mittels:

<pre class="code">
// fuer sei(), cli() und INTERRUPT():
#include <avr/interrupt.h>

// fuer SIGNAL() auch:
#include <avr/signal.h>
</pre>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird
nichts anderes gemacht, als das '''Global Interrupt Enable''' Bit im Status
Register gesetzt.

<pre class="code">
sei();
</pre>

Das Makro '''cli()''' schaltet die Interrupts aus, oder anders
gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird
gelöscht.
<pre class="code">
cli();
</pre>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf.
Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen.
Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren
und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen
Zustands die Interrups aktivieren, was zu unerwünschten Seiteneffekten führen kann.
Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern */

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD); // 2 mal in Folge , vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
...

}
</pre>



Nachdem nun die Interrupts aktiviert sind, braucht es selbstverständlich noch den auszuführenden Code, der ablaufen soll, wenn ein Interrupt eintrifft. Dazu gibt es zwei Definitionen: '''SIGNAL''' und '''INTERRUPT''', welche allerdings AVR-GCC spezifisch sind und bei anderen Compilern womöglich anders heissen können.

=== SIGNAL ===

<pre class="code">
#include <avr/signal.h>
...
SIGNAL (siglabel)
{
/* Interrupt Code */
}
</pre>

Mit ''SIGNAL'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektoren angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Vor Nutzung von SIGNAL muss die Header-Datei signal.h eingebunden werden. Mögliche Funktionsrümpfe für solche Interruptfunktionen sind zum Beispiel:

<pre class="code">
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

SIGNAL (SIG_OVERFLOW1)
{
/* Interrupt Code */
}

SIGNAL (SIG_UART_RECV)
{
/* Interrupt Code */
}

// und so weiter und so fort...
</pre>

Während der Ausführung des Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten, so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== INTERRUPT ===

<pre class="code">
#include <avr/interrupt.h>
...
INTERRUPT (signame)
{
/* Interrupt Code */
}
</pre>

Mit INTERRUPT wird genau gleich gearbeitet wie mit SIGNAL. Der Unterschied ist derjenige, dass bei INTERRUPT beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit automatisch wieder gesetzt und somit weitere Interrupts zugelassen werden. Dies kann zu nicht unerheblichen Problemen von im einfachsten Fall einem Stack overflow bis zu sonstigen unerwarteten Effekten führen und sollte wirklich '''nur dann''' angewendet werden, wenn man sich absolut sicher ist, das Ganze auch im Griff zu haben. Vor Nutzung von INTERRUPT muss die Header-Datei interrupt.h eingebunden werden.

Interruptroutinen (ISRs) sollten möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern des Zustands aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen, s.u.). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

siehe auch: Hinweise in [[AVR-GCC]]

== Datenaustausch mit Interrupt-Routinen ==

Variablen auf die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen wird und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte die Code-Optimierung "greifen" und der Wert der Variablen nur in Prozessorregistern zwischenspeichert werden, die "nichts von der Änderung woanders mitbekommen".

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z.B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt z.B. alle 10ms
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
// hier wird gKeyCounter veraendert, die uebrigen
// Programmteile muessen diese Aenderung "sehen"
// (volatile -> aktuellen Wert immer in den Speicher schreiben)
if ( !(KEY_PIN & (1<<KEY_PINNO)) )
if (gKeyCouter < CNTREPEAT) gKeyCounter++;
else gKeyCounter = 0;
}

...

int main(void)
{
...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
...
// hier wird auf gKeyCounter zugegriffen, dazu muss der in der
// ISR geschrieben Wert bekannt sein.
// (volatile -> aktuellen Wert immer aus dem Speicher lesen)
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt"
}
else {
/* hier: Code fuer "Taste kurz gedrueckt"
}
...
}
</pre>

Bei Variablen größer ein Byte muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes ausserhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<pre class="code">
...
volatile uint16_t gMyCounter16bit
...
SIGNAL(...)
{
...
gMyCounter16Bit++;
...
}

int main(void)
{
uint16_t tmpCnt;
...
// nicht gut: mglw. hier ein Fehler wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor Kopieren des zweiten Bytes
// ein Interrupt auftritt der den Inhalt von MyCounter veraendert
tmpCnt = gMyCounter16bit;

// besser: Aenderungen "ausserhalb" verhindern, alle "Teilbytes"
// bleiben konsistent
cli(); // Interupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren
...
}
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8 (Stand: avr-libc Vers. 1.0.4)

== Was macht das Hauptprogramm ==

Im einfachsten Fall gar nichts mehr.

Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der
main-Funktion lediglich noch die Interrupts aktiviert und dann in eine
Endlosschleife folgender Art verzweigt:

<pre class="code">
...
for (;;) {}
...
</pre>

Normalerweise wird man allerdings in den Interruptroutinen die Interrupts
erfassen und im Hauptprogramm dann gemütlich auswerten.

Wie wir im bisherigen Kursverlauf gesehen haben ist es ohnehin mit so
schnellen Controller meistens gar nicht unbedingt notwendig mit
Interruptfunktionen zu arbeiten. 
Es ist allerdings auch zu bemerken, dass mit den Interruptroutinen ein Programm
sehr schön strukturiert werden kann, wenn man es richtig macht.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (eigentlich [[SRAM]]) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als [[FLASH]]-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z.B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin wenig Sinn macht und auch nur bei einigen RAM-losen Typen nach "Bastelarbeiten" möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory). Die Standard-Laufzeitbibliothek des avr-gcc, die [[avr-libc]], stellt diese Funktionen nach einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Einige Beispiele:

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray1 };
...
</pre>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<pre class="code">
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte...
}
</pre>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel, jedoch mit der Funktion pgm_read_word.

<pre class="code">
uint16_t myWord;

myWord = pgm_read_word(&pgmFooWord);
</pre>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "gross". (Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.) Pointer müssen gegebenenfalls "gecastet" werden.

<pre class="code">
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray1

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray2
// da im zweiteb Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmPointerToArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</pre>

=== Floats und Structs lesen ===

Um komplexe Datentypen (structs), nicht-integer Datentypen (floats) aus dem Flash auszulesen, sind Hilfsfunktionen erforderlich. Einige Beispiele:

<pre class="code">

/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
...

/* liest float von Flash-Addresse addr und gibt diese als return-value zurueck */
inline float pgm_read_float(const float *addr)
{
union
{
uint16_t i[2]; // 2 16-bit-Worte
float f;
} u;

u.i[0]=pgm_read_word((PGM_P)addr);
u.i[1]=pgm_read_word((PGM_P)addr+2);

return u.f;
}
...

void egal(void)
{
int i;
float f;

for (i=0;i<3;i++) {
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach' was mit f
}
}
</pre>

TODO: Beispiele fuer structs und pointer aus flash auf struct im flash (menues, state-machines etc.)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuerht, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
...
</pre>

Aber Achtung: Ersetzt man zum Beispiel
<pre class="code">
const char textImFlash[] PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
durch
<pre class="code">
const char textImFlash* PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der textImFlash zu den Konstanten ans Ende des Programmcodes gelegt wird, von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte. Da der lesende Code trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein Bug des AVR-GCC (gesehen bei 3.4.1) zu sein.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<pre class="code">
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
...
</pre>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z.B. 0x01fe), "weiss" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, dass der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000), wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z.B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmässig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, das vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgeben sind ("timed sequence"). Diese Prüfung wird nicht implizit durchgeführt. Im Zweifel kann man Sicherheitshalber bei EEPROM-Zugriffen die Interrupts global deaktivieren, z.B. so:

<pre class="code">
...
uint8_t sreg;
...

sreg = SREG;
cli();

/* hier die eeprom-Zugriffe */

SREG = sreg;
...
</pre>

Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Die Nutzung einer [[C-Präprozessor]]-Ersetzung bringt etwas Bequemlichkeit. Siehe dazu folgendes Beispiel.

<pre class="code">
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h>

// alle Textstellen EEPROM im Quellcode durch __attribute__ ... ersetzen
#define EEPROM __attribute__ ((section (".eeprom")))

...

/* Byte */
uint8_t eeFooByte EEPROM = 123;

/* Wort */
uint16_t eeFooWort EEPROM = 12345;

/* float */
float eeFooFloat EEPROM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEPROM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEPROM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */

uint16_t eeFooWordArray1[4] EEPROM;
...
</pre>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heisst eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<pre class="code">
...
uint8_t myByte;
uint8_t sreg;

sreg = SREG; // (1)
cli(); // (1)

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
...
SREG = sreg; // (1)
</pre>

Die mit (1) markierten Zeilen dienen hierbei dem (möglicherweise übertriebenen) Schutz vor Unterbrechnungen durch Interrupts.

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<pre class="code">
...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
...
</pre>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprueft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und mglw. noch mehr.

<pre class="code">
...
unit8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes aber der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnuetze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray[0],3);

/* dito mit etwas Absicherung betr. der Laenge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));

/* Datenlock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));
...
</pre>

"Nicht-Integer"-Datentypen wie z.B. Fliesskommazahlen lassen sich recht praktisch ueber eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<pre class="code">
...
float myFloat = 12.34;

union {
float r;
uint8_t n[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */
...
</pre>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<pre class="code">
...
typedef struct {
uint8_t label[8];
unin8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEPROM;

...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
...
}
...
</pre>

=== EEPROM-Speicherabbild in .eep-Datei ===

Eine besondere Funktion des avr-gcc ist, dass mit einem entsprechenden makefile aus den Initialisierungswerten der Variablen im Quellcode eine Datei erzeugt werden kann, die man auf den Controller programmieren kann (.eep-Datei). Damit können sehr elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Die Vorgehensweise wird aus dem WinAVR-Beispielmakefile ersichtlich. Siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles.

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Nicht alle neuen AVR Controller werden von avr-libc/eeprom.h untersützt (Stand Version 1.0.4). Insbesondere beim ATMega169 funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register) Etwas ältere Typen, oder zu den "etablierten" Controllern kompatible, bereiten jedoch hier keine Proleme. Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Der dort gezeigt Code kann direkt auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste").

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gcc-Toolchain" bietet dazu zwei Möglichkeiten:

;Inline-Assembler:
Die Assembleranweisungen werden in direkt in den C-Code integriert. Eine Quellcode-Datei enhält somit C- und Assembleranweisungen

;Assembler-Dateien:
Der Assembler-Codecode befindet sich in eigenen Quellcodedateien. Dieser werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z.B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben.

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen einer NOP-Anweisung. NOP steht für '''NO'''-O'''P'''eration. Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=warte)-Funktionen.

<pre class="code">
...
/* Verzoegern der weiteren Programmausfuehrung um
genau 3 Taktzyklen */
asm volatile ("nop"::);
asm volatile ("nop"::);
asm volatile ("nop"::);
...
</pre>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeindlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<pre class="code">
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i=0;i<1000;i++);

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i=0;i<1000;i++) asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j=0;j<1000;j++);
</pre>

Ein weiterer nützliche "Assembler-Einzeiler" ist der Auruf von sleep (''asm volatile ("sleep"::);''), da hierzu keine eigene Funktion in der avr-libc existiert.

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil des die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<pre class="code">
static inline void delayloop16(uint16_t count)
{
asm volatile ( "cp %A0,__zero_reg__ \n\t" \
"cpc %B0,__zero_reg__ \n\t" \
"breq L_Exit_%= \n\t" \
"L_LOOP_%=: \n\t" \
"sbiw %0,1 \n\t" \
"brne L_LOOP_%= \n\t" \
"L_Exit_%=: \n\t" \
: "=w" (count)
: "0" (count)
);
}
</pre>

* Jede Zeile wird mit '''\n\t''' abgeschlossen, alle Zeilen mit '''\''' verbunden.
* Sprung-Marken (labels) werden mit einm Prozentzeichen abgeschlossen, der Präprozessor (Assembler?) setzt an dieser Stelle eine laufende Nummer ein, die Doppelbezeichnungen bei mehrmaliger Verwendung somit verhindert.

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc.

* siehe auch: Dokumentation der avr-libc/Related Pages/Inline Asm
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

...TODO: Beispiele, Parameteruebergabe, globale Variablen für Datenaustausch

= TODO =

stdio.h, malloc() ???, Code-Optimierungen ("tricks"), "naked"-Functionen ??, IO-Register als Parameter/"Variablen" (volatile uint8_t *mybusport; mybusport=&PORTB; void sendbus(uint8_t *parm)...)

= C-Code und Bibliotheken für externe Baugrupen =
(TODO: sollte in avr-gcc verschoben werden)
[[Linksammlung#Avr]]

==LCD==
=== Text (character-mode) HD44870 ===
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray

=== Grafik-LCD ===
==== Nokia3310 ====
==== Nokia 6100 LCD ====
Das Nokia ist ein 132x132x4096 Farben Display das bei eBay ziemlich preiswert ersteigert werden kann.
[http://www.apetech.de/nokia6100.php Nokia 6100 LCD Library]
==== KS0108 ====
* Procyon avrlib (GPL)
* avrfreaks UP
* apetech.de
==Schnittstellen==
===I2C===
====Master====
[http://jump.to/fleury/ P. Fleurys I2C Master library]
====Slave====

===CAN===
* [http://www.atmel.com] Codesammlung zum AT90CAN128

=== DS18S20/1-Wire ===
* avrfreaks Projekt 59
* mikrocontroller.net/codesammlung (P. Dannegger)

=== UART ===
* Procyon avrlib (GPL)
* avrfreaks UP (viele viele)
* P. Fleury

== Speicherkarten/IDE/FAT ==
* avrfreaks UP (IDE/FAT read write)
== CRC ==
* avrfreaks-forum (O'Flynn)
* avr-hal (GPL)

AVR-GCC-Tutorial

2004-11-12T13:45:17Z

Oxygene: /* EEPROM */

[[Category:AVR]]

= Vorwort =

Dieses Tutorial soll Einsteigern helfen, mit der Programmiersprache '''C''' die Mikrocontroller der Atmel AVR-Reihe zu programmieren.


Die ursprüngliche Version stammt von Christian Schifferle, die meisten aktuellen Anpassungen von [[Benutzer:Mthomas]]. Viele der im Original-Dokument verwendeten Funktionen sind in
aktuellen Versionen des avr-gcc C-Compilers und der avr-libc zwar noch enthalten,
aber als überholt (''deprecated'') ausgewiesen. D.h. diese Funktionen sollten nicht mehr verwendet
werden und existieren in zukünftigen Versionen des Compilers/der Library nicht mehr
(z.B. sbi(), cbi(), outp(), inp()). Der Artikel wurde auf die neuen Funktionen/Methoden
angepasst.

In diesem Text wird häufig auf die Standardbibliothek für den avr-gcc-Compiler, die avr-libc, verwiesen. Die '''Dokumentation der avr-libc''' findet sich
[http://www.nongnu.org/avr-libc/user-manual/index.html hier]. Bei WinAVR gehört diese Dokumentation zum Lieferumfang und wird mitinstalliert.

= Benötigte Werkzeuge =

Um die Übungen in diesem Tutorial nachvollziehen zu können benötigen wir folgende Hard- und Software:

* Testboard für die Aufnahme eines AVR Controllers, der vom gcc Compiler untersützt wird (alle ATmegas und die meisten AT90). Dieses Testboard kann durchaus auch selber zusammen gelötet werden. So arbeite ich mit einem Testboard, welches ich mir auf einer Veroboard-Platine zusammen gestellt habe. Für die Versuche bzw. Übungen in diesem Tutorial habe ich jeweils einen AT90S2313 verwendet. Eine brauchbare Testplattform ist auch der [[AVR Butterfly]].
* AVRGCC-Compiler. Kostenlos erhältlich für nahezu alle Plattformen/Betriebssysteme. Für MS-Windows im Packet [[WinAVR]]; für Unix/Linx siehe auch Hinweise im Artikel [[AVR-GCC]].
* Programmiersoftware und Hardware z.B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], [[AVR-Studio]]).
* Nicht unbedingt erforderlich aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Abschnitt Exkurs: makefiles).

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.
* Die [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently Asked Questions = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.
* Das gcc-Forum auf [http://www.mikrocontroller.net www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.
* Das avr-gcc-Forum bei [http://www.avrfreaks.net avrfreaks] nach vergleichbaren Problemen absuchen.
* Das [http://www.avr1.org/pipermail/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.
* Nach Beispielcode suchen. Vor allem in der Academy von [http://www.avrfreaks.net AVRFREAKS] (anmelden).
* Google oder alltheweb befragen schadet nie.
* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal)
* einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei mgl. viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode, genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z.B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: [http://www.lugbz.org/documents/smart-questions_de.html "Wie man Fragen stellt"].

= Exkurs: makefiles =

Wenn man bisher gewohnt ist, mit integrierten Entwicklungsumgebung à la Visual-C Programme zu erstellen, wirkt das makefile-Konzept auf den ersten Blick etwas kryptisch. Nach kurzer Einarbeitung ist diese Vorgehensweise jedoch sehr praktisch. Diese Dateien (üblicher Name: 'Makefile' ohne Dateiendung) dienen der Ablaufsteuerung des Programms make, das auf allen Unix/Linux-Systemen installiert sein sollte, und in einer Fassung fuer MS-Windows auch in [[WinAVR]] (Unterverzeichnis utils/bin) enthalten ist.

Im Unterverzeichnis ''sample'' einer WinAVR-Installation findet man eine sehr brauchbare Vorlage, die sich einfach an das eigene Projekt anpassen lässt ([[Media:Makefile|lokale Kopie Stand Sept. 2004]]). Wahlweise kann man auch [http://www.sax.de/~joerg/mfile/ mfile] von Jörg Wunsch nutzen. mfile erzeugt ein makefile nach Einstellungen in einer grafischen Nutzeroberfläche, wird bei WinAVR mitinstalliert, ist aber als TCL/TK-Programm auf nahezu allen Platformen lauffähig.

''Die folgenden Ausführungen beziehen sich auf das WinAVR Beispiel-Makefile.''

Ist im Makefile alles richtig eingestellt genügt es, sich drei Parameter zu merken, die über die shell bzw. die Windows-Kommandozeile (cmd.exe/command.exe) als Parameter an "make" übergeben werden. Das Programm make sucht sich "automatisch" das makefile im aktuellen Arbeitsverzeichnis und führt die darin definierten Operationen für den entsprechenden Aufrufparameter durch.

{| border=1
| ''make all''
| Erstellt aus den in im makefile angegebenen Quellcodes eine ''hex''-Datei (und ggf. auch ''eep''-Datei).
|-
| ''make program''
| Überträgt die hex-Datei (und wahlweise auch die eep-Datei für den EEPROM) zum AVR.
|-
| ''make clean''
| löscht alle temporären Dateien, also auch die hex-Datei
|}

Diese Aufrufe können in die allermeisten Editoren in "Tool-Menüs" eingebunden werden. Dies erspart den Kontakt mit der Kommandozeile. (Bei WinAVR sind die Aufrufe bereits im Tools-Menü des mitgelieferten Editors Programmers-Notepad eingefügt.)

Üblicherweise sind folgende Daten im makefile anzupassen:
* Controllertyp
* Quellcode-Dateien (c-Dateien)
* Typ und Anschluss des Programmiergeräts

seltener sind folgende Einstellungen durchzuführen:
* Grad der Optimierung
* Methode zur Erzeugung der Debug-Symbole (Debug-Format)
* Assembler-Quellcode-Dateien (S-Dateien)

Die in den folgenden Unterabschnitten gezeigten makefile-Ausschnitte sind für ein Programm, das auf einem ATmega8 ausgeführt werden soll. Der Quellcode besteht aus den c-Dateien superprog.c (darin main()), uart.c, lcd.c und 1wire.c. Im Quellcodeverzeichnis befinden sich diese Dateien: superprog.c, uart.h, uart.c, lcd.h, lcd.c, 1wire.h, 1wire.c und das makefile (die angepasste Kopie des WinAVR-Beispiels).

Der Controller wird mittels [[AVRDUDE]] über ein [[STK200]]-Programmierdongle an der Schnittstelle lpt1 (bzw. /dev/lp0) programmiert. Im Quellcode sind auch Daten für die ''section .eeprom'' definiert (siehe Abschnitt Speicherzugriffe TODO: nach unten verlinken), diese sollen beim Programmieren gleich mit ins EEPROM geschrieben werden.

== Controllertyp setzen ==

Dazu wird die "make-Variable" MCU entsprechend dem Namen des verwendenten Controllers gesetzt. Ein Liste der von avr-gcc und der avr-libc untersützten Typen findet sich in der [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc].

<pre class="code">
# Kommentare in Makefiles beginnen mit einem Doppelkreuz
...

# ATmega8 at work
MCU = atmega8
# oder MCU = atmega16
# oder MCU = at90s8535
# oder ...
...
</pre>

== Quellcode-Dateien einstellen ==

Den Namen der Quellcodedatei welche die Funktion main enthält, wird hinter TARGET eingetragen. Dies jedoch ohne die Endung ''.c''.

<pre class="code">
...
TARGET = superprog
...
</pre>

Besteht das Projekt wie im Beispiel aus mehr als einer Quellcodedatei, sind die weiteren c-Dateien (nicht die Header-Dateien, vgl. [[Include-Files (C)]]) durch Leerzeichen getrennt bei SRC einzutragen. Die bei TARGET definierte Datei ist schon in der SRC-Liste enthalten. Diesen Eintrag nicht löschen!

<pre class="code">
...
SRC = $(TARGET).c uart.c lcd.c 1wire.c
...
</pre>

Alternativ kann man die Liste der Quellcodedateien auch mit dem Operator += erweitern.

<pre class="code">
SRC = $(TARGET).c uart.c 1wire.c
# lcd-Code fuer Controller xyz123 (auskommentiert)
# SRC += lcd_xyz.c
# lcd-Code fuer "Standard-Controller" (genutzt)
SRC += lcd.c
</pre>

== Programmiergerät einstellen ==

Die Vorlagen sind auf die Programmiersoftware [[AVRDUDE]] angepasst, jedoch lässt sich auch andere Programmiersoftware einbinden, sofern diese über Kommandozeile gesteuert werden kann (z.B. stk500.exe, uisp, sp12).

<pre class="code">
...
# Einstellung fuer STK500 an com1 (auskommentiert)
# AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
# AVRDUDE_PORT = com1 # programmer connected to serial device

# Einstellung fuer STK200-Dongle an lpt1
AVRDUDE_PROGRAMMER = stk200
AVRDUDE_PORT = lpt1
...
</pre>

Sollen Flash(=.hex) und EEPROM(=.eep) zusammen auf den Controller programmiert werden, ist das Kommentarzeichen vor AVRDUDE_WRITE_EEPROM zu löschen.

<pre class="code">
...
#Auskommentiert: EERPOM-Inhalt wird nicht mitgeschrieben
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

#Nich-auskommentiert EERPOM-Inhalt wird mitgeschrieben
AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
...
</pre>

== Anwendung ==

Die Eingabe von ''make all'' im Arbeitsverzeichnis mit dem makefile und den Quellcodedateien erzeugt (unter anderem) die Dateien superprog.hex und superprog.eep. Abhängigkeiten zwischen den einzelnen c-Dateien werden dabei automatisch berücksichtigt. Die ''superprog.hex'' und ''superprog.eep'' werden mit ''make program'' zum Controller übertragen. Mit ''make clean'' werden alle temporären Dateien gelöscht (="aufgeräumt").

== Sonstige Einstellungen ==

=== Optimierungsgrad ===

Der gcc-Compiler kennt verschiedene Stufen der Optimierung. Nur zu Testzwecken sollte die Optimierung ganz deaktiviert werden (''OPT = 0''). Die weiteren möglichen Optionen weisen den Compiler an, möglichst kompakten oder möglichst schnellen Code zu erzeugen. In den weitaus meisten Fällen ist ''OPT = s'' die optimale (sic) Einstellung, damit wird kompakter und oft auch der "schnellste" Maschienencode erzeugt.

=== Debug-Format ===

Unterstützt werden die Formate stabs und dwarf-2. Das Format wir hinter ''DEBUG ='' eingestellt. Siehe dazu Abschnitt ''Eingabedateien zur Simulation''.

=== Assembler-Dateien ===

Die im Projekt genutzten Assembler-Dateien werden hinter ASRC durch Leerzeichen getrennt aufgelistet. Assembler-Dateien haben immer die Endung .S (grosses S). Ist zum Beispiel der Assembler-Quellcode eines Software-UARTs in einer Datei softuart.S enthalten lautet die Zeile: ''ASRC = softuart.S''

== Eingabedateien zur Simulation in AVR-Studio ==

Mit älteren AVR-Studio-Versionen kann man nur auf Grundlage sogenannter ''coff''-Dateien simulieren. Neuere Versionen von AVR-Studio (ab 4.10.356) unterstützen zudem das modernere aber noch experimentelle dwarf-2-Format, das ab WinAVR 20040722 (avr-gcc 3.4.1/Binutils inkl. Atmel add-ons) "direkt" vom Compiler erzeugt wird.

; Vorgehensweise bei extcoff:
* im Makefile bei DEBUG: <pre class="code">DEBUG=stabs</pre>
* ''make extcoff'' (evtl. vorher ''make clean'')
* die erzeugte ''cof''-Datei (im Beispiel oben ''superprog.cof'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

; Vorgehensweise bei dwarf-2:
* im Makefile bei DEBUG: <pre class="code">DEBUG=dwarf-2</pre>
* ''make all'' (evtl. vorher ''make clean'')
* die erzeugte ''elf''-Datei (im Beispiel oben ''superprog.elf'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

Beim Simulieren scheinen oft "Variablen zu fehlen". Ursache dafür ist, dass der Compiler die "Variablen" direkt Registern zuweist. Dies kann vermieden werden, indem die Optimierung abgeschaltet wird (im makefile). Man simuliert dann jedoch ein vom optimierten Code stark abweichendes Programm. Das Abschalten der Optimierung wird nicht empfohlen.

Statt des Software-Simulators kann das AVR-Studio auch genutzt werden, um mit dem ATMEL JTAGICE, ein Nachbau davon (BootICE, Evertool o.ä.) oder dem ATMEL JTAGICE MKII "im System" zu debuggen. Dazu sind keine speziellen Einstellungen im makefile erforderlich. Debugging bzw. "In-System-Emulation" mit dem JTAGICE und JTAGICE MKII sind in der AVR-Studio Online-Hilfe beschrieben.

= Definition einiger Datentypen =

Für die Programmierung von Mikrocontrollern ist es sinnvoll, dass wir uns
vorerst einige Datentypen definieren, welche den Zugriff auf die verschiedenen
Komponenten des Controllers vereinfachen oder wenigstens das Programm lesbarer
machen können.

<pre class="code">
typedef unsigned char BYTE;
typedef unsigned short WORD;
</pre>

== BYTE ==

Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 255.

== WORD ==

Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 65535.

== DWORD ==

Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

== QWORD ==

Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

Bei allen vorgenannten Datentypen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z.B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich daher, die im folgenden Abschnitt beschriebenen standardisierten Datentypen zu nutzen und damit "Missverständnissen" vorzubeugen, die z.B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

= Standardisierte Integer(Ganzzahl)-Typen =

Standardisierte Datentypen werden in der Header-Datei inttypes.h definiert.
Will man diese Typen benutzen, bindet man die "Definitionsdatei" wie folgt ein:

<pre class="code">
#include <inttypes.h>
</pre>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<pre class="code">
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
</pre>

Ein Vierfach-Wort (64Bit) entspricht beim AVR ''uint64_t'', ein Doppel-[[Word|Wort]] (32bit) entspricht ''uint32_t'', ein Wort (16bit) entspricht ''uint16_t'' und ein [[Byte]] (8bit) entspricht ''uint8_t''.
Die Typen ohne vorangestelltes ''u'' können auch vorzeichenbehaftete Zahlen speichern. ''int8_t'' geht also von -128 bis 127, ''uint8_t'' dagegen geht von 0 bis 255.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Integer Types

== '''Bitfelder''' ==

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bit breit ist. 
Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in einer einzelnen Bytevariable zusammen fassen und (fast) wie
8 einzelne Variablen ansprechen können. 
Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente
definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<pre class="code">
struct {
unsigned char bStatus_1:1; // 1 Bit für bStatus_1
unsigned char bStatus_2:1; // 1 Bit für bStatus_2
unsigned char bNochNBit:1; // Und hier noch mal ein Bit
unsigned char b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</pre>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<pre class="code">
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</pre>

(mt Empfehlung: Bitfelder sparen zwar Platz, verschlechtern aber unter
Umständen die Les- und Wartbarkeit des Codes. Anfängern wird geraten,
ein "ganzes" ein Byte (uint8_t) zu nutzen auch wenn nur ein Bitwert gespeichert
werden soll.)

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten
Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher
Dinge erledigt werden können, welche nicht zeitkritisch sind. 
Wenn ein Interrupt ausgelöst wird so wird automatisch die zugeordnete
Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Allgemeiner Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heisst, das Programm kann die
Inhalte der Register auslesen und beschreiben. 
Einige Register haben spezielle Funktionen, andere wiederum könne für
allgemeine Zwecke (Speichern von Datenwerten) verwendet werden.

Einzelne Register sind bei allen AVR's vorhanden, andere wiederum nur bei
bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff
auf den UART notwendig sind selbstverständlich nur bei denjenigen Modellen
vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden
AVR-Typen definiert. 

Wenn im Makefile der MCU-Typ definiert ist, wird vom System automatisch die
zum Typen passende Definitionsdatei genutzt, sobald man im Code die allgemeine
"io.h" Header-Datei einbinden.

<pre class="code">
#include <avr/io.h>
</pre>

Ist im Makefile der MCU Type z.B. mit dem Inhalt atmega8 definiert,
wird beim einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit
den Register-Definitionen für den ATmega8 eingelesen.



== I/O-Register ==

Die I/O-Register haben einen besonderen Stellenwert bei den AVR Controllern.
Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. 
Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir mal
die 8-Bit Register.


=== Lesen eines I/O-Registers ===



Zum Lesen kann man auf I/O Register einfach wie auf eine
Variable zugreifen. Die spezielle Funktion inp() ist nicht mehr
notwendig und veraltet.

Beispiel:

<pre class="code">
#include <avr/io.h>
uint8_t foo;
...
int main(void)
{
foo=PINB; /* kopiert den Status der Eingabepins an PortB in die Variable foo */
...
}
</pre>

==== Lesen eines Bits ====

Die AVR-Bibliothek stellt auch Funktionen zur Abfrage eines einzelnen Bits
eines Registers zur Verfügung:

;bit_is_set (<Register>,<Bitnummer>) : Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 4 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>) : Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen bit_is_clear bzw. bit_is_set sind nicht unbedingt erfoderlich, man kann auch "einfachen" C-Syntax verwenden. Der universell verwendbar ist. ''bit_is_set'' entspricht dabei z.B. (Variable & (1<<Bitnummer)). Das Ergebnis ist <>0 wenn das Bit gesetzt und 0 wenn nicht gesetzt ist.

* siehe auch [[Bitmanipulation]]

=== Schreiben eines I/O-Registers ===



Zum Schreiben kann man I/O Register einfach wie eine
Variable setzen. Die spezielle Funktion outp() ist nicht mehr
notwendig, veraltet und sollte nicht mehr genutzt werden.

Beispiel:

<pre class="code">
#include <avr/io.h>
...
int main(void)
{
DDRA=0xff; /* Setzt das Richtungsregister des Ports A auf 0xff (alle Pins als Ausgang) */
PORTA=0x03; /* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low" */
...
}
</pre>

==== Schreiben eines Bits ====



Einzelne Bits setzt man "Standard-C-Konform" mittels logischen (bit-) Operationen.

mit dem Ausduck |=(1<<Bitnummer) wird ein Bit gesetzt, mit dem Ausdruck
&=~(1<<Bitnummer) wird ein Bit geloescht. Die Funktionen sbi und cbi sind
dazu nicht notwendig, veraltet und sollten nicht mehr genutzt werden.

Beispiel:
<pre class="code">
...
#define MEINBIT 2
...
PORTA |= (1<<MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1<<MEINBIT); /* loescht Bit 2 an PortA */
</pre>

* siehe auch:
** [[Bitmanipulation]]
** [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

=== Warten auf einen bestimmten Zustand ===

Es gibt in der Bibliothek sogar Funktionen, die Warten, bis ein bestimmter
Zustand auf einem Bit erreicht ist. 
Es ist allerdings normalerweise eine eher unschöne Programmiertechnik.

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das
definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits
gesetzt ist wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT 2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1<<WARTEBIT)) ) ;
</pre>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das
definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits
gelöscht ist wird die Funktion sofort wieder verlassen. 
Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT 4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// ungleich 0 ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
</pre>

Universeller und auch auf andere Platformen besser übertragbar ist die Verwendung von C-Standardoperationen.

siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]



= Zugriff auf Ports =

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind
jedem Port 3 Register zugeordnet:

{| border="1"
|-
| '''DDRx'''
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (anhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
| '''PORTx'''
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Wird ein Port als Eingang geschaltet, so können mit diesem Register
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|-
| '''PINx'''
| Eingangadresse für Port'''x'''.

Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der Portspins. Bit gesetzt (1) wenn Pin "high/an", Bit gelöscht (0) wenn Portpin "low/aus".
|}

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.


Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Wollen wir also beispielsweise Pin 0 bis 4 von Port B als Ausgänge
definieren so schreiben wir folgende Zeile:


<pre class="code">
#include <avr/io.h>
...
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F

DDRB=0x1F; /* direkte Zuweisung - unuebersichtlich */
/* mehr Tipparbeit aber uebersichtlicher: */
DDRB=(1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3)|(1<<DDB4);
...
</pre>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet.

=== Ganze Ports ===

Um einen ganzen Port als Ausgang zu definieren, kann der folgende Befehl
verwendet werden:

<pre class="code">
DDRB=0xff;
</pre>

Im Beispiel wird der Port B als Ganzes als Ausgang geschaltet.

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen
bzw. auszugeben.

== Ausgänge ==

Wir wollen nun einen als Ausgang definierten Pin auf Logisch 1 setzen. Dazu schreiben wir den entsprechenden Wert in das Portregister des entsprechenden Ports.

Mit dem Befehl

<pre class="code">
PORTB=0x04; /* besser PORTB=(1<<DDB2) */
</pre>

wird also der Ausgang an Pin 2 gesetzt (Beachte, dass die Bits immer ''von 0 an''
gezählt werden, das niederwertigste Bit ist also Bit 0 und nicht etwa Bit 1).

Man beachte bitte, dass bei der Zuweisung mittels '''='''  immer alle Pins gleichzeitig angegeben werden. Man sollte also zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfliessen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an PortB auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<pre class="code">
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<DDB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<DDB2)
</pre>


Die Funktionen cbi und sbi sind dazu nicht notwendig, veraltet und sollten
nicht mehr genutzt werden.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wird den Pegel über entsprechende Hardware (z.B. Optokoppler, Spannunsteiler "Levelshifter") anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unserer Controllers eine logische 1 (Vcc) oder eine logische 0 (Masse) anliegt.

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.



Wobei es hier sehr wichtig ist, zur Abfrage der Eingänge nicht etwa das Portregister '''PORTx''' zu verwenden, sondern die Porteingangsadresse '''PINx'''. Dies ist
ein oft gemachter Fehler!

Wollen wir also die aktuellen Signalzustände von Port D abfragen und in einer
Variable namens bPortD abspeichern so schreiben wir dazu folgende Befehlszeile:

<pre class="code">
#include <avr/io.h>
...
bPortD = PIND;
...
</pre>


=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen (''Active Low'' und ''Active High''):

{| border="1"
|-
| '''Active Low'''
| '''Active High'''
|-
| [[Image:Active Low.gif]]
| [[Image:Active High.gif]]
|-
| Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet.

Damit bei offenem Schalter der Controller kein undefiniertes Signal
bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein
sogenannter Pull-Up Widerstand geschaltet. Dieser dient dazu, den Pegel
bei geöffnetem Schalter auf logisch 1 zu ziehen. 
Der Widerstandswert des Pull-Up Widerstands ist an sich nicht kritisch. Es
muss jedoch beachtet werden, dass über den Widerstand ein Strom in den
Eingang fliesst, also sollte er nicht zu klein gewählt werden um den
Controller nicht zu zerstören. Wird er allerdings zu hoch gewählt ist
die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10
Kiloohm eingebürgert.

Die AVR's haben sogar an den meisten Pins softwaremässig zuschaltbare
interne Pull-Up Widerstände, welche wir natürlich auch verwenden
können.
| Hier wird der Kontakt zwischen die Versorgungsspannung und Masse geschaltet.

Damit bei offener Schalterstellung kein undefiniertes Signal am Controller
ansteht, wird zwischen den Eingangspin und die Masse ein Pull-Down
Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter
Schalterstellung auf logisch 0 zu halten.
|}

==== Pull-Up Widerstände aktivieren ====

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden
über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang'''
geschaltet ist. 

Wird der Wert des entsprechenden Portpins auf 1 gesetzt so ist
der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up
Widerstand nicht aktiv. 
Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand
verwenden, aber nicht beide zusammen.



<pre class="code">
#include <avr/io.h>
...
DDRD=0x00; /* alle Pins von Port D als Eingang */
PORTD=0xff: /* interer Pull-Up an allen Port-Pins aktivieren */
...
</pre>

Im Beispiel wird der gesamte Port D als Eingang geschaltet und alle Pull-Up
Widerstände aktiviert.

===== Tastenentprellung =====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von
Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim
Schliessen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern
mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes. 
Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein
solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen
als mehrfache Impulse gezählt wird. 
Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen
werden.

ToDo Bsp Quellcode

== Analog ==

Leider können wir mit unseren Controllern keine analogen Werte direkt
ausgeben oder einlesen. Dazu müssen wir Umwege gehen, doch dies wird in einem späteren
Kapitel behandelt.

=== 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1) ===

Einige der Portregister in den AVR-Controllern sind 16 Bit breit, Man spricht
dann von einem '''Wort'''.


Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<pre class="code">
#include <avr/io.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8

= Der UART, Teil 1 =

Wir werden in zukünftigen Übungen in die Situation kommen, dass wir
Informationen vom Controller auswerten bzw. anzeigen müssen wobei es vielleicht
dann nicht mehr reicht, ein paar Leuchtdioden anzusteuern. 
Somit brauchen wir eine Verbindung vom AVR zu unserem PC, und dies am besten
über die serielle Schnittstelle.

== Allgemeines zum UART ==

Einige AVR-Controller haben einen vollduplexfähigen UART ('''U'''niversal
'''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut.
Dies ist eine wirklich feine Sache, haben wir doch damit schon das nötige
Werkzeug, um mit anderen Geräten, welche über eine serielle Schnittstelle
verfügen (insbesondere mit unserem PC), zu kommunizieren.

Übrigens: Vollduplex heisst nichts anderes, als dass der Baustein gleichzeitig
senden und empfangen kann.

Neuere AVRs (ATmega) verfügen über einen oder zwei U'''S'''ART(s), dieser unterschiedet sich vom UART häuptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

Der UART wird über vier separate Register angesprochen. USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurations/Datenregister. Das Datenblatt gibt darüber Auskunft. Die Folgende Tabelle gibt nur die Register für die (veralteten) UARTs wieder.

{| border="1"
|-
| '''UCR   '''
| '''U'''ART '''C'''ontrol '''R'''egister. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXCIE'''
| align="center" | '''TXCIE'''
| align="center" | '''UDRIE'''
| align="center" | '''RXEN'''
| align="center" | '''TXEN'''
| align="center" | '''CHR9'''
| align="center" | '''RXB8'''
| align="center" | '''TXB8'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''CHR9''' (9 Bit Characters)
:Wenn dieses Bit gesetzt ist, können 9 Bit lange Zeichen übertragen und empfangen werden. Das 9. Bit kann bei Bedarf als zusätzliches Stopbit oder als Paritätsbit verwendet werden. Man spricht dann von einem 11-Bit Zeichenrahmen:
:1 Startbit + 8 Datenbits + 1 Stopbit + 1 Paritätsbit = 11 Bits

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.

|-
| '''USR   '''
| '''U'''ART '''S'''tatus '''R'''egister. 
Hier teilt uns der UART mit, was er gerade so macht.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXC'''
| align="center" | '''TXC'''
| align="center" | '''UDRE'''
| align="center" | '''FE'''
| align="center" | '''OR'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt bevor ein weiteres Zeichen komplett empfangen wurde wird eine Überlauf-Fehlersituation eintreffen. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, wenn die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit wird vom AVR gesetzt, wenn ein Zeichen vom Sendedatenregister in das Send-Schieberegister übernommen wurde und der UART nun wieder bereit ist, ein neues Zeichen zum Senden aufzunehmen.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''OR''' ('''O'''ver'''R'''un) 
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne
kommunizieren möchten. Der Wert, der in dieses Register geschrieben
werden muss, errechnet sich nach folgender Formel:

<math>
\begin{matrix}
UBBR = \frac{Taktfrequenz}{Baudrate * 16} - 1
\end{matrix}
</math>

Es sind Baudraten bis zu 115200 Baud und höher möglich.
|}

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (LOW) und 5V (HIGH). Die
Schnittstellenspezifikation für RS232 definiert jedoch -3V ... -12V (LOW) und
+3 ... +12V (HIGH). Zudem muss der Signalaustausch zwischen AVR und
Partnergerät invertiert werden. Für die Anpassung der Pegel und das
Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste
davon ist wohl der MAX232. Allerdings kostet der auch wieder Geld und benötigt
zusätzlich immerhin 4 externe Elkos.

Die in den PC eingebauten Schnittstellen vertragen ohne Klagen auch den
TTL-Pegel vom AVR. Allerdings müssen wir immer noch die Signale invertieren. Im
einfachtesn Fall verwenden wir dazu jeweils einen einfachen NPN-Transistor und 2
Widerstände. Näheres dazu erfahrt ihr in den folgenden Übungen.

Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z.B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfielt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Senden mit dem UART ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. 
Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach
gewünschter Funktionsweise die
benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister. 
Da wir vorerst nur senden möchten und (noch) keine Interrupts auswerten wollen,
gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das
'''Transmitter Enable''' Bit setzen müssen:


<pre class="code">
UCR |= (1<<TXEN);
</pre>

Der Atmega16 hat mehrere Konfigurationsregister für USART und erfordert eine etwas andere Konfiguration

<pre class="code">
UCSRB |= (1<<TXEN); //UART TX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1
</pre>

Nun müssen wir noch die Baudrate festlegen. Gemäß unserer Formel brauchen
wir dazu die Taktfrequenz des angeschlossenen Oszillators bzw. Quarz in die
Formel einzufügen und das Resultat der Berechnung in das Baudratenregister des
UART einzuschreiben:

<pre class="code">
/* UART-Init beim AT90S2313 */
#define F_CPU 4000000; // Zum Beispiel 4Mhz-Quarz
#define UART_BAUD_RATE 9600 // Wir versuchen mal mit 9600 Baud
UBRR = F_CPU / (UART_BAUD_RATE * 16L) - 1;
</pre>

Wieder für den Mega16 mit einem 16bit-Register eine andere Programmierung

<pre class="code">
/* USART-Init beim ATmegaXX */
#define F_OSC 3686400 /* Oszillator-Frequenz in Hz */
#define UART_BAUD_RATE 9600
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)

UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

/* alternativ bei der avr-libc "direkt 16bit" : */
UBRR=UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);
</pre>

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben.

<pre class="code">
while (USR & (1<<UDRE)); /* warten bis Senden moeglich */
UDR = 'x'; // Schreibt das Zeichen x auf die Schnittstelle
</pre>

=== Schreiben einer Zeichenkette (String) ===

Es ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

Zu diesem Zweck können wir uns für's Erste eine einfache Funktion basteln:

<pre class="code">
void SendeString (char *szBuf)
{
while (*szBuf) {
loop_until_bit_is_set (USR, UDRE); /* warten bis Senden moeglich */
UDR=*szBuf;
szBuf++;
}
}
</pre>

Warteschleifen sind insofern etwas kritisch, da während des Sendens eines
Strings nicht mehr auf andere Ereignisse reagieren werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. emfangenen Zeichen/Bytes zwischengespeichert und mittels Interruptroutinen an den U(S)ART weitergebgen bzw. ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

* siehe auch: Weiterführende Informationen inkl. Beispielen für die Nutzung von stdio-Funktionen (prinf etc.) im [[AVR-Tutorial - UART]].
* [http://homepage.sunrise.ch/mysunrise/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc

= Analoge Ein- und Ausgabe =

Leider können wir mit unseren Controllern keine analogen Werte direkt
verarbeiten. Dazu bedarf es jeweils einer Umwandlung des analogen Signals in
einen digitalen Zahlenwert. Je nachdem, ob wir Daten einlesen oder ausgeben
wollen reden wir dabei von '''ADC''' oder '''DAC'''.

== ADC (Analog Digital Converter) ==

Der '''ADC''' wandelt analoge Signale in digitale Werte um, welche vom Controller
interpretiert werden können. Einige AVR-Typen haben bereits einen oder mehrere
solcher '''ADC''''s eingebaut, bei den kleineren AVR's müssen wir uns anders aus der
Affäre ziehen. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst
werden kann, wird durch die Auflösung des '''ADC''' in Anzahl Bits angegeben, man
hört bzw. liest jeweils von 8-Bit '''ADC''' oder 10-Bit ''' ADC''' oder noch höher. 
Ein '''ADC''' mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit
von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten
eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

<div align="center"><center>

{| border="1"
|-
| align="center" | '''Eingangsspannung am ADC'''
| align="center" | '''Entsprechender Messwert'''
|-
| align="center" | 0...<0.625V
| align="center" | 0
|-
| align="center" | 0.625...<1.25V
| align="center" | 1
|-
| align="center" | 1.25...<1.875V
| align="center" | 2
|-
| align="center" | 1.875...<2.5V
| align="center" | 3
|-
| align="center" | 2.5...<3.125V
| align="center" | 4
|-
| align="center" | 3.125...<3.75V
| align="center" | 5
|-
| align="center" | 3.75...<4.375V
| align="center" | 6
|-
| align="center" | 4.375...5V
| align="center" | 7
|}

</center>
</div>

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des '''
ADC''' ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Messen eines Widerstandes ===

Wir wollen hier einmal die wohl einfachste Methode zur Erfassung eines
analogen Wertes realisieren und zwar das Messen eines veränderlichen
Widerstandes wie z.B. eines Potentiometers.

Man stelle sich vor, wir schalten einen Kondensator in Reihe zu einem
Widerstand zwischen die Versorgungsspannung und Masse und dazwischen nehmen wir
das Signal ab und führen es auf einen der Pins an unserem Controller, genau so
wie es in folgender Grafik dargestellt ist.

[[Image:Poti.gif]]

Wenn wir nun den Pin des AVR als Ausgang schalten und auf
Logisch 1 (HIGH) legen, dann liegt an beiden Platten des Kondensators ''' Vcc''' an und
dieser wird entladen (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen). 
Nachdem nun der Kondensator genügend entladen ist schalten wir einfach den Pin
als Eingang wodurch dieser hochohmig wird. Der Kondensator lädt sich jetzt
über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und
derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti
unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), dann schaltet der
Eingang von HIGH auf LOW um. Wenn wir nun messen (zählen), wie lange es dauert,
bis der Kondensator so weit geladen ist, dann haben wir einen ungefähren Wert
der Potentiometerstellung. 
Der 220 Ohm Widerstand dient dem Schutz des Controllers. Wenn nämlich sonst die
Potentiometerstellung auf Maximum steht (0 Ohm), dann würde in den Eingang des
Controllers ein viel zu hoher Strom fliessen und der AVR würde in Rauch
aufgehen.

Dies ist meines Wissens die einzige Schaltung zur Erfassung von
Analogwerten, welche mit nur einem einzigen Pin auskommt. 
Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine
Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B:
0...100 % oder so) umzurechnen.

Wer Lust hat, sich selber mal an ein solches Programm
heranzuwagen, der sollte das jetzt tun. Für diejenigen, die es gern schnell
mögen, hier das Beispielprogramm, welches den UART-Printf aus den
vorangegangenen Kapiteln benötigt, inkl. Makefile:

{| border="0"
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Poti.c Poti.c ]
| Hauptprogramm.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.c Pot.c]
| Separate Routine zur Ermittlung des Messwertes.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.h Pot.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c UartPrintF.c]
| Für die Debugausgabe auf den UART.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h UartPrintF.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile Makefile]
| Makefile.
|}

Nachdem das Programm auf den AVR geladen wurde, muss dieser
kalibriert werden. Dazu wird der Kalibrierungsschalter geschlossen und das Poti
einige Male zwischen minimaler und maximaler Stellung hin und her gedreht. Dabei
werden die jeweiligen Maximalwerte bestimmt. Wenn der Kalibrierschalter wieder
geöffnet wird werden die Kalibrierungsdaten in's EEPROM des AVR geschrieben,
damit die Prozedur nicht nach jedem Reset wiederholt werden muss.

Auf Pin 4 habe ich noch ein Triggersignal gelegt, welches auf
HIGH geht wenn die Messung beginnt und auf LOW, wenn der Messvorgang beendet
wird. Mit Hilfe dieses Signals kann der Vorgang wunderschön auf einem
Oszillographen dargestellt werden.

=== ADC über Komparator ===

Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

[[Image:ADC ueber Komparator.gif]]

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert. 
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

=== Der ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem '''ADC-Wandler''' zurückgreifen. Wir wollen hier einmal den AT90S8535 besprechen, welcher über 8 ADC-Kanäle verfügt. (TODO: nur ein Wandler, Mulitiplexbetrieb, nur eine Pin zur gleichen Zeit)

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung.

Verfügt der AVR über eine interne Referenzspannung (Datenblatt typisch 2,56 oder 1,1V je nach AVR), bleibt der ''Anschluss AREF'' unbeschaltet und man stellt die ADC-Register so ein, dass die interne Referenzspannung als "AREF" genutzt wird. Ansonsten ist eine externe Referenzspannung von maximal '''Vcc''' an den Abschluss '''AREF''' anzulegen. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden.

==== Einfache Wandlung (Single Conversion) ====

In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestossen für jeweils eine Messung.

==== Frei laufend (Free Running) ====

In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register, welche hier aufgelistet werden.

{| border="1"
|-
| '''ADCSR   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ADEN'''
| align="center" | '''ADSC'''
| align="center" | '''ADFR'''
| align="center" | '''ADIF'''
| align="center" | '''ADIE'''
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt, ist können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''Fr'''ee Running Select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Eine logische 1 aktiviert den frei laufenden Modus. Der ''' ADC''' misst nun ständig den ausgewählten Kanal und schreibt den gemessenen Wert in das '''ADC Data Register'''.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, wenn eine Umwandlung erfolgt und das '''ADC Data Register''' aktualisiert ist.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird (So steht es in der AVR-Dokumentation).

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200kHz}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50kHz}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.
<dl><dd>
{| style="" border="1"
|-
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
| align="center" | '''Teilungsfaktor'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 2
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 2
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 4
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 8
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 16
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 32
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 64
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 128
|}
</dd></dl>
|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<pre class="code">
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
C-Operatorprioritaet sichergestellt)
</pre>

oder

<pre class="code">
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</pre>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''MUX2'''
| align="center" | '''MUX1'''
| align="center" | '''MUX0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''MUX2...MUX0'''
:Mit diesem 3 Bits wird der zu messende Kanal bestimmt. Es wird einfach die entsprechende Pinnummer des Ports eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Meine Empfehlung ist deswegen klar diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Aktivieren des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register
setzen. Im gleichen Schritt legen wir auch gleich die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls mit Spannungsteiler konditionieren. Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1024 für V_ref-Volt.

<pre class="code">

#define CHANNELOFFSET 4

uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result;

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler setzen auf 8 (1)
ADCSRA |= (1<<ADEN); // ADC aktivieren (1)

ADMUX = CHANNELOFFSET+channel; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)

result = 0;

/* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
for(i=0;i<4;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)
result += ADC; // Wandlungsergebnisse aufaddieren
}

ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)

result >>= 2; // Summe durch vier teilen = arithm. Mittelwert

return result;
}
</pre>

Im Beispiel wird bei jedem Aufruf der ADC aktiviert und nach der Wandlung wieder abgeschaltet, das spart Strom. Will man dies nicht, verschiebt man die mit (1) gekenntzeichneten Zeilen in eine Funktion adc_init() o.ä. und löscht die mit (2) markierten Zeilen.



== DAC (Digital Analog Converter) ==

Mit Hilfe eines ''' DAC''' können wir nun auch Analogsignale ausgeben. Es gibt hier
mehrere Verfahren. Wenn wir beim ''' ADC''' die Möglichkeit haben, mit externen
Komponenten zu operieren, müssen wir bei der '''DAC'''-Wandlung mit dem auskommen, was
der Controller selber zu bieten hat.

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie ''' PWM''' eigentlich funktioniert.

Wie wir alle wissen ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber
wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. 
Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen
HIGH und LOW umschalten? 
Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen geometrischen Mittelwert, der je nach Pulsbreite
kleiner oder grösser ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein
RC-Glied filtern dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVR's können wir direkt '''PWM'''-Signale erzeugen. Dazu
dient der 16-Bit Zähler, welcher im sogenannten '''PWM'''-Modus betrieben werden
kann.

Hinweis:
:In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist allerdings bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt.

Um den '''PWM'''-Modus zu aktivieren müssen im Timer/Counter1 Control
Register A '''TCCR1A''' die Pulsweiten-Modulatorbits '''PWM10''' bzw. '''PWM11''' entsprechend
nachfolgender Tabelle gesetzt werden:

{| border="1"
|-
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| PWM-Modus des Timers ist nicht aktiv.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM.
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben. Die
Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| border="1"
|-
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden heisst dann:

<pre class="code">
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</pre>

Damit der Timer/Counter überhaupt läuft müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorzähler) einstellen, und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| border="1"
|-
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<pre class="code">
TCCR1B = (1<<CS12) | (1<<CS10);
</pre>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<pre class="code">
OCR1A = xxx;
</pre>

Die folgende Grafik soll den Zusammenhang zwischen dem
Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren.

= Die Timer/Counter des AVR =

Die heutigen Mikrocontroller und insbesondere die RISC-AVR's sind für viele
Steuerungsaufgaben natürlich viel zu schnell. Wenn wir beispielsweise eine LED
oder Lampe blinken lassen wollen, können wir selbstverständlich nicht die
CPU-Frequenz verwenden da ja dann nichts mehr vom Blinken zu bemerken wäre.

Wir brauchen also eine Möglichkeit, die Taktfrequenz auf vernünftige Werte
herunter zu brechen. Selbstverständlich sollte die resultierende Frequenz dann
auch noch einigermassen genau und stabil sein.

Hier kommen die im AVR vorhandenen Timer/Counter zum Einsatz.

Ein anderes Anwendungsgebiet ist die Zählung von Signalen, welche über
einen I/O-Pin zugeführt werden können.

Die folgenden Ausführungen beziehen sich auch den AT90S2313. Für andere
Modelltypen müsst ihr euch die allenfalls notwendigen Anpassungen aus den
Datenblättern der entsprechenden Controller herauslesen.

Wir unterscheiden grundsätzlich zwischen 8-Bit Timern, welche eine
Auflösung von 256 aufweisen und 16-Bit Timern mit (logischerweise) einer
Auflösung von 65536.

Als Eingangstakt für die Timer/Counter kann entweder die CPU-Taktfrequenz,
der Vorteiler-Ausgang oder ein an einen I/O-Pin angelegtes Signal verwendet
werden. Wenn ein externes Signal verwendet wird, so darf dessen Frequenz nicht
höher sein als die Hälfte des CPU-Taktes.

=== Der Vorzähler (Prescaler) ===

Beide Timer/Counter werden im Timerbetrieb über den gleichen Vorzähler
versorgt.

Der Vorzähler dient dazu, den CPU-Takt vorerst mal runter zu brechen auf eine
wählbare Teilung. Die so geteilte Frequenz wird den Eingängen der Timer
zugeführt.

Wenn wir mit einer einem CPU-Takt von 4 MHz arbeiten und den Vorteiler auf 1024
einstellen wird also der Timer mit einer Frequenz von 4 MHz / 1024, also mit ca.
4 kHz versorgt. Wenn also der Timer läuft, so wird das Daten- bzw.
Zählregister mit dieser Frequenz inkrementiert.

== 8-Bit Timer/Counter ==

Alle AVR-Modelle weisen mindestens einen, teilweise sogar zwei, 8-Bit Timer
auf.

Der 8-Bit Timer wird über folgende Register angesprochen:

{| border="1"
|-
| '''TCCR0'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
Timer '''0'''

In diesem Register stellen wir ein, wie wir den Timer/Counter verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CS02'''
| align="center" | '''CS01'''
| align="center" | '''CS00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''CS02, CS01, CS00''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS02
| align="center" | CS01
| align="center" | CS00
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin '''TO''', fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin '''TO''', steigende Flanke
|}
</dd>
</dl>
:Wenn als Quelle der externe Pin '''TO''' verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin '''TO''' als Ausgang geschaltet ist.

|-
| '''TCNT0'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer '''0''' 
Dieses ist als 8-Bit Aufwärtszähler mit Schreib- und Lesezugriff
realisiert. Wenn der Zähler den Wert 255 erreicht hat beginnt er beim
nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}
|}

Um nun also den Timer0 in Betrieb zu setzen und ihn mit einer Frequenz von 1/1024-tel des CPU-Taktes zählen zu lassen, schreiben wir die folgende Befehlszeile:

<pre class="code">
TCCR0 = (1<<CS00)|(1<<CS02);
</pre>

Der Zähler zählt nun aufwärts bis 255, um dann wieder bei 0 zu beginnen. Der aktuelle Zählerstand steht in TCNT0. Bei jedem Überlauf von 255 auf 0 wird das Timer Overflow Flag '''TOV0''' im Timer Interrupt Flag '''TIFR'''-Register gesetzt und, falls so konfiguriert, ein entsprechender Timer-Overflow-Interrupt ausgelöst.

== 16-Bit Timer/Counter ==

Viele AVR-Modelle besitzen ausser den 8-Bit Timers auch einen oder sogar zwei
(einige ATmega-Modelle) 16-Bit Timer.

Die 16-Bit Timer/Counter sind wesentlich komplexer aufgebaut als die 8-Bit
Timer/Counter, bieten dafür aber auch viel mehr Möglichkeiten, als da sind:

* Die [[PWM]]-Betriebsart Erzeugung eines pulsweitenmodulierten Ausgangssignals.
* Vergleichswert-Überprüfung mit Erzeugung eines Ausgangssignals (Output Compare Match).
* Einfangen eines Eingangssignals mit Speicherung des aktuellen Zählerwertes (Input Capturing), mit zuschaltbarer Rauschunterdrückung (Noise Filtering).

Folgende Register sind dem Timer/Counter 1 zugeordnet:

{| border="1"
|-
| '''TCCR1A'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''A''' Timer '''1''' 
In diesem und dem folgenden Register stellen wir ein, wie wir den Timer/Counter verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''COM1A1''', '''COM1A0''' ('''Co'''mpare '''M'''atch Control Bits)
:Diese 2 Bits bestimmen die Aktion, welche am Output-Pin '''OC1''' ausgeführt werden soll, wenn der Wert des Datenregisters des Timer/Counter 1 den Wert des Vergleichsregisters erreicht, also ein so genannter Compare Match auftritt.
:Der Pin '''OC1''' ('''PB3''' beim 2313) muss mit dem Datenrichtungsregister als Ausgang konfiguriert werden.

<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Das Signal am Pin '''OC1''' wird invertiert (Toggle).
|-
| align="center" | 1
| align="center" | 0
| Der Output Pin '''OC1''' wird auf 0 gesetzt.
|-
| align="center" | 1
| align="center" | 1
| Der Output Pin '''OC1''' wird auf 1 gesetzt.
|}
</dd></dl>
:In der PWM-Betriebsart haben diese Bits eine andere Funktion.
<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 1
| align="center" | 0
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 0 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 1 gesetzt.

Man nennt dies ''nicht invertierende PWM''.
|-
| align="center" | 1
| align="center" | 1
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 1 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 0 gesetzt.

Man nennt dies ''invertierende PWM''.
|}
</dd></dl>

'''PWM11''', '''PWM10''' ('''PWM''' Mode Select Bits)
:Mit diesen 2 Bits wird die PWM-Betriebsart des Timer/Counter 1 gesteuert.
<dl><dd>
{| border="1"
|-
| align="center" | PWM11
| align="center" | PWM10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Die PWM-Betriebsart ist nicht aktiviert. Timer/Counter 1 arbeitet als normaler Timer bzw. Zähler.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM Betriebsart aktivieren.
|}
</dd></dl>
|-
| '''TCCR1B'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''B''' Timer '''1'''

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ICNC1'''
| align="center" | '''ICES1'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CTC1'''
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''ICNC1''' ('''I'''nput '''C'''apture '''N'''oise '''C'''anceler (4 CKs) Timer/Counter 1
:oder auf Deutsch Rauschunterdrückung des Eingangssignals.
:Wenn dieses Bit gesetzt ist und mit dem Input Capture Signal gearbeitet wird so werden nach der Triggerung des Signals mit der entsprechenden Flanke (steigend oder fallend) am Input Capture Pin '''ICP''' jeweils 4 Messungen mit der CPU-Frequenz des Eingangssignals abgefragt. Nur dann, wenn alle 4 Messungen den gleichen Zustand aufweisen gilt das Signal als erkannt.

'''ICES1''' ('''I'''nput '''C'''apture '''E'''dge '''S'''elect Timer/Counter '''1''')
:Mit diesem Bit wird bestimmt, ob die steigende ('''ICES1'''=1) oder fallende ('''ICES1'''=0) Flanke zur Auswertung des Input Capture Signals an Pin '''ICP''' heran gezogen wird.

'''CTC1''' ('''C'''lear '''T'''imer/'''C'''ounter on Compare Match Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, so wird nach einer Übereinstimmung des Datenregisters '''TCNT1H'''/'''TCNT1L''' mit dem Vergleichswert in '''OCR1H'''/'''OCR1L''' das Datenregister '''TCNT1H'''/'''TCNT1L''' auf 0 gesetzt.
:Da die Übereinstimmung im Takt nach dem Vergleich behandelt wird, ergibt sich je nach eingestelltem Vorzähler ein etwas anderes Zählverhalten:
:Wenn der Vorteiler auf 1 gestellt ist und C der jeweilige Zählerwert ist, dann nimmt das Datenregister, im CPU-Takt betrachtet, folgende Werte an:
:... | C-2 | C-1 | C | 0 | 1 |...
:Wenn der Vorteiler z.B. auf 8 eingestellt ist, dann nimmt das Datenregister folgende Werte an:
:... | C-2, C-2, C-2, C-2, C-2, C-2, C-2, C-2 | C-1, C-1, C-1, C-1, C-1, C-1, C-1, C-1 | C, 0, 0, 0, 0, 0, 0, 0 |...
:In der PWM-Betriebsart hat dieses Bit keine Funktion.

'''CS12''', '''CS11''', '''CS10''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS12
| align="center" | CS11
| align="center" | CS10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin TO, fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin T0, steigende Flanke
|}
</dd></dl>
:Wenn als Quelle der externe Pin T0 verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin T0 als Ausgang geschaltet ist.
|-
| '''TCNT1H''' '''TCNT1L'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer/Counter '''1'''
Dieses ist als 16-Bit Aufwärtszähler mit Schreib- und Lesezugriff realisiert. Wenn der Zähler den Wert 65535 erreicht hat, beginnt er beim nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''TCNT1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''TCNT1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

In der PWM-Betriebsart wird das Register als Auf/Ab-Zähler verwendet, d.h. der Wert steigt zuerst von 0 bis er den Überlauf von 65535 auf 0 erreicht hat. Dann zählt das Register rückwärts wiederum bis 0.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.

Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''OCR1H''' '''OCR1L'''
| Timer/Counter '''O'''utput '''C'''ompare '''R'''egister Timer/Counter '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''OCR1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''OCR1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Der Wert im Output Compare Register wird ständig mit dem aktuellen Wert im Datenregister TCNT1H/TCNT1L verglichen. Stimmen die beiden Werte überein, so wird ein sogenannter Output Compare Match ausgelöst. Die entsprechenden Aktionen werden über die Timer/Counter 1 Control und Status Register eingestellt.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''ICR1H''' '''ICR1L'''
| Timer/Counter '''I'''nput '''C'''apture '''R'''egister Timer/Counter '''1''' 
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''ICR1''''''H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''ICR1''''''L'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Das Input Capture Register ist ein 16-Bit Register mit Lesezugriff. Es kann nicht beschrieben werden.

Wenn am Input Capture Pin '''ICP''' die gemäß Einstellungen im '''TCCR1B''' definierte Flanke erkannt wird, so wird der aktuelle Inhalt des Datenregisters '''TCNT1H'''/'''TCNT1L''' sofort in dieses Register kopiert und das Input Capture Flag '''ICF1''' im Timer Interrupt Flag Register '''TIFR''' gesetzt.

Wie bereits oben erwähnt, müssen vor dem Zugriff auf dieses Register alle Interrupts gesperrt werden. Zudem müssen Low- und Highbyte des Registers in der richtigen Reihenfolge bearbeitet werden:

{| border="0"
|-
| Lesen:
| '''ICR1L''' -> '''ICR1H'''
|-
| Schreiben:
| '''ICR1H''' -> '''ICR1L'''
|}
|}

=== Die PWM-Betriebsart ===

Wenn der Timer/Counter 1 in der PWM-Betriebsart betrieben wird, so bilden das Datenregister '''TCNT1H'''/'''TCNT1L''' und das Vergleichsregister '''OCR1H'''/'''OCR1L''' einen 8-, 9- oder 10-Bit, frei laufenden PWM-Modulator, welcher als PWM-Signal am '''OC1'''-Pin ('''PB3''' beim 2313) abgegriffen werden kann. Das Datenregister '''TCNT1H'''/'''TCNT1L''' wird dabei als Auf-/Ab-Zähler betrieben, welcher von 0 an aufwärts zählt bis zur Obergrenze und danach wieder zurück auf 0.
Die Obergrenze ergibt sich daraus, ob 8-, 9- oder 10-Bit PWM verwendet wird, und zwar gemäss folgender Tabelle:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Wenn nun der Zählerwert im Datenregister den in '''OCR1H'''/'''OCR1L''' gespeicherten Wert erreicht, wird der Ausgabepin '''OC1''' gesetzt bzw. gelöscht, je nach Einstellung von '''COM1A1''' und '''COM1A0''' im '''TCCR1A'''-Register.

Ich habe versucht, die entsprechenden Signale in der folgenden Grafik zusammenzufassen

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

=== Vergleichswert-Überprüfung ===

Hier wird in ein spezielles Vergleichswertregister ('''OCR1H'''/'''OCR1L''') ein Wert eingeschrieben, welcher ständig mit dem aktuellen Zählerwert verglichen wird.
Erreicht der Zähler den in diesem Register eingetragenen Wert, so kann ein Signal (0 oder 1) am Pin '''OC1''' erzeugt und/oder ein Interrupt ausgelöst werden.

=== Einfangen eines Eingangssignals (Input Capturing) ===

Bei dieser Betriebsart wird an den Input Capturing Pin (ICP) des Controllers eine Signalquelle angeschlossen.
Nun kann je nach Konfiguration entweder ein Signalwechsel von 0 nach 1 (steigende Flanke) oder von 1 nach 0 (fallende Flanke) erkannt werden und der zu diesem Zeitpunkt aktuelle Zählerstand in ein spezielles Register abgelegt werden. Gleichzeitig kann auch ein entsprechender Interrupt ausgelöst werden.
Wenn die Signalquelle ein starkes Rauschen beinhaltet, kann die Rauschunterdrückung eingeschaltet werden. Dann wird beim Erkennen der konfigurierten Flanke über 4 Taktzyklen das Signal überwacht und nur dann, wenn alle 4 Messungen gleich sind, wird die entsprechende Aktion ausgelöst.

== Gemeinsame Register ==

Verschiedene Register beinhalten Zustände und Einstellungen, welche sowohl
für den 8-Bit, als auch für den 16-Bit Timer/Counter in ein und demselben
Register zu finden sind.

{| border="1"
|-
| '''TIMSK'''
| '''T'''imer/Counter '''I'''nterrupt '''M'''a'''sk'''
Register

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOIE1'''
| align="center" | '''OCIE1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''TICIE'''
| align="center" | '''-'''
| align="center" | '''TOIE0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOIE1''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 1 ein Timer Overflow 1 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''OCIE1A''' ('''O'''utput '''C'''ompare Match '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Beim Timer/Counter 1 kann zusätzlich zum Überlauf ein Vergleichswert definiert werden.

:Wenn dieses Bit gesetzt ist, wird beim Erreichen des Vergleichswertes ein Compare Match Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TICIE''' ('''T'''imer/Counter '''I'''nput '''C'''apture '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein Capture Event Interrupt ausgelöst, wenn ein entsprechendes Signalereignis am Pin PD6(ICP) auftritt. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein, wenn auch ein entsprechender Interrupt ausgelöst werden soll.

'''TOIE0''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''0''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 0 ein Timer Overflow 0 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

|-
| '''TIFR'''
| '''T'''imer/Counter '''I'''nterrupt '''F'''lag '''R'''egister

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOV1'''
| align="center" | '''OCF1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''ICF1'''
| align="center" | '''-'''
| align="center" | '''TOV0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOV1''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''1''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 1 ein Überlauf des Datenregisters stattfindet.

:In der PWM-Betriebsart wird das Bit gesetzt, wenn die Zählrichtung von auf- zu abwärts und umgekehrt geändert wird (Zählerwert = 0).

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''OCF1A''' ('''O'''utput '''C'''ompare '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn der aktuelle Wert des Datenregisters von Timer/Counter 1 mit demjenigen im Vergleichsregister '''OCR1''' übereinstimmt.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''ICF1''' ('''I'''nput '''C'''apture '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn ein Capture-Ereignis aufgetreten ist, welches anzeigt, dass der Wert des Datenregisters des Timer/Counter 1 in das Input Capture Register ICR1 übertragen wurde.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''TOV0''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''0''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 0 ein Überlauf des Datenregisters stattfindet.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.
|}

 

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sog. ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comperators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrups den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

* '''set_sleep_mode(uint8_t mode)'''
:Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z.B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
* '''sleep_mode()'''
:Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus.

<pre class="code">
#include <avr/io.h>
#include <avr/sleep.h>
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach auftreten eines entsprechenden "Aufwach-Interrupts" verarbeitet
...
</pre>

Vorsicht: Nicht alle AVR-Controller (v.a. nicht die "Brandneuen") werden von den avr-libc sleep-Funktionen richtig angesteuert. Bei nicht-untersützten Typen erreicht man die gewollte Funktionalität durch direkte "Bitmanipulation" der ensprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler:

<pre class="code">
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep");
...
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes

= Der Watchdog =

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der Watchdog.

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln.

Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

Betrachten wir doch einmal folgende Codesequenz:

<pre class="code">
uint8_t x;

x = 10;

while (x >= 0) {
// tu was

x--;
}
</pre>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm würde sich also hier aufhängen und auf ewig in der Schleife drehen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde beginnt der Counter von 0 an hochzuzählen. Wenn nun die je nach Vorteiler eingestellte Anzahl Zyklen erreicht wurde, löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern müssen wir den Watchdog regelmässig wieder neu starten bzw. Rücksetzen (Watchdog Reset). Dies sollte innerehalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern muss ein spezielles Prozedere verwendet werden, um den WD auszuschalten und zwar müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden. Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| border="1"
|-
| '''WDTCR'''
| '''W'''atchog '''T'''imer  '''C'''ontrol '''R'''egister

In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''WDTOE'''
| align="center" | '''WDE'''
| align="center" | '''WDP2'''
| align="center" | '''WDP1'''
| align="center" | '''WDP0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''WDTOE''' ('''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable)
:Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
:Wenn das Bit einmal gesetzt ist wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.

'''WDE''' ('''W'''atch'''d'''og '''E'''nable)
:Wenn dieses Bit gesetzt wird, so wird der Watchdog aktiviert.
:Das Bit kann nur gelöscht werden, solange das Bit '''WDTOE''' auf 1 steht.

'''WDP2''', '''WDP1''', '''WDP0''' ('''W'''atch'''d'''og Timer '''P'''rescaler Bits)
:Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:
<dl><dd>
{| border="1"
|-
| align="center" | WDP2
| align="center" | WDP1
| align="center" | WDP0
| align="center" | Anzahl Zyklen
| align="center" | Typ. Timeoutzeit bei Vcc = 3V
| align="center" | Typ. Timeoutzeit bei Vcc = 5V
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 16K
| align="center" | 47ms
| align="center" | 15ms
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 32K
| align="center" | 94ms
| align="center" | 30ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 64K
| align="center" | 0.19s
| align="center" | 60ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 128K
| align="center" | 0.38s
| align="center" | 0.12s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 256K
| align="center" | 0.75s
| align="center" | 0.24s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 512K
| align="center" | 1.5s
| align="center" | 0.49s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 1024K
| align="center" | 3s
| align="center" | 0.97s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 2048K
| align="center" | 6s
| align="center" | 1.9s
|}
</dd></dl>
|}

Um den Watchdog mit dem AVR-GCC Compiler zu verwenden, muss die Headerdatei wdt.h in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

* '''wdt_enable(uint8_t timeout)'''
:Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert (z.B. WDTO_30MS).
* '''wdt_disable()'''
:Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
* '''wdt_reset()'''
:Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Ein paar grundsätzliche Gedanken ==

Ob nun so ein Watchdog überhaupt verwendet werden soll, ist wohl eher eine
philosophische Frage und hängt vom Geschmack jedes einzelnen Entwicklers ab.

Ich persönlich habe es lieber, wenn ich auch merke, dass in meine Programm
etwas noch nicht in Ordnung ist, als dass mir ein Watchdog einfach die CPU immer
wieder zurücksetzt, denn immerhin kann es so passieren, dass ein Programm über
Jahre hinweg so einigermassen läuft, obwohl noch ein voll krasser Bock drin
liegt.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Watchdog timer handling

= Programmieren mit Interrupts =

Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

[[Image:Interrupt Programme.gif]]

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

== Anforderungen an die Interrupt-Routine ==

Um unliebsamen Überraschungen vorzubeugen sollten einige Grundregeln bei
der Gestaltung der Interruptroutinen beachtet werden.

* Die Interruptroutine soll möglichst kurz und schnell abarbeitbar sein, daraus folgt:
* Keine unfangreichen Berechnungen innerhalb der Interruptroutine.
* Keine endlos langen Programmschleifen.
* Obschon es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen rate ich dringend von solchen Spielen ab.

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf dem AVR auslösen, wobei
die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

== Register ==

Der AT90S2313 verfügt über 2 Register welche mit den
Interrupts zusammen hängen.

{| border="1"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INT1'''
| align="center" | '''INT0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INT1''' (External '''Int'''errupt Request '''1''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

'''INT0''' (External '''Int'''errupt Request '''0''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INTF1'''
| align="center" | '''INTF0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INTF1''' (External '''Int'''errupt Flag '''1''')
:Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.

'''INTF0''' (External '''Int'''errupt Flag '''0''')
:Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister.

Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''SE'''
| align="center" | '''SM'''
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''SE''' ('''S'''leep '''E'''nable)
:Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl in den Schlafzustand versetzen zu können.
:Um den Schlafmodus nicht irrtümlich einzuschalten, wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.

'''SM''' ('''S'''leep '''M'''ode)
:Dieses Bit bestimmt der Schlafmodus.
:Ist das Bit gelöscht, so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt, so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")

'''ISC11''', '''ISC10''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.
<dl><dd>
{| border="1"
|-
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}
</dd></dl>
'''ISC01''', '''ISC00''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

<dl><dd>
{| border="1"
|-
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}
</dd></dl>
|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft, wird automatisch das '''Global
Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle
weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem
Zeitpunkt bereits wieder das GIE-bit zu setzen, rate ich dringend davon ab. Dieses
wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn
in der Zwischenzeit weitere Interrupts eintreffen, werden die zugehörigen
Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden
Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt
ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle
anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe,
weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.

=== Das Status-Register ===

Es gilt auch zu beachten, dass das Status-Register während der Abarbeitung
einer Interruptroutine nicht automatisch gesichert wird. Falls notwendig, muss dies vom
Programmierer selber vorgesehen werden.

== Interrupts mit dem AVR GCC Compiler (WinAVR) ==

Selbstverständlich können alle Interruptspezifischen Registerzugriffe wie gewohnt über I/O-Adressierung vorgenommen werden. Etwas einfacher geht es jedoch, wenn wir die vom Compiler zur Verfügung gestellten Mittel einsetzen.

Damit diese Mittel zur Verfügung stehen, müssen wir die Includedatei ''interrupt.h'' und evtl. ''signal.h'' einbinden mittels:

<pre class="code">
// fuer sei(), cli() und INTERRUPT():
#include <avr/interrupt.h>

// fuer SIGNAL() auch:
#include <avr/signal.h>
</pre>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird
nichts anderes gemacht, als das '''Global Interrupt Enable''' Bit im Status
Register gesetzt.

<pre class="code">
sei();
</pre>

Das Makro '''cli()''' schaltet die Interrupts aus, oder anders
gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird
gelöscht.
<pre class="code">
cli();
</pre>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf.
Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen.
Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren
und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen
Zustands die Interrups aktivieren, was zu unerwünschten Seiteneffekten führen kann.
Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern */

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD); // 2 mal in Folge , vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
...

}
</pre>



Nachdem nun die Interrupts aktiviert sind, braucht es selbstverständlich noch den auszuführenden Code, der ablaufen soll, wenn ein Interrupt eintrifft. Dazu gibt es zwei Definitionen: '''SIGNAL''' und '''INTERRUPT''', welche allerdings AVR-GCC spezifisch sind und bei anderen Compilern womöglich anders heissen können.

=== SIGNAL ===

<pre class="code">
#include <avr/signal.h>
...
SIGNAL (siglabel)
{
/* Interrupt Code */
}
</pre>

Mit ''SIGNAL'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektoren angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Vor Nutzung von SIGNAL muss die Header-Datei signal.h eingebunden werden. Mögliche Funktionsrümpfe für solche Interruptfunktionen sind zum Beispiel:

<pre class="code">
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

SIGNAL (SIG_OVERFLOW1)
{
/* Interrupt Code */
}

SIGNAL (SIG_UART_RECV)
{
/* Interrupt Code */
}

// und so weiter und so fort...
</pre>

Während der Ausführung des Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten, so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== INTERRUPT ===

<pre class="code">
#include <avr/interrupt.h>
...
INTERRUPT (signame)
{
/* Interrupt Code */
}
</pre>

Mit INTERRUPT wird genau gleich gearbeitet wie mit SIGNAL. Der Unterschied ist derjenige, dass bei INTERRUPT beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit automatisch wieder gesetzt und somit weitere Interrupts zugelassen werden. Dies kann zu nicht unerheblichen Problemen von im einfachsten Fall einem Stack overflow bis zu sonstigen unerwarteten Effekten führen und sollte wirklich '''nur dann''' angewendet werden, wenn man sich absolut sicher ist, das Ganze auch im Griff zu haben. Vor Nutzung von INTERRUPT muss die Header-Datei interrupt.h eingebunden werden.

Interruptroutinen (ISRs) sollten möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern des Zustands aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen, s.u.). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

siehe auch: Hinweise in [[AVR-GCC]]

== Datenaustausch mit Interrupt-Routinen ==

Variablen auf die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen wird und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte die Code-Optimierung "greifen" und der Wert der Variablen nur in Prozessorregistern zwischenspeichert werden, die "nichts von der Änderung woanders mitbekommen".

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z.B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt z.B. alle 10ms
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
// hier wird gKeyCounter veraendert, die uebrigen
// Programmteile muessen diese Aenderung "sehen"
// (volatile -> aktuellen Wert immer in den Speicher schreiben)
if ( !(KEY_PIN & (1<<KEY_PINNO)) )
if (gKeyCouter < CNTREPEAT) gKeyCounter++;
else gKeyCounter = 0;
}

...

int main(void)
{
...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
...
// hier wird auf gKeyCounter zugegriffen, dazu muss der in der
// ISR geschrieben Wert bekannt sein.
// (volatile -> aktuellen Wert immer aus dem Speicher lesen)
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt"
}
else {
/* hier: Code fuer "Taste kurz gedrueckt"
}
...
}
</pre>

Bei Variablen größer ein Byte muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes ausserhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<pre class="code">
...
volatile uint16_t gMyCounter16bit
...
SIGNAL(...)
{
...
gMyCounter16Bit++;
...
}

int main(void)
{
uint16_t tmpCnt;
...
// nicht gut: mglw. hier ein Fehler wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor Kopieren des zweiten Bytes
// ein Interrupt auftritt der den Inhalt von MyCounter veraendert
tmpCnt = gMyCounter16bit;

// besser: Aenderungen "ausserhalb" verhindern, alle "Teilbytes"
// bleiben konsistent
cli(); // Interupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren
...
}
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8 (Stand: avr-libc Vers. 1.0.4)

== Was macht das Hauptprogramm ==

Im einfachsten Fall gar nichts mehr.

Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der
main-Funktion lediglich noch die Interrupts aktiviert und dann in eine
Endlosschleife folgender Art verzweigt:

<pre class="code">
...
for (;;) {}
...
</pre>

Normalerweise wird man allerdings in den Interruptroutinen die Interrupts
erfassen und im Hauptprogramm dann gemütlich auswerten.

Wie wir im bisherigen Kursverlauf gesehen haben ist es ohnehin mit so
schnellen Controller meistens gar nicht unbedingt notwendig mit
Interruptfunktionen zu arbeiten. 
Es ist allerdings auch zu bemerken, dass mit den Interruptroutinen ein Programm
sehr schön strukturiert werden kann, wenn man es richtig macht.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (eigentlich [[SRAM]]) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als [[FLASH]]-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z.B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin wenig Sinn macht und auch nur bei einigen RAM-losen Typen nach "Bastelarbeiten" möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory). Die Standard-Laufzeitbibliothek des avr-gcc, die [[avr-libc]], stellt diese Funktionen nach einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Einige Beispiele:

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray1 };
...
</pre>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<pre class="code">
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte...
}
</pre>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel, jedoch mit der Funktion pgm_read_word.

<pre class="code">
uint16_t myWord;

myWord = pgm_read_word(&pgmFooWord);
</pre>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "gross". (Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.) Pointer müssen gegebenenfalls "gecastet" werden.

<pre class="code">
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray1

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray2
// da im zweiteb Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmPointerToArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</pre>

=== Floats und Structs lesen ===

Um komplexe Datentypen (structs), nicht-integer Datentypen (floats) aus dem Flash auszulesen, sind Hilfsfunktionen erforderlich. Einige Beispiele:

<pre class="code">

/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
...

/* liest float von Flash-Addresse addr und gibt diese als return-value zurueck */
inline float pgm_read_float(const float *addr)
{
union
{
uint16_t i[2]; // 2 16-bit-Worte
float f;
} u;

u.i[0]=pgm_read_word((PGM_P)addr);
u.i[1]=pgm_read_word((PGM_P)addr+2);

return u.f;
}
...

void egal(void)
{
int i;
float f;

for (i=0;i<3;i++) {
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach' was mit f
}
}
</pre>

TODO: Beispiele fuer structs und pointer aus flash auf struct im flash (menues, state-machines etc.)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuerht, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
...
</pre>

Aber Achtung: Ersetzt man zum Beispiel
<pre class="code">
const char textImFlash[] PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
durch
<pre class="code">
const char textImFlash* PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der textImFlash zu den Konstanten ans Ende des Programmcodes gelegt wird, von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte. Da der lesende Code trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein Bug des AVR-GCC (gesehen bei 3.4.1) zu sein.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<pre class="code">
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
...
</pre>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z.B. 0x01fe), "weiss" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, dass der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000), wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z.B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmässig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, das vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgeben sind ("timed sequence"). Diese Prüfung wird nicht implizit durchgeführt. Im Zweifel kann man Sicherheitshalber bei EEPROM-Zugriffen die Interrupts global deaktivieren, z.B. so:

<pre class="code">
...
uint8_t sreg;
...

sreg = SREG;
cli();

/* hier die eeprom-Zugriffe */

SREG = sreg;
...
</pre>

Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Die Nutzung einer [[C-Präprozessor]]-Ersetzung bringt etwas Bequemlichkeit. Siehe dazu folgendes Beispiel.

<pre class="code">
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h>

// alle Textstellen EEPROM im Quellcode durch __attribute__ ... ersetzen
#define EEPROM __attribute__ ((section (".eeprom")))

...

/* Byte */
uint8_t eeFooByte EEPROM = 123;

/* Wort */
uint16_t eeFooWort EEPROM = 12345;

/* float */
float eeFooFloat EEPROM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEPROM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEPROM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */

uint16_t eeFooWordArray1[4] EEPROM;
...
</pre>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heisst eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<pre class="code">
...
uint8_t myByte;
uint8_t sreg;

sreg = SREG; // (1)
cli(); // (1)

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
...
SREG = sreg; // (1)
</pre>

Die mit (1) markierten Zeilen dienen hierbei dem (möglicherweise übertriebenen) Schutz vor Unterbrechnungen durch Interrupts.

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<pre class="code">
...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
...
</pre>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprueft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und mglw. noch mehr.

<pre class="code">
...
unit8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes aber der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnuetze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray[0],3);

/* dito mit etwas Absicherung betr. der Laenge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));

/* Datenlock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));
...
</pre>

"Nicht-Integer"-Datentypen wie z.B. Fliesskommazahlen lassen sich recht praktisch ueber eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<pre class="code">
...
float myFloat = 12.34;

union {
float r;
uint8_t n[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */
...
</pre>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<pre class="code">
...
typedef struct {
uint8_t label[8];
unin8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEPROM;

...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
...
}
...
</pre>

=== EEPROM-Speicherabbild in .eep-Datei ===

Eine besondere Funktion des avr-gcc ist, dass mit einem entsprechenden makefile aus den Initialisierungswerten der Variablen im Quellcode eine Datei erzeugt werden kann, die man auf den Controller programmieren kann (.eep-Datei). Damit können sehr elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Die Vorgehensweise wird aus dem WinAVR-Beispielmakefile ersichtlich. Siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles.

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Nicht alle neuen AVR Controller werden von avr-libc/eeprom.h untersützt (Stand Version 1.0.4). Insbesondere beim ATMega169 funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register) Etwas ältere Typen, oder zu den "etablierten" Controllern kompatible, bereiten jedoch hier keine Proleme. Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Der dort gezeigt Code kann direkt auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste").

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gcc-Toolchain" bietet dazu zwei Möglichkeiten:

;Inline-Assembler:
Die Assembleranweisungen werden in direkt in den C-Code integriert. Eine Quellcode-Datei enhält somit C- und Assembleranweisungen

;Assembler-Dateien:
Der Assembler-Codecode befindet sich in eigenen Quellcodedateien. Dieser werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z.B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen eine NOP-Anweisung. NOP steht für '''NO'''-O'''P'''eration. Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=warte)-Funktionen.

<pre class="code">
...
/* Verzoegern der weiteren Programmausfuehrung um
genau 3 Taktzyklen */
asm volatile ("nop"::);
asm volatile ("nop"::);
asm volatile ("nop"::);
...
</pre>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeindlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<pre class="code">
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i=0;i<1000;i++);

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i=0;i<1000;i++) asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j=0;j<1000;j++);
</pre>

Ein weiterer nützliche "Assembler-Einzeiler" ist der Auruf von sleep (''asm volatile ("sleep"::);''), da hierzu keine eigene Funktion in der avr-libc existiert.

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil des die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<pre class="code">
static inline void delayloop16(uint16_t count)
{
asm volatile ( "cp %A0,__zero_reg__ \n\t" \
"cpc %B0,__zero_reg__ \n\t" \
"breq L_Exit_%= \n\t" \
"L_LOOP_%=: \n\t" \
"sbiw %0,1 \n\t" \
"brne L_LOOP_%= \n\t" \
"L_Exit_%=: \n\t" \
: "=w" (count)
: "0" (count)
);
}
</pre>

* Jede Zeile wird mit '''\n\t''' abgeschlossen, alle Zeilen mit '''\''' verbunden.
* Sprung-Marken (labels) werden mit einm Prozentzeichen abgeschlossen, der Präprozessor (Assembler?) setzt an dieser Stelle eine laufende Nummer ein, die Doppelbezeichnungen bei mehrmaliger Verwendung somit verhindert.

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc.

* siehe auch: Dokumentation der avr-libc/Related Pages/Inline Asm
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

...TODO: Beispiele, Parameteruebergabe, globale Variablen für Datenaustausch

= TODO =

stdio.h, malloc() ???, Code-Optimierungen ("tricks"), "naked"-Functionen ??, IO-Register als Parameter/"Variablen" (volatile uint8_t *mybusport; mybusport=&PORTB; void sendbus(uint8_t *parm)...)

= C-Code und Bibliotheken für externe Baugrupen =
(TODO: sollte in avr-gcc verschoben werden)
[[Linksammlung#Avr]]

==LCD==
=== Text (character-mode) HD44870 ===
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray

=== Grafik-LCD ===
==== Nokia3310 ====
==== Nokia 6100 LCD ====
Das Nokia ist ein 132x132x4096 Farben Display das bei eBay ziemlich preiswert ersteigert werden kann.
[http://www.apetech.de/nokia6100.php Nokia 6100 LCD Library]
==== KS0108 ====
* Procyon avrlib (GPL)
* avrfreaks UP
* apetech.de
==Schnittstellen==
===I2C===
====Master====
[http://jump.to/fleury/ P. Fleurys I2C Master library]
====Slave====

===CAN===
* [http://www.atmel.com] Codesammlung zum AT90CAN128

=== DS18S20/1-Wire ===
* avrfreaks Projekt 59
* mikrocontroller.net/codesammlung (P. Dannegger)

=== UART ===
* Procyon avrlib (GPL)
* avrfreaks UP (viele viele)
* P. Fleury

== Speicherkarten/IDE/FAT ==
* avrfreaks UP (IDE/FAT read write)
== CRC ==
* avrfreaks-forum (O'Flynn)
* avr-hal (GPL)

AVR-GCC-Tutorial

2004-11-12T13:38:57Z

Oxygene: /* Programmspeicher (Flash) */

[[Category:AVR]]

= Vorwort =

Dieses Tutorial soll Einsteigern helfen, mit der Programmiersprache '''C''' die Mikrocontroller der Atmel AVR-Reihe zu programmieren.


Die ursprüngliche Version stammt von Christian Schifferle, die meisten aktuellen Anpassungen von [[Benutzer:Mthomas]]. Viele der im Original-Dokument verwendeten Funktionen sind in
aktuellen Versionen des avr-gcc C-Compilers und der avr-libc zwar noch enthalten,
aber als überholt (''deprecated'') ausgewiesen. D.h. diese Funktionen sollten nicht mehr verwendet
werden und existieren in zukünftigen Versionen des Compilers/der Library nicht mehr
(z.B. sbi(), cbi(), outp(), inp()). Der Artikel wurde auf die neuen Funktionen/Methoden
angepasst.

In diesem Text wird häufig auf die Standardbibliothek für den avr-gcc-Compiler, die avr-libc, verwiesen. Die '''Dokumentation der avr-libc''' findet sich
[http://www.nongnu.org/avr-libc/user-manual/index.html hier]. Bei WinAVR gehört diese Dokumentation zum Lieferumfang und wird mitinstalliert.

= Benötigte Werkzeuge =

Um die Übungen in diesem Tutorial nachvollziehen zu können benötigen wir folgende Hard- und Software:

* Testboard für die Aufnahme eines AVR Controllers, der vom gcc Compiler untersützt wird (alle ATmegas und die meisten AT90). Dieses Testboard kann durchaus auch selber zusammen gelötet werden. So arbeite ich mit einem Testboard, welches ich mir auf einer Veroboard-Platine zusammen gestellt habe. Für die Versuche bzw. Übungen in diesem Tutorial habe ich jeweils einen AT90S2313 verwendet. Eine brauchbare Testplattform ist auch der [[AVR Butterfly]].
* AVRGCC-Compiler. Kostenlos erhältlich für nahezu alle Plattformen/Betriebssysteme. Für MS-Windows im Packet [[WinAVR]]; für Unix/Linx siehe auch Hinweise im Artikel [[AVR-GCC]].
* Programmiersoftware und Hardware z.B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], [[AVR-Studio]]).
* Nicht unbedingt erforderlich aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Abschnitt Exkurs: makefiles).

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.
* Die [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently Asked Questions = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.
* Das gcc-Forum auf [http://www.mikrocontroller.net www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.
* Das avr-gcc-Forum bei [http://www.avrfreaks.net avrfreaks] nach vergleichbaren Problemen absuchen.
* Das [http://www.avr1.org/pipermail/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.
* Nach Beispielcode suchen. Vor allem in der Academy von [http://www.avrfreaks.net AVRFREAKS] (anmelden).
* Google oder alltheweb befragen schadet nie.
* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal)
* einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei mgl. viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode, genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z.B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: [http://www.lugbz.org/documents/smart-questions_de.html "Wie man Fragen stellt"].

= Exkurs: makefiles =

Wenn man bisher gewohnt ist, mit integrierten Entwicklungsumgebung à la Visual-C Programme zu erstellen, wirkt das makefile-Konzept auf den ersten Blick etwas kryptisch. Nach kurzer Einarbeitung ist diese Vorgehensweise jedoch sehr praktisch. Diese Dateien (üblicher Name: 'Makefile' ohne Dateiendung) dienen der Ablaufsteuerung des Programms make, das auf allen Unix/Linux-Systemen installiert sein sollte, und in einer Fassung fuer MS-Windows auch in [[WinAVR]] (Unterverzeichnis utils/bin) enthalten ist.

Im Unterverzeichnis ''sample'' einer WinAVR-Installation findet man eine sehr brauchbare Vorlage, die sich einfach an das eigene Projekt anpassen lässt ([[Media:Makefile|lokale Kopie Stand Sept. 2004]]). Wahlweise kann man auch [http://www.sax.de/~joerg/mfile/ mfile] von Jörg Wunsch nutzen. mfile erzeugt ein makefile nach Einstellungen in einer grafischen Nutzeroberfläche, wird bei WinAVR mitinstalliert, ist aber als TCL/TK-Programm auf nahezu allen Platformen lauffähig.

''Die folgenden Ausführungen beziehen sich auf das WinAVR Beispiel-Makefile.''

Ist im Makefile alles richtig eingestellt genügt es, sich drei Parameter zu merken, die über die shell bzw. die Windows-Kommandozeile (cmd.exe/command.exe) als Parameter an "make" übergeben werden. Das Programm make sucht sich "automatisch" das makefile im aktuellen Arbeitsverzeichnis und führt die darin definierten Operationen für den entsprechenden Aufrufparameter durch.

{| border=1
| ''make all''
| Erstellt aus den in im makefile angegebenen Quellcodes eine ''hex''-Datei (und ggf. auch ''eep''-Datei).
|-
| ''make program''
| Überträgt die hex-Datei (und wahlweise auch die eep-Datei für den EEPROM) zum AVR.
|-
| ''make clean''
| löscht alle temporären Dateien, also auch die hex-Datei
|}

Diese Aufrufe können in die allermeisten Editoren in "Tool-Menüs" eingebunden werden. Dies erspart den Kontakt mit der Kommandozeile. (Bei WinAVR sind die Aufrufe bereits im Tools-Menü des mitgelieferten Editors Programmers-Notepad eingefügt.)

Üblicherweise sind folgende Daten im makefile anzupassen:
* Controllertyp
* Quellcode-Dateien (c-Dateien)
* Typ und Anschluss des Programmiergeräts

seltener sind folgende Einstellungen durchzuführen:
* Grad der Optimierung
* Methode zur Erzeugung der Debug-Symbole (Debug-Format)
* Assembler-Quellcode-Dateien (S-Dateien)

Die in den folgenden Unterabschnitten gezeigten makefile-Ausschnitte sind für ein Programm, das auf einem ATmega8 ausgeführt werden soll. Der Quellcode besteht aus den c-Dateien superprog.c (darin main()), uart.c, lcd.c und 1wire.c. Im Quellcodeverzeichnis befinden sich diese Dateien: superprog.c, uart.h, uart.c, lcd.h, lcd.c, 1wire.h, 1wire.c und das makefile (die angepasste Kopie des WinAVR-Beispiels).

Der Controller wird mittels [[AVRDUDE]] über ein [[STK200]]-Programmierdongle an der Schnittstelle lpt1 (bzw. /dev/lp0) programmiert. Im Quellcode sind auch Daten für die ''section .eeprom'' definiert (siehe Abschnitt Speicherzugriffe TODO: nach unten verlinken), diese sollen beim Programmieren gleich mit ins EEPROM geschrieben werden.

== Controllertyp setzen ==

Dazu wird die "make-Variable" MCU entsprechend dem Namen des verwendenten Controllers gesetzt. Ein Liste der von avr-gcc und der avr-libc untersützten Typen findet sich in der [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc].

<pre class="code">
# Kommentare in Makefiles beginnen mit einem Doppelkreuz
...

# ATmega8 at work
MCU = atmega8
# oder MCU = atmega16
# oder MCU = at90s8535
# oder ...
...
</pre>

== Quellcode-Dateien einstellen ==

Den Namen der Quellcodedatei welche die Funktion main enthält, wird hinter TARGET eingetragen. Dies jedoch ohne die Endung ''.c''.

<pre class="code">
...
TARGET = superprog
...
</pre>

Besteht das Projekt wie im Beispiel aus mehr als einer Quellcodedatei, sind die weiteren c-Dateien (nicht die Header-Dateien, vgl. [[Include-Files (C)]]) durch Leerzeichen getrennt bei SRC einzutragen. Die bei TARGET definierte Datei ist schon in der SRC-Liste enthalten. Diesen Eintrag nicht löschen!

<pre class="code">
...
SRC = $(TARGET).c uart.c lcd.c 1wire.c
...
</pre>

Alternativ kann man die Liste der Quellcodedateien auch mit dem Operator += erweitern.

<pre class="code">
SRC = $(TARGET).c uart.c 1wire.c
# lcd-Code fuer Controller xyz123 (auskommentiert)
# SRC += lcd_xyz.c
# lcd-Code fuer "Standard-Controller" (genutzt)
SRC += lcd.c
</pre>

== Programmiergerät einstellen ==

Die Vorlagen sind auf die Programmiersoftware [[AVRDUDE]] angepasst, jedoch lässt sich auch andere Programmiersoftware einbinden, sofern diese über Kommandozeile gesteuert werden kann (z.B. stk500.exe, uisp, sp12).

<pre class="code">
...
# Einstellung fuer STK500 an com1 (auskommentiert)
# AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
# AVRDUDE_PORT = com1 # programmer connected to serial device

# Einstellung fuer STK200-Dongle an lpt1
AVRDUDE_PROGRAMMER = stk200
AVRDUDE_PORT = lpt1
...
</pre>

Sollen Flash(=.hex) und EEPROM(=.eep) zusammen auf den Controller programmiert werden, ist das Kommentarzeichen vor AVRDUDE_WRITE_EEPROM zu löschen.

<pre class="code">
...
#Auskommentiert: EERPOM-Inhalt wird nicht mitgeschrieben
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

#Nich-auskommentiert EERPOM-Inhalt wird mitgeschrieben
AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
...
</pre>

== Anwendung ==

Die Eingabe von ''make all'' im Arbeitsverzeichnis mit dem makefile und den Quellcodedateien erzeugt (unter anderem) die Dateien superprog.hex und superprog.eep. Abhängigkeiten zwischen den einzelnen c-Dateien werden dabei automatisch berücksichtigt. Die ''superprog.hex'' und ''superprog.eep'' werden mit ''make program'' zum Controller übertragen. Mit ''make clean'' werden alle temporären Dateien gelöscht (="aufgeräumt").

== Sonstige Einstellungen ==

=== Optimierungsgrad ===

Der gcc-Compiler kennt verschiedene Stufen der Optimierung. Nur zu Testzwecken sollte die Optimierung ganz deaktiviert werden (''OPT = 0''). Die weiteren möglichen Optionen weisen den Compiler an, möglichst kompakten oder möglichst schnellen Code zu erzeugen. In den weitaus meisten Fällen ist ''OPT = s'' die optimale (sic) Einstellung, damit wird kompakter und oft auch der "schnellste" Maschienencode erzeugt.

=== Debug-Format ===

Unterstützt werden die Formate stabs und dwarf-2. Das Format wir hinter ''DEBUG ='' eingestellt. Siehe dazu Abschnitt ''Eingabedateien zur Simulation''.

=== Assembler-Dateien ===

Die im Projekt genutzten Assembler-Dateien werden hinter ASRC durch Leerzeichen getrennt aufgelistet. Assembler-Dateien haben immer die Endung .S (grosses S). Ist zum Beispiel der Assembler-Quellcode eines Software-UARTs in einer Datei softuart.S enthalten lautet die Zeile: ''ASRC = softuart.S''

== Eingabedateien zur Simulation in AVR-Studio ==

Mit älteren AVR-Studio-Versionen kann man nur auf Grundlage sogenannter ''coff''-Dateien simulieren. Neuere Versionen von AVR-Studio (ab 4.10.356) unterstützen zudem das modernere aber noch experimentelle dwarf-2-Format, das ab WinAVR 20040722 (avr-gcc 3.4.1/Binutils inkl. Atmel add-ons) "direkt" vom Compiler erzeugt wird.

; Vorgehensweise bei extcoff:
* im Makefile bei DEBUG: <pre class="code">DEBUG=stabs</pre>
* ''make extcoff'' (evtl. vorher ''make clean'')
* die erzeugte ''cof''-Datei (im Beispiel oben ''superprog.cof'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

; Vorgehensweise bei dwarf-2:
* im Makefile bei DEBUG: <pre class="code">DEBUG=dwarf-2</pre>
* ''make all'' (evtl. vorher ''make clean'')
* die erzeugte ''elf''-Datei (im Beispiel oben ''superprog.elf'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

Beim Simulieren scheinen oft "Variablen zu fehlen". Ursache dafür ist, dass der Compiler die "Variablen" direkt Registern zuweist. Dies kann vermieden werden, indem die Optimierung abgeschaltet wird (im makefile). Man simuliert dann jedoch ein vom optimierten Code stark abweichendes Programm. Das Abschalten der Optimierung wird nicht empfohlen.

Statt des Software-Simulators kann das AVR-Studio auch genutzt werden, um mit dem ATMEL JTAGICE, ein Nachbau davon (BootICE, Evertool o.ä.) oder dem ATMEL JTAGICE MKII "im System" zu debuggen. Dazu sind keine speziellen Einstellungen im makefile erforderlich. Debugging bzw. "In-System-Emulation" mit dem JTAGICE und JTAGICE MKII sind in der AVR-Studio Online-Hilfe beschrieben.

= Definition einiger Datentypen =

Für die Programmierung von Mikrocontrollern ist es sinnvoll, dass wir uns
vorerst einige Datentypen definieren, welche den Zugriff auf die verschiedenen
Komponenten des Controllers vereinfachen oder wenigstens das Programm lesbarer
machen können.

<pre class="code">
typedef unsigned char BYTE;
typedef unsigned short WORD;
</pre>

== BYTE ==

Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 255.

== WORD ==

Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 65535.

== DWORD ==

Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

== QWORD ==

Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

Bei allen vorgenannten Datentypen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z.B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich daher, die im folgenden Abschnitt beschriebenen standardisierten Datentypen zu nutzen und damit "Missverständnissen" vorzubeugen, die z.B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

= Standardisierte Integer(Ganzzahl)-Typen =

Standardisierte Datentypen werden in der Header-Datei inttypes.h definiert.
Will man diese Typen benutzen, bindet man die "Definitionsdatei" wie folgt ein:

<pre class="code">
#include <inttypes.h>
</pre>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<pre class="code">
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
</pre>

Ein Vierfach-Wort (64Bit) entspricht beim AVR ''uint64_t'', ein Doppel-[[Word|Wort]] (32bit) entspricht ''uint32_t'', ein Wort (16bit) entspricht ''uint16_t'' und ein [[Byte]] (8bit) entspricht ''uint8_t''.
Die Typen ohne vorangestelltes ''u'' können auch vorzeichenbehaftete Zahlen speichern. ''int8_t'' geht also von -128 bis 127, ''uint8_t'' dagegen geht von 0 bis 255.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Integer Types

== '''Bitfelder''' ==

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bit breit ist. 
Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in einer einzelnen Bytevariable zusammen fassen und (fast) wie
8 einzelne Variablen ansprechen können. 
Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente
definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<pre class="code">
struct {
unsigned char bStatus_1:1; // 1 Bit für bStatus_1
unsigned char bStatus_2:1; // 1 Bit für bStatus_2
unsigned char bNochNBit:1; // Und hier noch mal ein Bit
unsigned char b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</pre>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<pre class="code">
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</pre>

(mt Empfehlung: Bitfelder sparen zwar Platz, verschlechtern aber unter
Umständen die Les- und Wartbarkeit des Codes. Anfängern wird geraten,
ein "ganzes" ein Byte (uint8_t) zu nutzen auch wenn nur ein Bitwert gespeichert
werden soll.)

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten
Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher
Dinge erledigt werden können, welche nicht zeitkritisch sind. 
Wenn ein Interrupt ausgelöst wird so wird automatisch die zugeordnete
Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Allgemeiner Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heisst, das Programm kann die
Inhalte der Register auslesen und beschreiben. 
Einige Register haben spezielle Funktionen, andere wiederum könne für
allgemeine Zwecke (Speichern von Datenwerten) verwendet werden.

Einzelne Register sind bei allen AVR's vorhanden, andere wiederum nur bei
bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff
auf den UART notwendig sind selbstverständlich nur bei denjenigen Modellen
vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden
AVR-Typen definiert. 

Wenn im Makefile der MCU-Typ definiert ist, wird vom System automatisch die
zum Typen passende Definitionsdatei genutzt, sobald man im Code die allgemeine
"io.h" Header-Datei einbinden.

<pre class="code">
#include <avr/io.h>
</pre>

Ist im Makefile der MCU Type z.B. mit dem Inhalt atmega8 definiert,
wird beim einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit
den Register-Definitionen für den ATmega8 eingelesen.



== I/O-Register ==

Die I/O-Register haben einen besonderen Stellenwert bei den AVR Controllern.
Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. 
Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir mal
die 8-Bit Register.


=== Lesen eines I/O-Registers ===



Zum Lesen kann man auf I/O Register einfach wie auf eine
Variable zugreifen. Die spezielle Funktion inp() ist nicht mehr
notwendig und veraltet.

Beispiel:

<pre class="code">
#include <avr/io.h>
uint8_t foo;
...
int main(void)
{
foo=PINB; /* kopiert den Status der Eingabepins an PortB in die Variable foo */
...
}
</pre>

==== Lesen eines Bits ====

Die AVR-Bibliothek stellt auch Funktionen zur Abfrage eines einzelnen Bits
eines Registers zur Verfügung:

;bit_is_set (<Register>,<Bitnummer>) : Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 4 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>) : Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen bit_is_clear bzw. bit_is_set sind nicht unbedingt erfoderlich, man kann auch "einfachen" C-Syntax verwenden. Der universell verwendbar ist. ''bit_is_set'' entspricht dabei z.B. (Variable & (1<<Bitnummer)). Das Ergebnis ist <>0 wenn das Bit gesetzt und 0 wenn nicht gesetzt ist.

* siehe auch [[Bitmanipulation]]

=== Schreiben eines I/O-Registers ===



Zum Schreiben kann man I/O Register einfach wie eine
Variable setzen. Die spezielle Funktion outp() ist nicht mehr
notwendig, veraltet und sollte nicht mehr genutzt werden.

Beispiel:

<pre class="code">
#include <avr/io.h>
...
int main(void)
{
DDRA=0xff; /* Setzt das Richtungsregister des Ports A auf 0xff (alle Pins als Ausgang) */
PORTA=0x03; /* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low" */
...
}
</pre>

==== Schreiben eines Bits ====



Einzelne Bits setzt man "Standard-C-Konform" mittels logischen (bit-) Operationen.

mit dem Ausduck |=(1<<Bitnummer) wird ein Bit gesetzt, mit dem Ausdruck
&=~(1<<Bitnummer) wird ein Bit geloescht. Die Funktionen sbi und cbi sind
dazu nicht notwendig, veraltet und sollten nicht mehr genutzt werden.

Beispiel:
<pre class="code">
...
#define MEINBIT 2
...
PORTA |= (1<<MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1<<MEINBIT); /* loescht Bit 2 an PortA */
</pre>

* siehe auch:
** [[Bitmanipulation]]
** [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

=== Warten auf einen bestimmten Zustand ===

Es gibt in der Bibliothek sogar Funktionen, die Warten, bis ein bestimmter
Zustand auf einem Bit erreicht ist. 
Es ist allerdings normalerweise eine eher unschöne Programmiertechnik.

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das
definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits
gesetzt ist wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT 2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1<<WARTEBIT)) ) ;
</pre>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das
definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits
gelöscht ist wird die Funktion sofort wieder verlassen. 
Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT 4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// ungleich 0 ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
</pre>

Universeller und auch auf andere Platformen besser übertragbar ist die Verwendung von C-Standardoperationen.

siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]



= Zugriff auf Ports =

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind
jedem Port 3 Register zugeordnet:

{| border="1"
|-
| '''DDRx'''
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (anhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
| '''PORTx'''
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Wird ein Port als Eingang geschaltet, so können mit diesem Register
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|-
| '''PINx'''
| Eingangadresse für Port'''x'''.

Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der Portspins. Bit gesetzt (1) wenn Pin "high/an", Bit gelöscht (0) wenn Portpin "low/aus".
|}

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.


Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Wollen wir also beispielsweise Pin 0 bis 4 von Port B als Ausgänge
definieren so schreiben wir folgende Zeile:


<pre class="code">
#include <avr/io.h>
...
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F

DDRB=0x1F; /* direkte Zuweisung - unuebersichtlich */
/* mehr Tipparbeit aber uebersichtlicher: */
DDRB=(1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3)|(1<<DDB4);
...
</pre>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet.

=== Ganze Ports ===

Um einen ganzen Port als Ausgang zu definieren, kann der folgende Befehl
verwendet werden:

<pre class="code">
DDRB=0xff;
</pre>

Im Beispiel wird der Port B als Ganzes als Ausgang geschaltet.

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen
bzw. auszugeben.

== Ausgänge ==

Wir wollen nun einen als Ausgang definierten Pin auf Logisch 1 setzen. Dazu schreiben wir den entsprechenden Wert in das Portregister des entsprechenden Ports.

Mit dem Befehl

<pre class="code">
PORTB=0x04; /* besser PORTB=(1<<DDB2) */
</pre>

wird also der Ausgang an Pin 2 gesetzt (Beachte, dass die Bits immer ''von 0 an''
gezählt werden, das niederwertigste Bit ist also Bit 0 und nicht etwa Bit 1).

Man beachte bitte, dass bei der Zuweisung mittels '''='''  immer alle Pins gleichzeitig angegeben werden. Man sollte also zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfliessen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an PortB auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<pre class="code">
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<DDB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<DDB2)
</pre>


Die Funktionen cbi und sbi sind dazu nicht notwendig, veraltet und sollten
nicht mehr genutzt werden.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wird den Pegel über entsprechende Hardware (z.B. Optokoppler, Spannunsteiler "Levelshifter") anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unserer Controllers eine logische 1 (Vcc) oder eine logische 0 (Masse) anliegt.

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.



Wobei es hier sehr wichtig ist, zur Abfrage der Eingänge nicht etwa das Portregister '''PORTx''' zu verwenden, sondern die Porteingangsadresse '''PINx'''. Dies ist
ein oft gemachter Fehler!

Wollen wir also die aktuellen Signalzustände von Port D abfragen und in einer
Variable namens bPortD abspeichern so schreiben wir dazu folgende Befehlszeile:

<pre class="code">
#include <avr/io.h>
...
bPortD = PIND;
...
</pre>


=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen (''Active Low'' und ''Active High''):

{| border="1"
|-
| '''Active Low'''
| '''Active High'''
|-
| [[Image:Active Low.gif]]
| [[Image:Active High.gif]]
|-
| Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet.

Damit bei offenem Schalter der Controller kein undefiniertes Signal
bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein
sogenannter Pull-Up Widerstand geschaltet. Dieser dient dazu, den Pegel
bei geöffnetem Schalter auf logisch 1 zu ziehen. 
Der Widerstandswert des Pull-Up Widerstands ist an sich nicht kritisch. Es
muss jedoch beachtet werden, dass über den Widerstand ein Strom in den
Eingang fliesst, also sollte er nicht zu klein gewählt werden um den
Controller nicht zu zerstören. Wird er allerdings zu hoch gewählt ist
die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10
Kiloohm eingebürgert.

Die AVR's haben sogar an den meisten Pins softwaremässig zuschaltbare
interne Pull-Up Widerstände, welche wir natürlich auch verwenden
können.
| Hier wird der Kontakt zwischen die Versorgungsspannung und Masse geschaltet.

Damit bei offener Schalterstellung kein undefiniertes Signal am Controller
ansteht, wird zwischen den Eingangspin und die Masse ein Pull-Down
Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter
Schalterstellung auf logisch 0 zu halten.
|}

==== Pull-Up Widerstände aktivieren ====

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden
über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang'''
geschaltet ist. 

Wird der Wert des entsprechenden Portpins auf 1 gesetzt so ist
der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up
Widerstand nicht aktiv. 
Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand
verwenden, aber nicht beide zusammen.



<pre class="code">
#include <avr/io.h>
...
DDRD=0x00; /* alle Pins von Port D als Eingang */
PORTD=0xff: /* interer Pull-Up an allen Port-Pins aktivieren */
...
</pre>

Im Beispiel wird der gesamte Port D als Eingang geschaltet und alle Pull-Up
Widerstände aktiviert.

===== Tastenentprellung =====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von
Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim
Schliessen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern
mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes. 
Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein
solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen
als mehrfache Impulse gezählt wird. 
Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen
werden.

ToDo Bsp Quellcode

== Analog ==

Leider können wir mit unseren Controllern keine analogen Werte direkt
ausgeben oder einlesen. Dazu müssen wir Umwege gehen, doch dies wird in einem späteren
Kapitel behandelt.

=== 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1) ===

Einige der Portregister in den AVR-Controllern sind 16 Bit breit, Man spricht
dann von einem '''Wort'''.


Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<pre class="code">
#include <avr/io.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8

= Der UART, Teil 1 =

Wir werden in zukünftigen Übungen in die Situation kommen, dass wir
Informationen vom Controller auswerten bzw. anzeigen müssen wobei es vielleicht
dann nicht mehr reicht, ein paar Leuchtdioden anzusteuern. 
Somit brauchen wir eine Verbindung vom AVR zu unserem PC, und dies am besten
über die serielle Schnittstelle.

== Allgemeines zum UART ==

Einige AVR-Controller haben einen vollduplexfähigen UART ('''U'''niversal
'''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut.
Dies ist eine wirklich feine Sache, haben wir doch damit schon das nötige
Werkzeug, um mit anderen Geräten, welche über eine serielle Schnittstelle
verfügen (insbesondere mit unserem PC), zu kommunizieren.

Übrigens: Vollduplex heisst nichts anderes, als dass der Baustein gleichzeitig
senden und empfangen kann.

Neuere AVRs (ATmega) verfügen über einen oder zwei U'''S'''ART(s), dieser unterschiedet sich vom UART häuptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

Der UART wird über vier separate Register angesprochen. USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurations/Datenregister. Das Datenblatt gibt darüber Auskunft. Die Folgende Tabelle gibt nur die Register für die (veralteten) UARTs wieder.

{| border="1"
|-
| '''UCR   '''
| '''U'''ART '''C'''ontrol '''R'''egister. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXCIE'''
| align="center" | '''TXCIE'''
| align="center" | '''UDRIE'''
| align="center" | '''RXEN'''
| align="center" | '''TXEN'''
| align="center" | '''CHR9'''
| align="center" | '''RXB8'''
| align="center" | '''TXB8'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''CHR9''' (9 Bit Characters)
:Wenn dieses Bit gesetzt ist, können 9 Bit lange Zeichen übertragen und empfangen werden. Das 9. Bit kann bei Bedarf als zusätzliches Stopbit oder als Paritätsbit verwendet werden. Man spricht dann von einem 11-Bit Zeichenrahmen:
:1 Startbit + 8 Datenbits + 1 Stopbit + 1 Paritätsbit = 11 Bits

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.

|-
| '''USR   '''
| '''U'''ART '''S'''tatus '''R'''egister. 
Hier teilt uns der UART mit, was er gerade so macht.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXC'''
| align="center" | '''TXC'''
| align="center" | '''UDRE'''
| align="center" | '''FE'''
| align="center" | '''OR'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt bevor ein weiteres Zeichen komplett empfangen wurde wird eine Überlauf-Fehlersituation eintreffen. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, wenn die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit wird vom AVR gesetzt, wenn ein Zeichen vom Sendedatenregister in das Send-Schieberegister übernommen wurde und der UART nun wieder bereit ist, ein neues Zeichen zum Senden aufzunehmen.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''OR''' ('''O'''ver'''R'''un) 
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne
kommunizieren möchten. Der Wert, der in dieses Register geschrieben
werden muss, errechnet sich nach folgender Formel:

<math>
\begin{matrix}
UBBR = \frac{Taktfrequenz}{Baudrate * 16} - 1
\end{matrix}
</math>

Es sind Baudraten bis zu 115200 Baud und höher möglich.
|}

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (LOW) und 5V (HIGH). Die
Schnittstellenspezifikation für RS232 definiert jedoch -3V ... -12V (LOW) und
+3 ... +12V (HIGH). Zudem muss der Signalaustausch zwischen AVR und
Partnergerät invertiert werden. Für die Anpassung der Pegel und das
Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste
davon ist wohl der MAX232. Allerdings kostet der auch wieder Geld und benötigt
zusätzlich immerhin 4 externe Elkos.

Die in den PC eingebauten Schnittstellen vertragen ohne Klagen auch den
TTL-Pegel vom AVR. Allerdings müssen wir immer noch die Signale invertieren. Im
einfachtesn Fall verwenden wir dazu jeweils einen einfachen NPN-Transistor und 2
Widerstände. Näheres dazu erfahrt ihr in den folgenden Übungen.

Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z.B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfielt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Senden mit dem UART ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. 
Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach
gewünschter Funktionsweise die
benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister. 
Da wir vorerst nur senden möchten und (noch) keine Interrupts auswerten wollen,
gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das
'''Transmitter Enable''' Bit setzen müssen:


<pre class="code">
UCR |= (1<<TXEN);
</pre>

Der Atmega16 hat mehrere Konfigurationsregister für USART und erfordert eine etwas andere Konfiguration

<pre class="code">
UCSRB |= (1<<TXEN); //UART TX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1
</pre>

Nun müssen wir noch die Baudrate festlegen. Gemäß unserer Formel brauchen
wir dazu die Taktfrequenz des angeschlossenen Oszillators bzw. Quarz in die
Formel einzufügen und das Resultat der Berechnung in das Baudratenregister des
UART einzuschreiben:

<pre class="code">
/* UART-Init beim AT90S2313 */
#define F_CPU 4000000; // Zum Beispiel 4Mhz-Quarz
#define UART_BAUD_RATE 9600 // Wir versuchen mal mit 9600 Baud
UBRR = F_CPU / (UART_BAUD_RATE * 16L) - 1;
</pre>

Wieder für den Mega16 mit einem 16bit-Register eine andere Programmierung

<pre class="code">
/* USART-Init beim ATmegaXX */
#define F_OSC 3686400 /* Oszillator-Frequenz in Hz */
#define UART_BAUD_RATE 9600
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)

UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

/* alternativ bei der avr-libc "direkt 16bit" : */
UBRR=UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);
</pre>

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben.

<pre class="code">
while (USR & (1<<UDRE)); /* warten bis Senden moeglich */
UDR = 'x'; // Schreibt das Zeichen x auf die Schnittstelle
</pre>

=== Schreiben einer Zeichenkette (String) ===

Es ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

Zu diesem Zweck können wir uns für's Erste eine einfache Funktion basteln:

<pre class="code">
void SendeString (char *szBuf)
{
while (*szBuf) {
loop_until_bit_is_set (USR, UDRE); /* warten bis Senden moeglich */
UDR=*szBuf;
szBuf++;
}
}
</pre>

Warteschleifen sind insofern etwas kritisch, da während des Sendens eines
Strings nicht mehr auf andere Ereignisse reagieren werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. emfangenen Zeichen/Bytes zwischengespeichert und mittels Interruptroutinen an den U(S)ART weitergebgen bzw. ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

* siehe auch: Weiterführende Informationen inkl. Beispielen für die Nutzung von stdio-Funktionen (prinf etc.) im [[AVR-Tutorial - UART]].
* [http://homepage.sunrise.ch/mysunrise/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc

= Analoge Ein- und Ausgabe =

Leider können wir mit unseren Controllern keine analogen Werte direkt
verarbeiten. Dazu bedarf es jeweils einer Umwandlung des analogen Signals in
einen digitalen Zahlenwert. Je nachdem, ob wir Daten einlesen oder ausgeben
wollen reden wir dabei von '''ADC''' oder '''DAC'''.

== ADC (Analog Digital Converter) ==

Der '''ADC''' wandelt analoge Signale in digitale Werte um, welche vom Controller
interpretiert werden können. Einige AVR-Typen haben bereits einen oder mehrere
solcher '''ADC''''s eingebaut, bei den kleineren AVR's müssen wir uns anders aus der
Affäre ziehen. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst
werden kann, wird durch die Auflösung des '''ADC''' in Anzahl Bits angegeben, man
hört bzw. liest jeweils von 8-Bit '''ADC''' oder 10-Bit ''' ADC''' oder noch höher. 
Ein '''ADC''' mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit
von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten
eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

<div align="center"><center>

{| border="1"
|-
| align="center" | '''Eingangsspannung am ADC'''
| align="center" | '''Entsprechender Messwert'''
|-
| align="center" | 0...<0.625V
| align="center" | 0
|-
| align="center" | 0.625...<1.25V
| align="center" | 1
|-
| align="center" | 1.25...<1.875V
| align="center" | 2
|-
| align="center" | 1.875...<2.5V
| align="center" | 3
|-
| align="center" | 2.5...<3.125V
| align="center" | 4
|-
| align="center" | 3.125...<3.75V
| align="center" | 5
|-
| align="center" | 3.75...<4.375V
| align="center" | 6
|-
| align="center" | 4.375...5V
| align="center" | 7
|}

</center>
</div>

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des '''
ADC''' ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Messen eines Widerstandes ===

Wir wollen hier einmal die wohl einfachste Methode zur Erfassung eines
analogen Wertes realisieren und zwar das Messen eines veränderlichen
Widerstandes wie z.B. eines Potentiometers.

Man stelle sich vor, wir schalten einen Kondensator in Reihe zu einem
Widerstand zwischen die Versorgungsspannung und Masse und dazwischen nehmen wir
das Signal ab und führen es auf einen der Pins an unserem Controller, genau so
wie es in folgender Grafik dargestellt ist.

[[Image:Poti.gif]]

Wenn wir nun den Pin des AVR als Ausgang schalten und auf
Logisch 1 (HIGH) legen, dann liegt an beiden Platten des Kondensators ''' Vcc''' an und
dieser wird entladen (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen). 
Nachdem nun der Kondensator genügend entladen ist schalten wir einfach den Pin
als Eingang wodurch dieser hochohmig wird. Der Kondensator lädt sich jetzt
über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und
derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti
unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), dann schaltet der
Eingang von HIGH auf LOW um. Wenn wir nun messen (zählen), wie lange es dauert,
bis der Kondensator so weit geladen ist, dann haben wir einen ungefähren Wert
der Potentiometerstellung. 
Der 220 Ohm Widerstand dient dem Schutz des Controllers. Wenn nämlich sonst die
Potentiometerstellung auf Maximum steht (0 Ohm), dann würde in den Eingang des
Controllers ein viel zu hoher Strom fliessen und der AVR würde in Rauch
aufgehen.

Dies ist meines Wissens die einzige Schaltung zur Erfassung von
Analogwerten, welche mit nur einem einzigen Pin auskommt. 
Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine
Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B:
0...100 % oder so) umzurechnen.

Wer Lust hat, sich selber mal an ein solches Programm
heranzuwagen, der sollte das jetzt tun. Für diejenigen, die es gern schnell
mögen, hier das Beispielprogramm, welches den UART-Printf aus den
vorangegangenen Kapiteln benötigt, inkl. Makefile:

{| border="0"
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Poti.c Poti.c ]
| Hauptprogramm.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.c Pot.c]
| Separate Routine zur Ermittlung des Messwertes.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.h Pot.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c UartPrintF.c]
| Für die Debugausgabe auf den UART.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h UartPrintF.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile Makefile]
| Makefile.
|}

Nachdem das Programm auf den AVR geladen wurde, muss dieser
kalibriert werden. Dazu wird der Kalibrierungsschalter geschlossen und das Poti
einige Male zwischen minimaler und maximaler Stellung hin und her gedreht. Dabei
werden die jeweiligen Maximalwerte bestimmt. Wenn der Kalibrierschalter wieder
geöffnet wird werden die Kalibrierungsdaten in's EEPROM des AVR geschrieben,
damit die Prozedur nicht nach jedem Reset wiederholt werden muss.

Auf Pin 4 habe ich noch ein Triggersignal gelegt, welches auf
HIGH geht wenn die Messung beginnt und auf LOW, wenn der Messvorgang beendet
wird. Mit Hilfe dieses Signals kann der Vorgang wunderschön auf einem
Oszillographen dargestellt werden.

=== ADC über Komparator ===

Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

[[Image:ADC ueber Komparator.gif]]

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert. 
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

=== Der ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem '''ADC-Wandler''' zurückgreifen. Wir wollen hier einmal den AT90S8535 besprechen, welcher über 8 ADC-Kanäle verfügt. (TODO: nur ein Wandler, Mulitiplexbetrieb, nur eine Pin zur gleichen Zeit)

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung.

Verfügt der AVR über eine interne Referenzspannung (Datenblatt typisch 2,56 oder 1,1V je nach AVR), bleibt der ''Anschluss AREF'' unbeschaltet und man stellt die ADC-Register so ein, dass die interne Referenzspannung als "AREF" genutzt wird. Ansonsten ist eine externe Referenzspannung von maximal '''Vcc''' an den Abschluss '''AREF''' anzulegen. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden.

==== Einfache Wandlung (Single Conversion) ====

In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestossen für jeweils eine Messung.

==== Frei laufend (Free Running) ====

In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register, welche hier aufgelistet werden.

{| border="1"
|-
| '''ADCSR   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ADEN'''
| align="center" | '''ADSC'''
| align="center" | '''ADFR'''
| align="center" | '''ADIF'''
| align="center" | '''ADIE'''
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt, ist können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''Fr'''ee Running Select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Eine logische 1 aktiviert den frei laufenden Modus. Der ''' ADC''' misst nun ständig den ausgewählten Kanal und schreibt den gemessenen Wert in das '''ADC Data Register'''.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, wenn eine Umwandlung erfolgt und das '''ADC Data Register''' aktualisiert ist.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird (So steht es in der AVR-Dokumentation).

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200kHz}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50kHz}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.
<dl><dd>
{| style="" border="1"
|-
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
| align="center" | '''Teilungsfaktor'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 2
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 2
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 4
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 8
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 16
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 32
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 64
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 128
|}
</dd></dl>
|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<pre class="code">
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
C-Operatorprioritaet sichergestellt)
</pre>

oder

<pre class="code">
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</pre>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''MUX2'''
| align="center" | '''MUX1'''
| align="center" | '''MUX0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''MUX2...MUX0'''
:Mit diesem 3 Bits wird der zu messende Kanal bestimmt. Es wird einfach die entsprechende Pinnummer des Ports eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Meine Empfehlung ist deswegen klar diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Aktivieren des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register
setzen. Im gleichen Schritt legen wir auch gleich die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls mit Spannungsteiler konditionieren. Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1024 für V_ref-Volt.

<pre class="code">

#define CHANNELOFFSET 4

uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result;

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler setzen auf 8 (1)
ADCSRA |= (1<<ADEN); // ADC aktivieren (1)

ADMUX = CHANNELOFFSET+channel; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)

result = 0;

/* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
for(i=0;i<4;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)
result += ADC; // Wandlungsergebnisse aufaddieren
}

ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)

result >>= 2; // Summe durch vier teilen = arithm. Mittelwert

return result;
}
</pre>

Im Beispiel wird bei jedem Aufruf der ADC aktiviert und nach der Wandlung wieder abgeschaltet, das spart Strom. Will man dies nicht, verschiebt man die mit (1) gekenntzeichneten Zeilen in eine Funktion adc_init() o.ä. und löscht die mit (2) markierten Zeilen.



== DAC (Digital Analog Converter) ==

Mit Hilfe eines ''' DAC''' können wir nun auch Analogsignale ausgeben. Es gibt hier
mehrere Verfahren. Wenn wir beim ''' ADC''' die Möglichkeit haben, mit externen
Komponenten zu operieren, müssen wir bei der '''DAC'''-Wandlung mit dem auskommen, was
der Controller selber zu bieten hat.

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie ''' PWM''' eigentlich funktioniert.

Wie wir alle wissen ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber
wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. 
Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen
HIGH und LOW umschalten? 
Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen geometrischen Mittelwert, der je nach Pulsbreite
kleiner oder grösser ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein
RC-Glied filtern dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVR's können wir direkt '''PWM'''-Signale erzeugen. Dazu
dient der 16-Bit Zähler, welcher im sogenannten '''PWM'''-Modus betrieben werden
kann.

Hinweis:
:In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist allerdings bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt.

Um den '''PWM'''-Modus zu aktivieren müssen im Timer/Counter1 Control
Register A '''TCCR1A''' die Pulsweiten-Modulatorbits '''PWM10''' bzw. '''PWM11''' entsprechend
nachfolgender Tabelle gesetzt werden:

{| border="1"
|-
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| PWM-Modus des Timers ist nicht aktiv.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM.
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben. Die
Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| border="1"
|-
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden heisst dann:

<pre class="code">
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</pre>

Damit der Timer/Counter überhaupt läuft müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorzähler) einstellen, und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| border="1"
|-
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<pre class="code">
TCCR1B = (1<<CS12) | (1<<CS10);
</pre>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<pre class="code">
OCR1A = xxx;
</pre>

Die folgende Grafik soll den Zusammenhang zwischen dem
Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren.

= Die Timer/Counter des AVR =

Die heutigen Mikrocontroller und insbesondere die RISC-AVR's sind für viele
Steuerungsaufgaben natürlich viel zu schnell. Wenn wir beispielsweise eine LED
oder Lampe blinken lassen wollen, können wir selbstverständlich nicht die
CPU-Frequenz verwenden da ja dann nichts mehr vom Blinken zu bemerken wäre.

Wir brauchen also eine Möglichkeit, die Taktfrequenz auf vernünftige Werte
herunter zu brechen. Selbstverständlich sollte die resultierende Frequenz dann
auch noch einigermassen genau und stabil sein.

Hier kommen die im AVR vorhandenen Timer/Counter zum Einsatz.

Ein anderes Anwendungsgebiet ist die Zählung von Signalen, welche über
einen I/O-Pin zugeführt werden können.

Die folgenden Ausführungen beziehen sich auch den AT90S2313. Für andere
Modelltypen müsst ihr euch die allenfalls notwendigen Anpassungen aus den
Datenblättern der entsprechenden Controller herauslesen.

Wir unterscheiden grundsätzlich zwischen 8-Bit Timern, welche eine
Auflösung von 256 aufweisen und 16-Bit Timern mit (logischerweise) einer
Auflösung von 65536.

Als Eingangstakt für die Timer/Counter kann entweder die CPU-Taktfrequenz,
der Vorteiler-Ausgang oder ein an einen I/O-Pin angelegtes Signal verwendet
werden. Wenn ein externes Signal verwendet wird, so darf dessen Frequenz nicht
höher sein als die Hälfte des CPU-Taktes.

=== Der Vorzähler (Prescaler) ===

Beide Timer/Counter werden im Timerbetrieb über den gleichen Vorzähler
versorgt.

Der Vorzähler dient dazu, den CPU-Takt vorerst mal runter zu brechen auf eine
wählbare Teilung. Die so geteilte Frequenz wird den Eingängen der Timer
zugeführt.

Wenn wir mit einer einem CPU-Takt von 4 MHz arbeiten und den Vorteiler auf 1024
einstellen wird also der Timer mit einer Frequenz von 4 MHz / 1024, also mit ca.
4 kHz versorgt. Wenn also der Timer läuft, so wird das Daten- bzw.
Zählregister mit dieser Frequenz inkrementiert.

== 8-Bit Timer/Counter ==

Alle AVR-Modelle weisen mindestens einen, teilweise sogar zwei, 8-Bit Timer
auf.

Der 8-Bit Timer wird über folgende Register angesprochen:

{| border="1"
|-
| '''TCCR0'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
Timer '''0'''

In diesem Register stellen wir ein, wie wir den Timer/Counter verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CS02'''
| align="center" | '''CS01'''
| align="center" | '''CS00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''CS02, CS01, CS00''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS02
| align="center" | CS01
| align="center" | CS00
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin '''TO''', fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin '''TO''', steigende Flanke
|}
</dd>
</dl>
:Wenn als Quelle der externe Pin '''TO''' verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin '''TO''' als Ausgang geschaltet ist.

|-
| '''TCNT0'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer '''0''' 
Dieses ist als 8-Bit Aufwärtszähler mit Schreib- und Lesezugriff
realisiert. Wenn der Zähler den Wert 255 erreicht hat beginnt er beim
nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}
|}

Um nun also den Timer0 in Betrieb zu setzen und ihn mit einer Frequenz von 1/1024-tel des CPU-Taktes zählen zu lassen, schreiben wir die folgende Befehlszeile:

<pre class="code">
TCCR0 = (1<<CS00)|(1<<CS02);
</pre>

Der Zähler zählt nun aufwärts bis 255, um dann wieder bei 0 zu beginnen. Der aktuelle Zählerstand steht in TCNT0. Bei jedem Überlauf von 255 auf 0 wird das Timer Overflow Flag '''TOV0''' im Timer Interrupt Flag '''TIFR'''-Register gesetzt und, falls so konfiguriert, ein entsprechender Timer-Overflow-Interrupt ausgelöst.

== 16-Bit Timer/Counter ==

Viele AVR-Modelle besitzen ausser den 8-Bit Timers auch einen oder sogar zwei
(einige ATmega-Modelle) 16-Bit Timer.

Die 16-Bit Timer/Counter sind wesentlich komplexer aufgebaut als die 8-Bit
Timer/Counter, bieten dafür aber auch viel mehr Möglichkeiten, als da sind:

* Die [[PWM]]-Betriebsart Erzeugung eines pulsweitenmodulierten Ausgangssignals.
* Vergleichswert-Überprüfung mit Erzeugung eines Ausgangssignals (Output Compare Match).
* Einfangen eines Eingangssignals mit Speicherung des aktuellen Zählerwertes (Input Capturing), mit zuschaltbarer Rauschunterdrückung (Noise Filtering).

Folgende Register sind dem Timer/Counter 1 zugeordnet:

{| border="1"
|-
| '''TCCR1A'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''A''' Timer '''1''' 
In diesem und dem folgenden Register stellen wir ein, wie wir den Timer/Counter verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''COM1A1''', '''COM1A0''' ('''Co'''mpare '''M'''atch Control Bits)
:Diese 2 Bits bestimmen die Aktion, welche am Output-Pin '''OC1''' ausgeführt werden soll, wenn der Wert des Datenregisters des Timer/Counter 1 den Wert des Vergleichsregisters erreicht, also ein so genannter Compare Match auftritt.
:Der Pin '''OC1''' ('''PB3''' beim 2313) muss mit dem Datenrichtungsregister als Ausgang konfiguriert werden.

<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Das Signal am Pin '''OC1''' wird invertiert (Toggle).
|-
| align="center" | 1
| align="center" | 0
| Der Output Pin '''OC1''' wird auf 0 gesetzt.
|-
| align="center" | 1
| align="center" | 1
| Der Output Pin '''OC1''' wird auf 1 gesetzt.
|}
</dd></dl>
:In der PWM-Betriebsart haben diese Bits eine andere Funktion.
<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 1
| align="center" | 0
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 0 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 1 gesetzt.

Man nennt dies ''nicht invertierende PWM''.
|-
| align="center" | 1
| align="center" | 1
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 1 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 0 gesetzt.

Man nennt dies ''invertierende PWM''.
|}
</dd></dl>

'''PWM11''', '''PWM10''' ('''PWM''' Mode Select Bits)
:Mit diesen 2 Bits wird die PWM-Betriebsart des Timer/Counter 1 gesteuert.
<dl><dd>
{| border="1"
|-
| align="center" | PWM11
| align="center" | PWM10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Die PWM-Betriebsart ist nicht aktiviert. Timer/Counter 1 arbeitet als normaler Timer bzw. Zähler.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM Betriebsart aktivieren.
|}
</dd></dl>
|-
| '''TCCR1B'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''B''' Timer '''1'''

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ICNC1'''
| align="center" | '''ICES1'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CTC1'''
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''ICNC1''' ('''I'''nput '''C'''apture '''N'''oise '''C'''anceler (4 CKs) Timer/Counter 1
:oder auf Deutsch Rauschunterdrückung des Eingangssignals.
:Wenn dieses Bit gesetzt ist und mit dem Input Capture Signal gearbeitet wird so werden nach der Triggerung des Signals mit der entsprechenden Flanke (steigend oder fallend) am Input Capture Pin '''ICP''' jeweils 4 Messungen mit der CPU-Frequenz des Eingangssignals abgefragt. Nur dann, wenn alle 4 Messungen den gleichen Zustand aufweisen gilt das Signal als erkannt.

'''ICES1''' ('''I'''nput '''C'''apture '''E'''dge '''S'''elect Timer/Counter '''1''')
:Mit diesem Bit wird bestimmt, ob die steigende ('''ICES1'''=1) oder fallende ('''ICES1'''=0) Flanke zur Auswertung des Input Capture Signals an Pin '''ICP''' heran gezogen wird.

'''CTC1''' ('''C'''lear '''T'''imer/'''C'''ounter on Compare Match Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, so wird nach einer Übereinstimmung des Datenregisters '''TCNT1H'''/'''TCNT1L''' mit dem Vergleichswert in '''OCR1H'''/'''OCR1L''' das Datenregister '''TCNT1H'''/'''TCNT1L''' auf 0 gesetzt.
:Da die Übereinstimmung im Takt nach dem Vergleich behandelt wird, ergibt sich je nach eingestelltem Vorzähler ein etwas anderes Zählverhalten:
:Wenn der Vorteiler auf 1 gestellt ist und C der jeweilige Zählerwert ist, dann nimmt das Datenregister, im CPU-Takt betrachtet, folgende Werte an:
:... | C-2 | C-1 | C | 0 | 1 |...
:Wenn der Vorteiler z.B. auf 8 eingestellt ist, dann nimmt das Datenregister folgende Werte an:
:... | C-2, C-2, C-2, C-2, C-2, C-2, C-2, C-2 | C-1, C-1, C-1, C-1, C-1, C-1, C-1, C-1 | C, 0, 0, 0, 0, 0, 0, 0 |...
:In der PWM-Betriebsart hat dieses Bit keine Funktion.

'''CS12''', '''CS11''', '''CS10''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS12
| align="center" | CS11
| align="center" | CS10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin TO, fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin T0, steigende Flanke
|}
</dd></dl>
:Wenn als Quelle der externe Pin T0 verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin T0 als Ausgang geschaltet ist.
|-
| '''TCNT1H''' '''TCNT1L'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer/Counter '''1'''
Dieses ist als 16-Bit Aufwärtszähler mit Schreib- und Lesezugriff realisiert. Wenn der Zähler den Wert 65535 erreicht hat, beginnt er beim nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''TCNT1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''TCNT1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

In der PWM-Betriebsart wird das Register als Auf/Ab-Zähler verwendet, d.h. der Wert steigt zuerst von 0 bis er den Überlauf von 65535 auf 0 erreicht hat. Dann zählt das Register rückwärts wiederum bis 0.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.

Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''OCR1H''' '''OCR1L'''
| Timer/Counter '''O'''utput '''C'''ompare '''R'''egister Timer/Counter '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''OCR1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''OCR1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Der Wert im Output Compare Register wird ständig mit dem aktuellen Wert im Datenregister TCNT1H/TCNT1L verglichen. Stimmen die beiden Werte überein, so wird ein sogenannter Output Compare Match ausgelöst. Die entsprechenden Aktionen werden über die Timer/Counter 1 Control und Status Register eingestellt.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''ICR1H''' '''ICR1L'''
| Timer/Counter '''I'''nput '''C'''apture '''R'''egister Timer/Counter '''1''' 
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''ICR1''''''H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''ICR1''''''L'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Das Input Capture Register ist ein 16-Bit Register mit Lesezugriff. Es kann nicht beschrieben werden.

Wenn am Input Capture Pin '''ICP''' die gemäß Einstellungen im '''TCCR1B''' definierte Flanke erkannt wird, so wird der aktuelle Inhalt des Datenregisters '''TCNT1H'''/'''TCNT1L''' sofort in dieses Register kopiert und das Input Capture Flag '''ICF1''' im Timer Interrupt Flag Register '''TIFR''' gesetzt.

Wie bereits oben erwähnt, müssen vor dem Zugriff auf dieses Register alle Interrupts gesperrt werden. Zudem müssen Low- und Highbyte des Registers in der richtigen Reihenfolge bearbeitet werden:

{| border="0"
|-
| Lesen:
| '''ICR1L''' -> '''ICR1H'''
|-
| Schreiben:
| '''ICR1H''' -> '''ICR1L'''
|}
|}

=== Die PWM-Betriebsart ===

Wenn der Timer/Counter 1 in der PWM-Betriebsart betrieben wird, so bilden das Datenregister '''TCNT1H'''/'''TCNT1L''' und das Vergleichsregister '''OCR1H'''/'''OCR1L''' einen 8-, 9- oder 10-Bit, frei laufenden PWM-Modulator, welcher als PWM-Signal am '''OC1'''-Pin ('''PB3''' beim 2313) abgegriffen werden kann. Das Datenregister '''TCNT1H'''/'''TCNT1L''' wird dabei als Auf-/Ab-Zähler betrieben, welcher von 0 an aufwärts zählt bis zur Obergrenze und danach wieder zurück auf 0.
Die Obergrenze ergibt sich daraus, ob 8-, 9- oder 10-Bit PWM verwendet wird, und zwar gemäss folgender Tabelle:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Wenn nun der Zählerwert im Datenregister den in '''OCR1H'''/'''OCR1L''' gespeicherten Wert erreicht, wird der Ausgabepin '''OC1''' gesetzt bzw. gelöscht, je nach Einstellung von '''COM1A1''' und '''COM1A0''' im '''TCCR1A'''-Register.

Ich habe versucht, die entsprechenden Signale in der folgenden Grafik zusammenzufassen

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

=== Vergleichswert-Überprüfung ===

Hier wird in ein spezielles Vergleichswertregister ('''OCR1H'''/'''OCR1L''') ein Wert eingeschrieben, welcher ständig mit dem aktuellen Zählerwert verglichen wird.
Erreicht der Zähler den in diesem Register eingetragenen Wert, so kann ein Signal (0 oder 1) am Pin '''OC1''' erzeugt und/oder ein Interrupt ausgelöst werden.

=== Einfangen eines Eingangssignals (Input Capturing) ===

Bei dieser Betriebsart wird an den Input Capturing Pin (ICP) des Controllers eine Signalquelle angeschlossen.
Nun kann je nach Konfiguration entweder ein Signalwechsel von 0 nach 1 (steigende Flanke) oder von 1 nach 0 (fallende Flanke) erkannt werden und der zu diesem Zeitpunkt aktuelle Zählerstand in ein spezielles Register abgelegt werden. Gleichzeitig kann auch ein entsprechender Interrupt ausgelöst werden.
Wenn die Signalquelle ein starkes Rauschen beinhaltet, kann die Rauschunterdrückung eingeschaltet werden. Dann wird beim Erkennen der konfigurierten Flanke über 4 Taktzyklen das Signal überwacht und nur dann, wenn alle 4 Messungen gleich sind, wird die entsprechende Aktion ausgelöst.

== Gemeinsame Register ==

Verschiedene Register beinhalten Zustände und Einstellungen, welche sowohl
für den 8-Bit, als auch für den 16-Bit Timer/Counter in ein und demselben
Register zu finden sind.

{| border="1"
|-
| '''TIMSK'''
| '''T'''imer/Counter '''I'''nterrupt '''M'''a'''sk'''
Register

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOIE1'''
| align="center" | '''OCIE1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''TICIE'''
| align="center" | '''-'''
| align="center" | '''TOIE0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOIE1''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 1 ein Timer Overflow 1 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''OCIE1A''' ('''O'''utput '''C'''ompare Match '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Beim Timer/Counter 1 kann zusätzlich zum Überlauf ein Vergleichswert definiert werden.

:Wenn dieses Bit gesetzt ist, wird beim Erreichen des Vergleichswertes ein Compare Match Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TICIE''' ('''T'''imer/Counter '''I'''nput '''C'''apture '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein Capture Event Interrupt ausgelöst, wenn ein entsprechendes Signalereignis am Pin PD6(ICP) auftritt. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein, wenn auch ein entsprechender Interrupt ausgelöst werden soll.

'''TOIE0''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''0''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 0 ein Timer Overflow 0 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

|-
| '''TIFR'''
| '''T'''imer/Counter '''I'''nterrupt '''F'''lag '''R'''egister

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOV1'''
| align="center" | '''OCF1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''ICF1'''
| align="center" | '''-'''
| align="center" | '''TOV0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOV1''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''1''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 1 ein Überlauf des Datenregisters stattfindet.

:In der PWM-Betriebsart wird das Bit gesetzt, wenn die Zählrichtung von auf- zu abwärts und umgekehrt geändert wird (Zählerwert = 0).

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''OCF1A''' ('''O'''utput '''C'''ompare '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn der aktuelle Wert des Datenregisters von Timer/Counter 1 mit demjenigen im Vergleichsregister '''OCR1''' übereinstimmt.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''ICF1''' ('''I'''nput '''C'''apture '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn ein Capture-Ereignis aufgetreten ist, welches anzeigt, dass der Wert des Datenregisters des Timer/Counter 1 in das Input Capture Register ICR1 übertragen wurde.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''TOV0''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''0''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 0 ein Überlauf des Datenregisters stattfindet.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.
|}

 

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sog. ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comperators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrups den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

* '''set_sleep_mode(uint8_t mode)'''
:Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z.B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
* '''sleep_mode()'''
:Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus.

<pre class="code">
#include <avr/io.h>
#include <avr/sleep.h>
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach auftreten eines entsprechenden "Aufwach-Interrupts" verarbeitet
...
</pre>

Vorsicht: Nicht alle AVR-Controller (v.a. nicht die "Brandneuen") werden von den avr-libc sleep-Funktionen richtig angesteuert. Bei nicht-untersützten Typen erreicht man die gewollte Funktionalität durch direkte "Bitmanipulation" der ensprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler:

<pre class="code">
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep");
...
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes

= Der Watchdog =

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der Watchdog.

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln.

Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

Betrachten wir doch einmal folgende Codesequenz:

<pre class="code">
uint8_t x;

x = 10;

while (x >= 0) {
// tu was

x--;
}
</pre>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm würde sich also hier aufhängen und auf ewig in der Schleife drehen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde beginnt der Counter von 0 an hochzuzählen. Wenn nun die je nach Vorteiler eingestellte Anzahl Zyklen erreicht wurde, löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern müssen wir den Watchdog regelmässig wieder neu starten bzw. Rücksetzen (Watchdog Reset). Dies sollte innerehalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern muss ein spezielles Prozedere verwendet werden, um den WD auszuschalten und zwar müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden. Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| border="1"
|-
| '''WDTCR'''
| '''W'''atchog '''T'''imer  '''C'''ontrol '''R'''egister

In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''WDTOE'''
| align="center" | '''WDE'''
| align="center" | '''WDP2'''
| align="center" | '''WDP1'''
| align="center" | '''WDP0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''WDTOE''' ('''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable)
:Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
:Wenn das Bit einmal gesetzt ist wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.

'''WDE''' ('''W'''atch'''d'''og '''E'''nable)
:Wenn dieses Bit gesetzt wird, so wird der Watchdog aktiviert.
:Das Bit kann nur gelöscht werden, solange das Bit '''WDTOE''' auf 1 steht.

'''WDP2''', '''WDP1''', '''WDP0''' ('''W'''atch'''d'''og Timer '''P'''rescaler Bits)
:Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:
<dl><dd>
{| border="1"
|-
| align="center" | WDP2
| align="center" | WDP1
| align="center" | WDP0
| align="center" | Anzahl Zyklen
| align="center" | Typ. Timeoutzeit bei Vcc = 3V
| align="center" | Typ. Timeoutzeit bei Vcc = 5V
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 16K
| align="center" | 47ms
| align="center" | 15ms
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 32K
| align="center" | 94ms
| align="center" | 30ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 64K
| align="center" | 0.19s
| align="center" | 60ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 128K
| align="center" | 0.38s
| align="center" | 0.12s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 256K
| align="center" | 0.75s
| align="center" | 0.24s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 512K
| align="center" | 1.5s
| align="center" | 0.49s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 1024K
| align="center" | 3s
| align="center" | 0.97s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 2048K
| align="center" | 6s
| align="center" | 1.9s
|}
</dd></dl>
|}

Um den Watchdog mit dem AVR-GCC Compiler zu verwenden, muss die Headerdatei wdt.h in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

* '''wdt_enable(uint8_t timeout)'''
:Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert (z.B. WDTO_30MS).
* '''wdt_disable()'''
:Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
* '''wdt_reset()'''
:Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Ein paar grundsätzliche Gedanken ==

Ob nun so ein Watchdog überhaupt verwendet werden soll, ist wohl eher eine
philosophische Frage und hängt vom Geschmack jedes einzelnen Entwicklers ab.

Ich persönlich habe es lieber, wenn ich auch merke, dass in meine Programm
etwas noch nicht in Ordnung ist, als dass mir ein Watchdog einfach die CPU immer
wieder zurücksetzt, denn immerhin kann es so passieren, dass ein Programm über
Jahre hinweg so einigermassen läuft, obwohl noch ein voll krasser Bock drin
liegt.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Watchdog timer handling

= Programmieren mit Interrupts =

Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

[[Image:Interrupt Programme.gif]]

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

== Anforderungen an die Interrupt-Routine ==

Um unliebsamen Überraschungen vorzubeugen sollten einige Grundregeln bei
der Gestaltung der Interruptroutinen beachtet werden.

* Die Interruptroutine soll möglichst kurz und schnell abarbeitbar sein, daraus folgt:
* Keine unfangreichen Berechnungen innerhalb der Interruptroutine.
* Keine endlos langen Programmschleifen.
* Obschon es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen rate ich dringend von solchen Spielen ab.

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf dem AVR auslösen, wobei
die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

== Register ==

Der AT90S2313 verfügt über 2 Register welche mit den
Interrupts zusammen hängen.

{| border="1"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INT1'''
| align="center" | '''INT0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INT1''' (External '''Int'''errupt Request '''1''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

'''INT0''' (External '''Int'''errupt Request '''0''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INTF1'''
| align="center" | '''INTF0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INTF1''' (External '''Int'''errupt Flag '''1''')
:Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.

'''INTF0''' (External '''Int'''errupt Flag '''0''')
:Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister.

Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''SE'''
| align="center" | '''SM'''
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''SE''' ('''S'''leep '''E'''nable)
:Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl in den Schlafzustand versetzen zu können.
:Um den Schlafmodus nicht irrtümlich einzuschalten, wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.

'''SM''' ('''S'''leep '''M'''ode)
:Dieses Bit bestimmt der Schlafmodus.
:Ist das Bit gelöscht, so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt, so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")

'''ISC11''', '''ISC10''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.
<dl><dd>
{| border="1"
|-
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}
</dd></dl>
'''ISC01''', '''ISC00''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

<dl><dd>
{| border="1"
|-
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}
</dd></dl>
|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft, wird automatisch das '''Global
Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle
weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem
Zeitpunkt bereits wieder das GIE-bit zu setzen, rate ich dringend davon ab. Dieses
wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn
in der Zwischenzeit weitere Interrupts eintreffen, werden die zugehörigen
Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden
Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt
ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle
anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe,
weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.

=== Das Status-Register ===

Es gilt auch zu beachten, dass das Status-Register während der Abarbeitung
einer Interruptroutine nicht automatisch gesichert wird. Falls notwendig, muss dies vom
Programmierer selber vorgesehen werden.

== Interrupts mit dem AVR GCC Compiler (WinAVR) ==

Selbstverständlich können alle Interruptspezifischen Registerzugriffe wie gewohnt über I/O-Adressierung vorgenommen werden. Etwas einfacher geht es jedoch, wenn wir die vom Compiler zur Verfügung gestellten Mittel einsetzen.

Damit diese Mittel zur Verfügung stehen, müssen wir die Includedatei ''interrupt.h'' und evtl. ''signal.h'' einbinden mittels:

<pre class="code">
// fuer sei(), cli() und INTERRUPT():
#include <avr/interrupt.h>

// fuer SIGNAL() auch:
#include <avr/signal.h>
</pre>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird
nichts anderes gemacht, als das '''Global Interrupt Enable''' Bit im Status
Register gesetzt.

<pre class="code">
sei();
</pre>

Das Makro '''cli()''' schaltet die Interrupts aus, oder anders
gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird
gelöscht.
<pre class="code">
cli();
</pre>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf.
Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen.
Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren
und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen
Zustands die Interrups aktivieren, was zu unerwünschten Seiteneffekten führen kann.
Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern */

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD); // 2 mal in Folge , vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
...

}
</pre>



Nachdem nun die Interrupts aktiviert sind, braucht es selbstverständlich noch den auszuführenden Code, der ablaufen soll, wenn ein Interrupt eintrifft. Dazu gibt es zwei Definitionen: '''SIGNAL''' und '''INTERRUPT''', welche allerdings AVR-GCC spezifisch sind und bei anderen Compilern womöglich anders heissen können.

=== SIGNAL ===

<pre class="code">
#include <avr/signal.h>
...
SIGNAL (siglabel)
{
/* Interrupt Code */
}
</pre>

Mit ''SIGNAL'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektoren angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Vor Nutzung von SIGNAL muss die Header-Datei signal.h eingebunden werden. Mögliche Funktionsrümpfe für solche Interruptfunktionen sind zum Beispiel:

<pre class="code">
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

SIGNAL (SIG_OVERFLOW1)
{
/* Interrupt Code */
}

SIGNAL (SIG_UART_RECV)
{
/* Interrupt Code */
}

// und so weiter und so fort...
</pre>

Während der Ausführung des Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten, so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== INTERRUPT ===

<pre class="code">
#include <avr/interrupt.h>
...
INTERRUPT (signame)
{
/* Interrupt Code */
}
</pre>

Mit INTERRUPT wird genau gleich gearbeitet wie mit SIGNAL. Der Unterschied ist derjenige, dass bei INTERRUPT beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit automatisch wieder gesetzt und somit weitere Interrupts zugelassen werden. Dies kann zu nicht unerheblichen Problemen von im einfachsten Fall einem Stack overflow bis zu sonstigen unerwarteten Effekten führen und sollte wirklich '''nur dann''' angewendet werden, wenn man sich absolut sicher ist, das Ganze auch im Griff zu haben. Vor Nutzung von INTERRUPT muss die Header-Datei interrupt.h eingebunden werden.

Interruptroutinen (ISRs) sollten möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern des Zustands aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen, s.u.). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

siehe auch: Hinweise in [[AVR-GCC]]

== Datenaustausch mit Interrupt-Routinen ==

Variablen auf die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen wird und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte die Code-Optimierung "greifen" und der Wert der Variablen nur in Prozessorregistern zwischenspeichert werden, die "nichts von der Änderung woanders mitbekommen".

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z.B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt z.B. alle 10ms
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
// hier wird gKeyCounter veraendert, die uebrigen
// Programmteile muessen diese Aenderung "sehen"
// (volatile -> aktuellen Wert immer in den Speicher schreiben)
if ( !(KEY_PIN & (1<<KEY_PINNO)) )
if (gKeyCouter < CNTREPEAT) gKeyCounter++;
else gKeyCounter = 0;
}

...

int main(void)
{
...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
...
// hier wird auf gKeyCounter zugegriffen, dazu muss der in der
// ISR geschrieben Wert bekannt sein.
// (volatile -> aktuellen Wert immer aus dem Speicher lesen)
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt"
}
else {
/* hier: Code fuer "Taste kurz gedrueckt"
}
...
}
</pre>

Bei Variablen größer ein Byte muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes ausserhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<pre class="code">
...
volatile uint16_t gMyCounter16bit
...
SIGNAL(...)
{
...
gMyCounter16Bit++;
...
}

int main(void)
{
uint16_t tmpCnt;
...
// nicht gut: mglw. hier ein Fehler wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor Kopieren des zweiten Bytes
// ein Interrupt auftritt der den Inhalt von MyCounter veraendert
tmpCnt = gMyCounter16bit;

// besser: Aenderungen "ausserhalb" verhindern, alle "Teilbytes"
// bleiben konsistent
cli(); // Interupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren
...
}
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8 (Stand: avr-libc Vers. 1.0.4)

== Was macht das Hauptprogramm ==

Im einfachsten Fall gar nichts mehr.

Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der
main-Funktion lediglich noch die Interrupts aktiviert und dann in eine
Endlosschleife folgender Art verzweigt:

<pre class="code">
...
for (;;) {}
...
</pre>

Normalerweise wird man allerdings in den Interruptroutinen die Interrupts
erfassen und im Hauptprogramm dann gemütlich auswerten.

Wie wir im bisherigen Kursverlauf gesehen haben ist es ohnehin mit so
schnellen Controller meistens gar nicht unbedingt notwendig mit
Interruptfunktionen zu arbeiten. 
Es ist allerdings auch zu bemerken, dass mit den Interruptroutinen ein Programm
sehr schön strukturiert werden kann, wenn man es richtig macht.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (eigentlich [[SRAM]]) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als [[FLASH]]-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z.B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin wenig Sinn macht und auch nur bei einigen RAM-losen Typen nach "Bastelarbeiten" möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory). Die Standard-Laufzeitbibliothek des avr-gcc, die [[avr-libc]], stellt diese Funktionen nach einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Einige Beispiele:

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray1 };
...
</pre>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<pre class="code">
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte...
}
</pre>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel, jedoch mit der Funktion pgm_read_word.

<pre class="code">
uint16_t myWord;

myWord = pgm_read_word(&pgmFooWord);
</pre>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "gross". (Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.) Pointer müssen gegebenenfalls "gecastet" werden.

<pre class="code">
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray1

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray2
// da im zweiteb Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmPointerToArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</pre>

=== Floats und Structs lesen ===

Um komplexe Datentypen (structs), nicht-integer Datentypen (floats) aus dem Flash auszulesen, sind Hilfsfunktionen erforderlich. Einige Beispiele:

<pre class="code">

/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
...

/* liest float von Flash-Addresse addr und gibt diese als return-value zurueck */
inline float pgm_read_float(const float *addr)
{
union
{
uint16_t i[2]; // 2 16-bit-Worte
float f;
} u;

u.i[0]=pgm_read_word((PGM_P)addr);
u.i[1]=pgm_read_word((PGM_P)addr+2);

return u.f;
}
...

void egal(void)
{
int i;
float f;

for (i=0;i<3;i++) {
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach' was mit f
}
}
</pre>

TODO: Beispiele fuer structs und pointer aus flash auf struct im flash (menues, state-machines etc.)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuerht, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
...
</pre>

Aber Achtung: Ersetzt man zum Beispiel
<pre class="code">
const char textImFlash[] PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
durch
<pre class="code">
const char textImFlash* PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der textImFlash zu den Konstanten ans Ende des Programmcodes gelegt wird, von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte. Da der lesende Code trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein Bug des AVR-GCC (gesehen bei 3.4.1) zu sein.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<pre class="code">
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
...
</pre>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z.B. 0x01fe), "weiss" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, das der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000) wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z.B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmässig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, das vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgeben sind ("timed sequence"). Diese Prüfung wird nicht implizit durchgeführt. Im Zweifel kann man Sicherheitshalber bei EEPROM-Zugriffen die Interrupts global deaktivieren, z.B. so:

<pre class="code">
...
uint8_t sreg;
...

sreg = SREG;
cli();

/* hier die eeprom-Zugriffe */

SREG = sreg;
...
</pre>

Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Die Nutzung einer [[C-Präprozessor]]-Ersetzung bringt etwas Bequemlichkeit. Siehe dazu folgendes Beispiel.

<pre class="code">
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h>

// alle Textstellen EEPROM im Quellcode durch __attribute__ ... ersetzen
#define EEPROM __attribute__ ((section (".eeprom")))

...

/* Byte */
uint8_t eeFooByte EEPROM = 123;

/* Wort */
uint16_t eeFooWort EEPROM = 12345;

/* float */
float eeFooFloat EEPROM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEPROM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEPROM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */

uint16_t eeFooWordArray1[4] EEPROM;
...
</pre>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heisst eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<pre class="code">
...
uint8_t myByte;
uint8_t sreg;

sreg = SREG; // (1)
cli(); // (1)

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
...
SREG = sreg; // (1)
</pre>

Die mit (1) markierten Zeilen dienen hierbei dem (möglicherweise übertriebenen) Schutz vor Unterbrechnungen durch Interrupts.

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<pre class="code">
...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
...
</pre>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprueft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und mglw. noch mehr.

<pre class="code">
...
unit8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes aber der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnuetze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray[0],3);

/* dito mit etwas Absicherung betr. der Laenge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));

/* Datenlock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));
...
</pre>

"Nicht-Integer"-Datentypen wie z.B. Fliesskommazahlen lassen sich recht praktisch ueber eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<pre class="code">
...
float myFloat = 12.34;

union {
float r;
uint8_t n[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */
...
</pre>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<pre class="code">
...
typedef struct {
uint8_t label[8];
unin8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEPROM;

...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
...
}
...
</pre>

=== EEPROM-Speicherabbild in .eep-Datei ===

Eine besondere Funktion des avr-gcc ist, dass mit einem entsprechenden makefile aus den Initialisierungswerten der Variablen im Quellcode eine Datei erzeugt werden kann, die man auf den Controller programmieren kann (.eep-Datei). Damit können sehr elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Die Vorgehensweise wird aus dem WinAVR-Beispielmakefile ersichtlich. Siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles.

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Nicht alle neuen AVR Controller werden von avr-libc/eeprom.h untersützt (Stand Version 1.0.4). Insbesondere beim ATMega169 funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register) Etwas ältere Typen, oder zu den "etablierten" Controllern kompatible, bereiten jedoch hier keine Proleme. Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Der dort gezeigt Code kann direkt auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste").

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gcc-Toolchain" bietet dazu zwei Möglichkeiten:

;Inline-Assembler:
Die Assembleranweisungen werden in direkt in den C-Code integriert. Eine Quellcode-Datei enhält somit C- und Assembleranweisungen

;Assembler-Dateien:
Der Assembler-Codecode befindet sich in eigenen Quellcodedateien. Dieser werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z.B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen eine NOP-Anweisung. NOP steht für '''NO'''-O'''P'''eration. Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=warte)-Funktionen.

<pre class="code">
...
/* Verzoegern der weiteren Programmausfuehrung um
genau 3 Taktzyklen */
asm volatile ("nop"::);
asm volatile ("nop"::);
asm volatile ("nop"::);
...
</pre>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeindlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<pre class="code">
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i=0;i<1000;i++);

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i=0;i<1000;i++) asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j=0;j<1000;j++);
</pre>

Ein weiterer nützliche "Assembler-Einzeiler" ist der Auruf von sleep (''asm volatile ("sleep"::);''), da hierzu keine eigene Funktion in der avr-libc existiert.

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil des die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<pre class="code">
static inline void delayloop16(uint16_t count)
{
asm volatile ( "cp %A0,__zero_reg__ \n\t" \
"cpc %B0,__zero_reg__ \n\t" \
"breq L_Exit_%= \n\t" \
"L_LOOP_%=: \n\t" \
"sbiw %0,1 \n\t" \
"brne L_LOOP_%= \n\t" \
"L_Exit_%=: \n\t" \
: "=w" (count)
: "0" (count)
);
}
</pre>

* Jede Zeile wird mit '''\n\t''' abgeschlossen, alle Zeilen mit '''\''' verbunden.
* Sprung-Marken (labels) werden mit einm Prozentzeichen abgeschlossen, der Präprozessor (Assembler?) setzt an dieser Stelle eine laufende Nummer ein, die Doppelbezeichnungen bei mehrmaliger Verwendung somit verhindert.

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc.

* siehe auch: Dokumentation der avr-libc/Related Pages/Inline Asm
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

...TODO: Beispiele, Parameteruebergabe, globale Variablen für Datenaustausch

= TODO =

stdio.h, malloc() ???, Code-Optimierungen ("tricks"), "naked"-Functionen ??, IO-Register als Parameter/"Variablen" (volatile uint8_t *mybusport; mybusport=&PORTB; void sendbus(uint8_t *parm)...)

= C-Code und Bibliotheken für externe Baugrupen =
(TODO: sollte in avr-gcc verschoben werden)
[[Linksammlung#Avr]]

==LCD==
=== Text (character-mode) HD44870 ===
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray

=== Grafik-LCD ===
==== Nokia3310 ====
==== Nokia 6100 LCD ====
Das Nokia ist ein 132x132x4096 Farben Display das bei eBay ziemlich preiswert ersteigert werden kann.
[http://www.apetech.de/nokia6100.php Nokia 6100 LCD Library]
==== KS0108 ====
* Procyon avrlib (GPL)
* avrfreaks UP
* apetech.de
==Schnittstellen==
===I2C===
====Master====
[http://jump.to/fleury/ P. Fleurys I2C Master library]
====Slave====

===CAN===
* [http://www.atmel.com] Codesammlung zum AT90CAN128

=== DS18S20/1-Wire ===
* avrfreaks Projekt 59
* mikrocontroller.net/codesammlung (P. Dannegger)

=== UART ===
* Procyon avrlib (GPL)
* avrfreaks UP (viele viele)
* P. Fleury

== Speicherkarten/IDE/FAT ==
* avrfreaks UP (IDE/FAT read write)
== CRC ==
* avrfreaks-forum (O'Flynn)
* avr-hal (GPL)

AVR-GCC-Tutorial

2004-11-12T13:29:23Z

Oxygene: /* Programmieren mit Interrupts */

[[Category:AVR]]

= Vorwort =

Dieses Tutorial soll Einsteigern helfen, mit der Programmiersprache '''C''' die Mikrocontroller der Atmel AVR-Reihe zu programmieren.


Die ursprüngliche Version stammt von Christian Schifferle, die meisten aktuellen Anpassungen von [[Benutzer:Mthomas]]. Viele der im Original-Dokument verwendeten Funktionen sind in
aktuellen Versionen des avr-gcc C-Compilers und der avr-libc zwar noch enthalten,
aber als überholt (''deprecated'') ausgewiesen. D.h. diese Funktionen sollten nicht mehr verwendet
werden und existieren in zukünftigen Versionen des Compilers/der Library nicht mehr
(z.B. sbi(), cbi(), outp(), inp()). Der Artikel wurde auf die neuen Funktionen/Methoden
angepasst.

In diesem Text wird häufig auf die Standardbibliothek für den avr-gcc-Compiler, die avr-libc, verwiesen. Die '''Dokumentation der avr-libc''' findet sich
[http://www.nongnu.org/avr-libc/user-manual/index.html hier]. Bei WinAVR gehört diese Dokumentation zum Lieferumfang und wird mitinstalliert.

= Benötigte Werkzeuge =

Um die Übungen in diesem Tutorial nachvollziehen zu können benötigen wir folgende Hard- und Software:

* Testboard für die Aufnahme eines AVR Controllers, der vom gcc Compiler untersützt wird (alle ATmegas und die meisten AT90). Dieses Testboard kann durchaus auch selber zusammen gelötet werden. So arbeite ich mit einem Testboard, welches ich mir auf einer Veroboard-Platine zusammen gestellt habe. Für die Versuche bzw. Übungen in diesem Tutorial habe ich jeweils einen AT90S2313 verwendet. Eine brauchbare Testplattform ist auch der [[AVR Butterfly]].
* AVRGCC-Compiler. Kostenlos erhältlich für nahezu alle Plattformen/Betriebssysteme. Für MS-Windows im Packet [[WinAVR]]; für Unix/Linx siehe auch Hinweise im Artikel [[AVR-GCC]].
* Programmiersoftware und Hardware z.B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], [[AVR-Studio]]).
* Nicht unbedingt erforderlich aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Abschnitt Exkurs: makefiles).

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.
* Die [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently Asked Questions = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.
* Das gcc-Forum auf [http://www.mikrocontroller.net www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.
* Das avr-gcc-Forum bei [http://www.avrfreaks.net avrfreaks] nach vergleichbaren Problemen absuchen.
* Das [http://www.avr1.org/pipermail/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.
* Nach Beispielcode suchen. Vor allem in der Academy von [http://www.avrfreaks.net AVRFREAKS] (anmelden).
* Google oder alltheweb befragen schadet nie.
* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal)
* einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei mgl. viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode, genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z.B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: [http://www.lugbz.org/documents/smart-questions_de.html "Wie man Fragen stellt"].

= Exkurs: makefiles =

Wenn man bisher gewohnt ist, mit integrierten Entwicklungsumgebung à la Visual-C Programme zu erstellen, wirkt das makefile-Konzept auf den ersten Blick etwas kryptisch. Nach kurzer Einarbeitung ist diese Vorgehensweise jedoch sehr praktisch. Diese Dateien (üblicher Name: 'Makefile' ohne Dateiendung) dienen der Ablaufsteuerung des Programms make, das auf allen Unix/Linux-Systemen installiert sein sollte, und in einer Fassung fuer MS-Windows auch in [[WinAVR]] (Unterverzeichnis utils/bin) enthalten ist.

Im Unterverzeichnis ''sample'' einer WinAVR-Installation findet man eine sehr brauchbare Vorlage, die sich einfach an das eigene Projekt anpassen lässt ([[Media:Makefile|lokale Kopie Stand Sept. 2004]]). Wahlweise kann man auch [http://www.sax.de/~joerg/mfile/ mfile] von Jörg Wunsch nutzen. mfile erzeugt ein makefile nach Einstellungen in einer grafischen Nutzeroberfläche, wird bei WinAVR mitinstalliert, ist aber als TCL/TK-Programm auf nahezu allen Platformen lauffähig.

''Die folgenden Ausführungen beziehen sich auf das WinAVR Beispiel-Makefile.''

Ist im Makefile alles richtig eingestellt genügt es, sich drei Parameter zu merken, die über die shell bzw. die Windows-Kommandozeile (cmd.exe/command.exe) als Parameter an "make" übergeben werden. Das Programm make sucht sich "automatisch" das makefile im aktuellen Arbeitsverzeichnis und führt die darin definierten Operationen für den entsprechenden Aufrufparameter durch.

{| border=1
| ''make all''
| Erstellt aus den in im makefile angegebenen Quellcodes eine ''hex''-Datei (und ggf. auch ''eep''-Datei).
|-
| ''make program''
| Überträgt die hex-Datei (und wahlweise auch die eep-Datei für den EEPROM) zum AVR.
|-
| ''make clean''
| löscht alle temporären Dateien, also auch die hex-Datei
|}

Diese Aufrufe können in die allermeisten Editoren in "Tool-Menüs" eingebunden werden. Dies erspart den Kontakt mit der Kommandozeile. (Bei WinAVR sind die Aufrufe bereits im Tools-Menü des mitgelieferten Editors Programmers-Notepad eingefügt.)

Üblicherweise sind folgende Daten im makefile anzupassen:
* Controllertyp
* Quellcode-Dateien (c-Dateien)
* Typ und Anschluss des Programmiergeräts

seltener sind folgende Einstellungen durchzuführen:
* Grad der Optimierung
* Methode zur Erzeugung der Debug-Symbole (Debug-Format)
* Assembler-Quellcode-Dateien (S-Dateien)

Die in den folgenden Unterabschnitten gezeigten makefile-Ausschnitte sind für ein Programm, das auf einem ATmega8 ausgeführt werden soll. Der Quellcode besteht aus den c-Dateien superprog.c (darin main()), uart.c, lcd.c und 1wire.c. Im Quellcodeverzeichnis befinden sich diese Dateien: superprog.c, uart.h, uart.c, lcd.h, lcd.c, 1wire.h, 1wire.c und das makefile (die angepasste Kopie des WinAVR-Beispiels).

Der Controller wird mittels [[AVRDUDE]] über ein [[STK200]]-Programmierdongle an der Schnittstelle lpt1 (bzw. /dev/lp0) programmiert. Im Quellcode sind auch Daten für die ''section .eeprom'' definiert (siehe Abschnitt Speicherzugriffe TODO: nach unten verlinken), diese sollen beim Programmieren gleich mit ins EEPROM geschrieben werden.

== Controllertyp setzen ==

Dazu wird die "make-Variable" MCU entsprechend dem Namen des verwendenten Controllers gesetzt. Ein Liste der von avr-gcc und der avr-libc untersützten Typen findet sich in der [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc].

<pre class="code">
# Kommentare in Makefiles beginnen mit einem Doppelkreuz
...

# ATmega8 at work
MCU = atmega8
# oder MCU = atmega16
# oder MCU = at90s8535
# oder ...
...
</pre>

== Quellcode-Dateien einstellen ==

Den Namen der Quellcodedatei welche die Funktion main enthält, wird hinter TARGET eingetragen. Dies jedoch ohne die Endung ''.c''.

<pre class="code">
...
TARGET = superprog
...
</pre>

Besteht das Projekt wie im Beispiel aus mehr als einer Quellcodedatei, sind die weiteren c-Dateien (nicht die Header-Dateien, vgl. [[Include-Files (C)]]) durch Leerzeichen getrennt bei SRC einzutragen. Die bei TARGET definierte Datei ist schon in der SRC-Liste enthalten. Diesen Eintrag nicht löschen!

<pre class="code">
...
SRC = $(TARGET).c uart.c lcd.c 1wire.c
...
</pre>

Alternativ kann man die Liste der Quellcodedateien auch mit dem Operator += erweitern.

<pre class="code">
SRC = $(TARGET).c uart.c 1wire.c
# lcd-Code fuer Controller xyz123 (auskommentiert)
# SRC += lcd_xyz.c
# lcd-Code fuer "Standard-Controller" (genutzt)
SRC += lcd.c
</pre>

== Programmiergerät einstellen ==

Die Vorlagen sind auf die Programmiersoftware [[AVRDUDE]] angepasst, jedoch lässt sich auch andere Programmiersoftware einbinden, sofern diese über Kommandozeile gesteuert werden kann (z.B. stk500.exe, uisp, sp12).

<pre class="code">
...
# Einstellung fuer STK500 an com1 (auskommentiert)
# AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
# AVRDUDE_PORT = com1 # programmer connected to serial device

# Einstellung fuer STK200-Dongle an lpt1
AVRDUDE_PROGRAMMER = stk200
AVRDUDE_PORT = lpt1
...
</pre>

Sollen Flash(=.hex) und EEPROM(=.eep) zusammen auf den Controller programmiert werden, ist das Kommentarzeichen vor AVRDUDE_WRITE_EEPROM zu löschen.

<pre class="code">
...
#Auskommentiert: EERPOM-Inhalt wird nicht mitgeschrieben
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

#Nich-auskommentiert EERPOM-Inhalt wird mitgeschrieben
AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
...
</pre>

== Anwendung ==

Die Eingabe von ''make all'' im Arbeitsverzeichnis mit dem makefile und den Quellcodedateien erzeugt (unter anderem) die Dateien superprog.hex und superprog.eep. Abhängigkeiten zwischen den einzelnen c-Dateien werden dabei automatisch berücksichtigt. Die ''superprog.hex'' und ''superprog.eep'' werden mit ''make program'' zum Controller übertragen. Mit ''make clean'' werden alle temporären Dateien gelöscht (="aufgeräumt").

== Sonstige Einstellungen ==

=== Optimierungsgrad ===

Der gcc-Compiler kennt verschiedene Stufen der Optimierung. Nur zu Testzwecken sollte die Optimierung ganz deaktiviert werden (''OPT = 0''). Die weiteren möglichen Optionen weisen den Compiler an, möglichst kompakten oder möglichst schnellen Code zu erzeugen. In den weitaus meisten Fällen ist ''OPT = s'' die optimale (sic) Einstellung, damit wird kompakter und oft auch der "schnellste" Maschienencode erzeugt.

=== Debug-Format ===

Unterstützt werden die Formate stabs und dwarf-2. Das Format wir hinter ''DEBUG ='' eingestellt. Siehe dazu Abschnitt ''Eingabedateien zur Simulation''.

=== Assembler-Dateien ===

Die im Projekt genutzten Assembler-Dateien werden hinter ASRC durch Leerzeichen getrennt aufgelistet. Assembler-Dateien haben immer die Endung .S (grosses S). Ist zum Beispiel der Assembler-Quellcode eines Software-UARTs in einer Datei softuart.S enthalten lautet die Zeile: ''ASRC = softuart.S''

== Eingabedateien zur Simulation in AVR-Studio ==

Mit älteren AVR-Studio-Versionen kann man nur auf Grundlage sogenannter ''coff''-Dateien simulieren. Neuere Versionen von AVR-Studio (ab 4.10.356) unterstützen zudem das modernere aber noch experimentelle dwarf-2-Format, das ab WinAVR 20040722 (avr-gcc 3.4.1/Binutils inkl. Atmel add-ons) "direkt" vom Compiler erzeugt wird.

; Vorgehensweise bei extcoff:
* im Makefile bei DEBUG: <pre class="code">DEBUG=stabs</pre>
* ''make extcoff'' (evtl. vorher ''make clean'')
* die erzeugte ''cof''-Datei (im Beispiel oben ''superprog.cof'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

; Vorgehensweise bei dwarf-2:
* im Makefile bei DEBUG: <pre class="code">DEBUG=dwarf-2</pre>
* ''make all'' (evtl. vorher ''make clean'')
* die erzeugte ''elf''-Datei (im Beispiel oben ''superprog.elf'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

Beim Simulieren scheinen oft "Variablen zu fehlen". Ursache dafür ist, dass der Compiler die "Variablen" direkt Registern zuweist. Dies kann vermieden werden, indem die Optimierung abgeschaltet wird (im makefile). Man simuliert dann jedoch ein vom optimierten Code stark abweichendes Programm. Das Abschalten der Optimierung wird nicht empfohlen.

Statt des Software-Simulators kann das AVR-Studio auch genutzt werden, um mit dem ATMEL JTAGICE, ein Nachbau davon (BootICE, Evertool o.ä.) oder dem ATMEL JTAGICE MKII "im System" zu debuggen. Dazu sind keine speziellen Einstellungen im makefile erforderlich. Debugging bzw. "In-System-Emulation" mit dem JTAGICE und JTAGICE MKII sind in der AVR-Studio Online-Hilfe beschrieben.

= Definition einiger Datentypen =

Für die Programmierung von Mikrocontrollern ist es sinnvoll, dass wir uns
vorerst einige Datentypen definieren, welche den Zugriff auf die verschiedenen
Komponenten des Controllers vereinfachen oder wenigstens das Programm lesbarer
machen können.

<pre class="code">
typedef unsigned char BYTE;
typedef unsigned short WORD;
</pre>

== BYTE ==

Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 255.

== WORD ==

Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 65535.

== DWORD ==

Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

== QWORD ==

Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

Bei allen vorgenannten Datentypen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z.B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich daher, die im folgenden Abschnitt beschriebenen standardisierten Datentypen zu nutzen und damit "Missverständnissen" vorzubeugen, die z.B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

= Standardisierte Integer(Ganzzahl)-Typen =

Standardisierte Datentypen werden in der Header-Datei inttypes.h definiert.
Will man diese Typen benutzen, bindet man die "Definitionsdatei" wie folgt ein:

<pre class="code">
#include <inttypes.h>
</pre>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<pre class="code">
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
</pre>

Ein Vierfach-Wort (64Bit) entspricht beim AVR ''uint64_t'', ein Doppel-[[Word|Wort]] (32bit) entspricht ''uint32_t'', ein Wort (16bit) entspricht ''uint16_t'' und ein [[Byte]] (8bit) entspricht ''uint8_t''.
Die Typen ohne vorangestelltes ''u'' können auch vorzeichenbehaftete Zahlen speichern. ''int8_t'' geht also von -128 bis 127, ''uint8_t'' dagegen geht von 0 bis 255.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Integer Types

== '''Bitfelder''' ==

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bit breit ist. 
Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in einer einzelnen Bytevariable zusammen fassen und (fast) wie
8 einzelne Variablen ansprechen können. 
Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente
definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<pre class="code">
struct {
unsigned char bStatus_1:1; // 1 Bit für bStatus_1
unsigned char bStatus_2:1; // 1 Bit für bStatus_2
unsigned char bNochNBit:1; // Und hier noch mal ein Bit
unsigned char b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</pre>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<pre class="code">
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</pre>

(mt Empfehlung: Bitfelder sparen zwar Platz, verschlechtern aber unter
Umständen die Les- und Wartbarkeit des Codes. Anfängern wird geraten,
ein "ganzes" ein Byte (uint8_t) zu nutzen auch wenn nur ein Bitwert gespeichert
werden soll.)

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten
Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher
Dinge erledigt werden können, welche nicht zeitkritisch sind. 
Wenn ein Interrupt ausgelöst wird so wird automatisch die zugeordnete
Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Allgemeiner Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heisst, das Programm kann die
Inhalte der Register auslesen und beschreiben. 
Einige Register haben spezielle Funktionen, andere wiederum könne für
allgemeine Zwecke (Speichern von Datenwerten) verwendet werden.

Einzelne Register sind bei allen AVR's vorhanden, andere wiederum nur bei
bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff
auf den UART notwendig sind selbstverständlich nur bei denjenigen Modellen
vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden
AVR-Typen definiert. 

Wenn im Makefile der MCU-Typ definiert ist, wird vom System automatisch die
zum Typen passende Definitionsdatei genutzt, sobald man im Code die allgemeine
"io.h" Header-Datei einbinden.

<pre class="code">
#include <avr/io.h>
</pre>

Ist im Makefile der MCU Type z.B. mit dem Inhalt atmega8 definiert,
wird beim einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit
den Register-Definitionen für den ATmega8 eingelesen.



== I/O-Register ==

Die I/O-Register haben einen besonderen Stellenwert bei den AVR Controllern.
Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. 
Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir mal
die 8-Bit Register.


=== Lesen eines I/O-Registers ===



Zum Lesen kann man auf I/O Register einfach wie auf eine
Variable zugreifen. Die spezielle Funktion inp() ist nicht mehr
notwendig und veraltet.

Beispiel:

<pre class="code">
#include <avr/io.h>
uint8_t foo;
...
int main(void)
{
foo=PINB; /* kopiert den Status der Eingabepins an PortB in die Variable foo */
...
}
</pre>

==== Lesen eines Bits ====

Die AVR-Bibliothek stellt auch Funktionen zur Abfrage eines einzelnen Bits
eines Registers zur Verfügung:

;bit_is_set (<Register>,<Bitnummer>) : Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 4 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>) : Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen bit_is_clear bzw. bit_is_set sind nicht unbedingt erfoderlich, man kann auch "einfachen" C-Syntax verwenden. Der universell verwendbar ist. ''bit_is_set'' entspricht dabei z.B. (Variable & (1<<Bitnummer)). Das Ergebnis ist <>0 wenn das Bit gesetzt und 0 wenn nicht gesetzt ist.

* siehe auch [[Bitmanipulation]]

=== Schreiben eines I/O-Registers ===



Zum Schreiben kann man I/O Register einfach wie eine
Variable setzen. Die spezielle Funktion outp() ist nicht mehr
notwendig, veraltet und sollte nicht mehr genutzt werden.

Beispiel:

<pre class="code">
#include <avr/io.h>
...
int main(void)
{
DDRA=0xff; /* Setzt das Richtungsregister des Ports A auf 0xff (alle Pins als Ausgang) */
PORTA=0x03; /* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low" */
...
}
</pre>

==== Schreiben eines Bits ====



Einzelne Bits setzt man "Standard-C-Konform" mittels logischen (bit-) Operationen.

mit dem Ausduck |=(1<<Bitnummer) wird ein Bit gesetzt, mit dem Ausdruck
&=~(1<<Bitnummer) wird ein Bit geloescht. Die Funktionen sbi und cbi sind
dazu nicht notwendig, veraltet und sollten nicht mehr genutzt werden.

Beispiel:
<pre class="code">
...
#define MEINBIT 2
...
PORTA |= (1<<MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1<<MEINBIT); /* loescht Bit 2 an PortA */
</pre>

* siehe auch:
** [[Bitmanipulation]]
** [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

=== Warten auf einen bestimmten Zustand ===

Es gibt in der Bibliothek sogar Funktionen, die Warten, bis ein bestimmter
Zustand auf einem Bit erreicht ist. 
Es ist allerdings normalerweise eine eher unschöne Programmiertechnik.

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das
definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits
gesetzt ist wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT 2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1<<WARTEBIT)) ) ;
</pre>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das
definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits
gelöscht ist wird die Funktion sofort wieder verlassen. 
Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT 4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// ungleich 0 ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
</pre>

Universeller und auch auf andere Platformen besser übertragbar ist die Verwendung von C-Standardoperationen.

siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]



= Zugriff auf Ports =

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind
jedem Port 3 Register zugeordnet:

{| border="1"
|-
| '''DDRx'''
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (anhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
| '''PORTx'''
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Wird ein Port als Eingang geschaltet, so können mit diesem Register
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|-
| '''PINx'''
| Eingangadresse für Port'''x'''.

Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der Portspins. Bit gesetzt (1) wenn Pin "high/an", Bit gelöscht (0) wenn Portpin "low/aus".
|}

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.


Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Wollen wir also beispielsweise Pin 0 bis 4 von Port B als Ausgänge
definieren so schreiben wir folgende Zeile:


<pre class="code">
#include <avr/io.h>
...
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F

DDRB=0x1F; /* direkte Zuweisung - unuebersichtlich */
/* mehr Tipparbeit aber uebersichtlicher: */
DDRB=(1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3)|(1<<DDB4);
...
</pre>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet.

=== Ganze Ports ===

Um einen ganzen Port als Ausgang zu definieren, kann der folgende Befehl
verwendet werden:

<pre class="code">
DDRB=0xff;
</pre>

Im Beispiel wird der Port B als Ganzes als Ausgang geschaltet.

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen
bzw. auszugeben.

== Ausgänge ==

Wir wollen nun einen als Ausgang definierten Pin auf Logisch 1 setzen. Dazu schreiben wir den entsprechenden Wert in das Portregister des entsprechenden Ports.

Mit dem Befehl

<pre class="code">
PORTB=0x04; /* besser PORTB=(1<<DDB2) */
</pre>

wird also der Ausgang an Pin 2 gesetzt (Beachte, dass die Bits immer ''von 0 an''
gezählt werden, das niederwertigste Bit ist also Bit 0 und nicht etwa Bit 1).

Man beachte bitte, dass bei der Zuweisung mittels '''='''  immer alle Pins gleichzeitig angegeben werden. Man sollte also zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfliessen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an PortB auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<pre class="code">
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<DDB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<DDB2)
</pre>


Die Funktionen cbi und sbi sind dazu nicht notwendig, veraltet und sollten
nicht mehr genutzt werden.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wird den Pegel über entsprechende Hardware (z.B. Optokoppler, Spannunsteiler "Levelshifter") anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unserer Controllers eine logische 1 (Vcc) oder eine logische 0 (Masse) anliegt.

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.



Wobei es hier sehr wichtig ist, zur Abfrage der Eingänge nicht etwa das Portregister '''PORTx''' zu verwenden, sondern die Porteingangsadresse '''PINx'''. Dies ist
ein oft gemachter Fehler!

Wollen wir also die aktuellen Signalzustände von Port D abfragen und in einer
Variable namens bPortD abspeichern so schreiben wir dazu folgende Befehlszeile:

<pre class="code">
#include <avr/io.h>
...
bPortD = PIND;
...
</pre>


=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen (''Active Low'' und ''Active High''):

{| border="1"
|-
| '''Active Low'''
| '''Active High'''
|-
| [[Image:Active Low.gif]]
| [[Image:Active High.gif]]
|-
| Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet.

Damit bei offenem Schalter der Controller kein undefiniertes Signal
bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein
sogenannter Pull-Up Widerstand geschaltet. Dieser dient dazu, den Pegel
bei geöffnetem Schalter auf logisch 1 zu ziehen. 
Der Widerstandswert des Pull-Up Widerstands ist an sich nicht kritisch. Es
muss jedoch beachtet werden, dass über den Widerstand ein Strom in den
Eingang fliesst, also sollte er nicht zu klein gewählt werden um den
Controller nicht zu zerstören. Wird er allerdings zu hoch gewählt ist
die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10
Kiloohm eingebürgert.

Die AVR's haben sogar an den meisten Pins softwaremässig zuschaltbare
interne Pull-Up Widerstände, welche wir natürlich auch verwenden
können.
| Hier wird der Kontakt zwischen die Versorgungsspannung und Masse geschaltet.

Damit bei offener Schalterstellung kein undefiniertes Signal am Controller
ansteht, wird zwischen den Eingangspin und die Masse ein Pull-Down
Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter
Schalterstellung auf logisch 0 zu halten.
|}

==== Pull-Up Widerstände aktivieren ====

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden
über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang'''
geschaltet ist. 

Wird der Wert des entsprechenden Portpins auf 1 gesetzt so ist
der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up
Widerstand nicht aktiv. 
Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand
verwenden, aber nicht beide zusammen.



<pre class="code">
#include <avr/io.h>
...
DDRD=0x00; /* alle Pins von Port D als Eingang */
PORTD=0xff: /* interer Pull-Up an allen Port-Pins aktivieren */
...
</pre>

Im Beispiel wird der gesamte Port D als Eingang geschaltet und alle Pull-Up
Widerstände aktiviert.

===== Tastenentprellung =====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von
Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim
Schliessen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern
mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes. 
Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein
solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen
als mehrfache Impulse gezählt wird. 
Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen
werden.

ToDo Bsp Quellcode

== Analog ==

Leider können wir mit unseren Controllern keine analogen Werte direkt
ausgeben oder einlesen. Dazu müssen wir Umwege gehen, doch dies wird in einem späteren
Kapitel behandelt.

=== 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1) ===

Einige der Portregister in den AVR-Controllern sind 16 Bit breit, Man spricht
dann von einem '''Wort'''.


Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<pre class="code">
#include <avr/io.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8

= Der UART, Teil 1 =

Wir werden in zukünftigen Übungen in die Situation kommen, dass wir
Informationen vom Controller auswerten bzw. anzeigen müssen wobei es vielleicht
dann nicht mehr reicht, ein paar Leuchtdioden anzusteuern. 
Somit brauchen wir eine Verbindung vom AVR zu unserem PC, und dies am besten
über die serielle Schnittstelle.

== Allgemeines zum UART ==

Einige AVR-Controller haben einen vollduplexfähigen UART ('''U'''niversal
'''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut.
Dies ist eine wirklich feine Sache, haben wir doch damit schon das nötige
Werkzeug, um mit anderen Geräten, welche über eine serielle Schnittstelle
verfügen (insbesondere mit unserem PC), zu kommunizieren.

Übrigens: Vollduplex heisst nichts anderes, als dass der Baustein gleichzeitig
senden und empfangen kann.

Neuere AVRs (ATmega) verfügen über einen oder zwei U'''S'''ART(s), dieser unterschiedet sich vom UART häuptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

Der UART wird über vier separate Register angesprochen. USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurations/Datenregister. Das Datenblatt gibt darüber Auskunft. Die Folgende Tabelle gibt nur die Register für die (veralteten) UARTs wieder.

{| border="1"
|-
| '''UCR   '''
| '''U'''ART '''C'''ontrol '''R'''egister. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXCIE'''
| align="center" | '''TXCIE'''
| align="center" | '''UDRIE'''
| align="center" | '''RXEN'''
| align="center" | '''TXEN'''
| align="center" | '''CHR9'''
| align="center" | '''RXB8'''
| align="center" | '''TXB8'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''CHR9''' (9 Bit Characters)
:Wenn dieses Bit gesetzt ist, können 9 Bit lange Zeichen übertragen und empfangen werden. Das 9. Bit kann bei Bedarf als zusätzliches Stopbit oder als Paritätsbit verwendet werden. Man spricht dann von einem 11-Bit Zeichenrahmen:
:1 Startbit + 8 Datenbits + 1 Stopbit + 1 Paritätsbit = 11 Bits

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.

|-
| '''USR   '''
| '''U'''ART '''S'''tatus '''R'''egister. 
Hier teilt uns der UART mit, was er gerade so macht.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXC'''
| align="center" | '''TXC'''
| align="center" | '''UDRE'''
| align="center" | '''FE'''
| align="center" | '''OR'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt bevor ein weiteres Zeichen komplett empfangen wurde wird eine Überlauf-Fehlersituation eintreffen. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, wenn die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit wird vom AVR gesetzt, wenn ein Zeichen vom Sendedatenregister in das Send-Schieberegister übernommen wurde und der UART nun wieder bereit ist, ein neues Zeichen zum Senden aufzunehmen.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''OR''' ('''O'''ver'''R'''un) 
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne
kommunizieren möchten. Der Wert, der in dieses Register geschrieben
werden muss, errechnet sich nach folgender Formel:

<math>
\begin{matrix}
UBBR = \frac{Taktfrequenz}{Baudrate * 16} - 1
\end{matrix}
</math>

Es sind Baudraten bis zu 115200 Baud und höher möglich.
|}

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (LOW) und 5V (HIGH). Die
Schnittstellenspezifikation für RS232 definiert jedoch -3V ... -12V (LOW) und
+3 ... +12V (HIGH). Zudem muss der Signalaustausch zwischen AVR und
Partnergerät invertiert werden. Für die Anpassung der Pegel und das
Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste
davon ist wohl der MAX232. Allerdings kostet der auch wieder Geld und benötigt
zusätzlich immerhin 4 externe Elkos.

Die in den PC eingebauten Schnittstellen vertragen ohne Klagen auch den
TTL-Pegel vom AVR. Allerdings müssen wir immer noch die Signale invertieren. Im
einfachtesn Fall verwenden wir dazu jeweils einen einfachen NPN-Transistor und 2
Widerstände. Näheres dazu erfahrt ihr in den folgenden Übungen.

Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z.B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfielt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Senden mit dem UART ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. 
Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach
gewünschter Funktionsweise die
benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister. 
Da wir vorerst nur senden möchten und (noch) keine Interrupts auswerten wollen,
gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das
'''Transmitter Enable''' Bit setzen müssen:


<pre class="code">
UCR |= (1<<TXEN);
</pre>

Der Atmega16 hat mehrere Konfigurationsregister für USART und erfordert eine etwas andere Konfiguration

<pre class="code">
UCSRB |= (1<<TXEN); //UART TX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1
</pre>

Nun müssen wir noch die Baudrate festlegen. Gemäß unserer Formel brauchen
wir dazu die Taktfrequenz des angeschlossenen Oszillators bzw. Quarz in die
Formel einzufügen und das Resultat der Berechnung in das Baudratenregister des
UART einzuschreiben:

<pre class="code">
/* UART-Init beim AT90S2313 */
#define F_CPU 4000000; // Zum Beispiel 4Mhz-Quarz
#define UART_BAUD_RATE 9600 // Wir versuchen mal mit 9600 Baud
UBRR = F_CPU / (UART_BAUD_RATE * 16L) - 1;
</pre>

Wieder für den Mega16 mit einem 16bit-Register eine andere Programmierung

<pre class="code">
/* USART-Init beim ATmegaXX */
#define F_OSC 3686400 /* Oszillator-Frequenz in Hz */
#define UART_BAUD_RATE 9600
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)

UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

/* alternativ bei der avr-libc "direkt 16bit" : */
UBRR=UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);
</pre>

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben.

<pre class="code">
while (USR & (1<<UDRE)); /* warten bis Senden moeglich */
UDR = 'x'; // Schreibt das Zeichen x auf die Schnittstelle
</pre>

=== Schreiben einer Zeichenkette (String) ===

Es ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

Zu diesem Zweck können wir uns für's Erste eine einfache Funktion basteln:

<pre class="code">
void SendeString (char *szBuf)
{
while (*szBuf) {
loop_until_bit_is_set (USR, UDRE); /* warten bis Senden moeglich */
UDR=*szBuf;
szBuf++;
}
}
</pre>

Warteschleifen sind insofern etwas kritisch, da während des Sendens eines
Strings nicht mehr auf andere Ereignisse reagieren werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. emfangenen Zeichen/Bytes zwischengespeichert und mittels Interruptroutinen an den U(S)ART weitergebgen bzw. ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

* siehe auch: Weiterführende Informationen inkl. Beispielen für die Nutzung von stdio-Funktionen (prinf etc.) im [[AVR-Tutorial - UART]].
* [http://homepage.sunrise.ch/mysunrise/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc

= Analoge Ein- und Ausgabe =

Leider können wir mit unseren Controllern keine analogen Werte direkt
verarbeiten. Dazu bedarf es jeweils einer Umwandlung des analogen Signals in
einen digitalen Zahlenwert. Je nachdem, ob wir Daten einlesen oder ausgeben
wollen reden wir dabei von '''ADC''' oder '''DAC'''.

== ADC (Analog Digital Converter) ==

Der '''ADC''' wandelt analoge Signale in digitale Werte um, welche vom Controller
interpretiert werden können. Einige AVR-Typen haben bereits einen oder mehrere
solcher '''ADC''''s eingebaut, bei den kleineren AVR's müssen wir uns anders aus der
Affäre ziehen. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst
werden kann, wird durch die Auflösung des '''ADC''' in Anzahl Bits angegeben, man
hört bzw. liest jeweils von 8-Bit '''ADC''' oder 10-Bit ''' ADC''' oder noch höher. 
Ein '''ADC''' mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit
von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten
eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

<div align="center"><center>

{| border="1"
|-
| align="center" | '''Eingangsspannung am ADC'''
| align="center" | '''Entsprechender Messwert'''
|-
| align="center" | 0...<0.625V
| align="center" | 0
|-
| align="center" | 0.625...<1.25V
| align="center" | 1
|-
| align="center" | 1.25...<1.875V
| align="center" | 2
|-
| align="center" | 1.875...<2.5V
| align="center" | 3
|-
| align="center" | 2.5...<3.125V
| align="center" | 4
|-
| align="center" | 3.125...<3.75V
| align="center" | 5
|-
| align="center" | 3.75...<4.375V
| align="center" | 6
|-
| align="center" | 4.375...5V
| align="center" | 7
|}

</center>
</div>

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des '''
ADC''' ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Messen eines Widerstandes ===

Wir wollen hier einmal die wohl einfachste Methode zur Erfassung eines
analogen Wertes realisieren und zwar das Messen eines veränderlichen
Widerstandes wie z.B. eines Potentiometers.

Man stelle sich vor, wir schalten einen Kondensator in Reihe zu einem
Widerstand zwischen die Versorgungsspannung und Masse und dazwischen nehmen wir
das Signal ab und führen es auf einen der Pins an unserem Controller, genau so
wie es in folgender Grafik dargestellt ist.

[[Image:Poti.gif]]

Wenn wir nun den Pin des AVR als Ausgang schalten und auf
Logisch 1 (HIGH) legen, dann liegt an beiden Platten des Kondensators ''' Vcc''' an und
dieser wird entladen (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen). 
Nachdem nun der Kondensator genügend entladen ist schalten wir einfach den Pin
als Eingang wodurch dieser hochohmig wird. Der Kondensator lädt sich jetzt
über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und
derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti
unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), dann schaltet der
Eingang von HIGH auf LOW um. Wenn wir nun messen (zählen), wie lange es dauert,
bis der Kondensator so weit geladen ist, dann haben wir einen ungefähren Wert
der Potentiometerstellung. 
Der 220 Ohm Widerstand dient dem Schutz des Controllers. Wenn nämlich sonst die
Potentiometerstellung auf Maximum steht (0 Ohm), dann würde in den Eingang des
Controllers ein viel zu hoher Strom fliessen und der AVR würde in Rauch
aufgehen.

Dies ist meines Wissens die einzige Schaltung zur Erfassung von
Analogwerten, welche mit nur einem einzigen Pin auskommt. 
Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine
Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B:
0...100 % oder so) umzurechnen.

Wer Lust hat, sich selber mal an ein solches Programm
heranzuwagen, der sollte das jetzt tun. Für diejenigen, die es gern schnell
mögen, hier das Beispielprogramm, welches den UART-Printf aus den
vorangegangenen Kapiteln benötigt, inkl. Makefile:

{| border="0"
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Poti.c Poti.c ]
| Hauptprogramm.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.c Pot.c]
| Separate Routine zur Ermittlung des Messwertes.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.h Pot.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c UartPrintF.c]
| Für die Debugausgabe auf den UART.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h UartPrintF.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile Makefile]
| Makefile.
|}

Nachdem das Programm auf den AVR geladen wurde, muss dieser
kalibriert werden. Dazu wird der Kalibrierungsschalter geschlossen und das Poti
einige Male zwischen minimaler und maximaler Stellung hin und her gedreht. Dabei
werden die jeweiligen Maximalwerte bestimmt. Wenn der Kalibrierschalter wieder
geöffnet wird werden die Kalibrierungsdaten in's EEPROM des AVR geschrieben,
damit die Prozedur nicht nach jedem Reset wiederholt werden muss.

Auf Pin 4 habe ich noch ein Triggersignal gelegt, welches auf
HIGH geht wenn die Messung beginnt und auf LOW, wenn der Messvorgang beendet
wird. Mit Hilfe dieses Signals kann der Vorgang wunderschön auf einem
Oszillographen dargestellt werden.

=== ADC über Komparator ===

Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

[[Image:ADC ueber Komparator.gif]]

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert. 
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

=== Der ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem '''ADC-Wandler''' zurückgreifen. Wir wollen hier einmal den AT90S8535 besprechen, welcher über 8 ADC-Kanäle verfügt. (TODO: nur ein Wandler, Mulitiplexbetrieb, nur eine Pin zur gleichen Zeit)

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung.

Verfügt der AVR über eine interne Referenzspannung (Datenblatt typisch 2,56 oder 1,1V je nach AVR), bleibt der ''Anschluss AREF'' unbeschaltet und man stellt die ADC-Register so ein, dass die interne Referenzspannung als "AREF" genutzt wird. Ansonsten ist eine externe Referenzspannung von maximal '''Vcc''' an den Abschluss '''AREF''' anzulegen. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden.

==== Einfache Wandlung (Single Conversion) ====

In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestossen für jeweils eine Messung.

==== Frei laufend (Free Running) ====

In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register, welche hier aufgelistet werden.

{| border="1"
|-
| '''ADCSR   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ADEN'''
| align="center" | '''ADSC'''
| align="center" | '''ADFR'''
| align="center" | '''ADIF'''
| align="center" | '''ADIE'''
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt, ist können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''Fr'''ee Running Select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Eine logische 1 aktiviert den frei laufenden Modus. Der ''' ADC''' misst nun ständig den ausgewählten Kanal und schreibt den gemessenen Wert in das '''ADC Data Register'''.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, wenn eine Umwandlung erfolgt und das '''ADC Data Register''' aktualisiert ist.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird (So steht es in der AVR-Dokumentation).

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200kHz}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50kHz}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.
<dl><dd>
{| style="" border="1"
|-
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
| align="center" | '''Teilungsfaktor'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 2
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 2
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 4
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 8
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 16
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 32
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 64
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 128
|}
</dd></dl>
|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<pre class="code">
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
C-Operatorprioritaet sichergestellt)
</pre>

oder

<pre class="code">
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</pre>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''MUX2'''
| align="center" | '''MUX1'''
| align="center" | '''MUX0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''MUX2...MUX0'''
:Mit diesem 3 Bits wird der zu messende Kanal bestimmt. Es wird einfach die entsprechende Pinnummer des Ports eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Meine Empfehlung ist deswegen klar diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Aktivieren des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register
setzen. Im gleichen Schritt legen wir auch gleich die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls mit Spannungsteiler konditionieren. Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1024 für V_ref-Volt.

<pre class="code">

#define CHANNELOFFSET 4

uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result;

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler setzen auf 8 (1)
ADCSRA |= (1<<ADEN); // ADC aktivieren (1)

ADMUX = CHANNELOFFSET+channel; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)

result = 0;

/* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
for(i=0;i<4;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)
result += ADC; // Wandlungsergebnisse aufaddieren
}

ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)

result >>= 2; // Summe durch vier teilen = arithm. Mittelwert

return result;
}
</pre>

Im Beispiel wird bei jedem Aufruf der ADC aktiviert und nach der Wandlung wieder abgeschaltet, das spart Strom. Will man dies nicht, verschiebt man die mit (1) gekenntzeichneten Zeilen in eine Funktion adc_init() o.ä. und löscht die mit (2) markierten Zeilen.



== DAC (Digital Analog Converter) ==

Mit Hilfe eines ''' DAC''' können wir nun auch Analogsignale ausgeben. Es gibt hier
mehrere Verfahren. Wenn wir beim ''' ADC''' die Möglichkeit haben, mit externen
Komponenten zu operieren, müssen wir bei der '''DAC'''-Wandlung mit dem auskommen, was
der Controller selber zu bieten hat.

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie ''' PWM''' eigentlich funktioniert.

Wie wir alle wissen ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber
wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. 
Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen
HIGH und LOW umschalten? 
Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen geometrischen Mittelwert, der je nach Pulsbreite
kleiner oder grösser ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein
RC-Glied filtern dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVR's können wir direkt '''PWM'''-Signale erzeugen. Dazu
dient der 16-Bit Zähler, welcher im sogenannten '''PWM'''-Modus betrieben werden
kann.

Hinweis:
:In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist allerdings bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt.

Um den '''PWM'''-Modus zu aktivieren müssen im Timer/Counter1 Control
Register A '''TCCR1A''' die Pulsweiten-Modulatorbits '''PWM10''' bzw. '''PWM11''' entsprechend
nachfolgender Tabelle gesetzt werden:

{| border="1"
|-
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| PWM-Modus des Timers ist nicht aktiv.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM.
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben. Die
Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| border="1"
|-
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden heisst dann:

<pre class="code">
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</pre>

Damit der Timer/Counter überhaupt läuft müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorzähler) einstellen, und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| border="1"
|-
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<pre class="code">
TCCR1B = (1<<CS12) | (1<<CS10);
</pre>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<pre class="code">
OCR1A = xxx;
</pre>

Die folgende Grafik soll den Zusammenhang zwischen dem
Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren.

= Die Timer/Counter des AVR =

Die heutigen Mikrocontroller und insbesondere die RISC-AVR's sind für viele
Steuerungsaufgaben natürlich viel zu schnell. Wenn wir beispielsweise eine LED
oder Lampe blinken lassen wollen, können wir selbstverständlich nicht die
CPU-Frequenz verwenden da ja dann nichts mehr vom Blinken zu bemerken wäre.

Wir brauchen also eine Möglichkeit, die Taktfrequenz auf vernünftige Werte
herunter zu brechen. Selbstverständlich sollte die resultierende Frequenz dann
auch noch einigermassen genau und stabil sein.

Hier kommen die im AVR vorhandenen Timer/Counter zum Einsatz.

Ein anderes Anwendungsgebiet ist die Zählung von Signalen, welche über
einen I/O-Pin zugeführt werden können.

Die folgenden Ausführungen beziehen sich auch den AT90S2313. Für andere
Modelltypen müsst ihr euch die allenfalls notwendigen Anpassungen aus den
Datenblättern der entsprechenden Controller herauslesen.

Wir unterscheiden grundsätzlich zwischen 8-Bit Timern, welche eine
Auflösung von 256 aufweisen und 16-Bit Timern mit (logischerweise) einer
Auflösung von 65536.

Als Eingangstakt für die Timer/Counter kann entweder die CPU-Taktfrequenz,
der Vorteiler-Ausgang oder ein an einen I/O-Pin angelegtes Signal verwendet
werden. Wenn ein externes Signal verwendet wird, so darf dessen Frequenz nicht
höher sein als die Hälfte des CPU-Taktes.

=== Der Vorzähler (Prescaler) ===

Beide Timer/Counter werden im Timerbetrieb über den gleichen Vorzähler
versorgt.

Der Vorzähler dient dazu, den CPU-Takt vorerst mal runter zu brechen auf eine
wählbare Teilung. Die so geteilte Frequenz wird den Eingängen der Timer
zugeführt.

Wenn wir mit einer einem CPU-Takt von 4 MHz arbeiten und den Vorteiler auf 1024
einstellen wird also der Timer mit einer Frequenz von 4 MHz / 1024, also mit ca.
4 kHz versorgt. Wenn also der Timer läuft, so wird das Daten- bzw.
Zählregister mit dieser Frequenz inkrementiert.

== 8-Bit Timer/Counter ==

Alle AVR-Modelle weisen mindestens einen, teilweise sogar zwei, 8-Bit Timer
auf.

Der 8-Bit Timer wird über folgende Register angesprochen:

{| border="1"
|-
| '''TCCR0'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
Timer '''0'''

In diesem Register stellen wir ein, wie wir den Timer/Counter verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CS02'''
| align="center" | '''CS01'''
| align="center" | '''CS00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''CS02, CS01, CS00''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS02
| align="center" | CS01
| align="center" | CS00
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin '''TO''', fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin '''TO''', steigende Flanke
|}
</dd>
</dl>
:Wenn als Quelle der externe Pin '''TO''' verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin '''TO''' als Ausgang geschaltet ist.

|-
| '''TCNT0'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer '''0''' 
Dieses ist als 8-Bit Aufwärtszähler mit Schreib- und Lesezugriff
realisiert. Wenn der Zähler den Wert 255 erreicht hat beginnt er beim
nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}
|}

Um nun also den Timer0 in Betrieb zu setzen und ihn mit einer Frequenz von 1/1024-tel des CPU-Taktes zählen zu lassen, schreiben wir die folgende Befehlszeile:

<pre class="code">
TCCR0 = (1<<CS00)|(1<<CS02);
</pre>

Der Zähler zählt nun aufwärts bis 255, um dann wieder bei 0 zu beginnen. Der aktuelle Zählerstand steht in TCNT0. Bei jedem Überlauf von 255 auf 0 wird das Timer Overflow Flag '''TOV0''' im Timer Interrupt Flag '''TIFR'''-Register gesetzt und, falls so konfiguriert, ein entsprechender Timer-Overflow-Interrupt ausgelöst.

== 16-Bit Timer/Counter ==

Viele AVR-Modelle besitzen ausser den 8-Bit Timers auch einen oder sogar zwei
(einige ATmega-Modelle) 16-Bit Timer.

Die 16-Bit Timer/Counter sind wesentlich komplexer aufgebaut als die 8-Bit
Timer/Counter, bieten dafür aber auch viel mehr Möglichkeiten, als da sind:

* Die [[PWM]]-Betriebsart Erzeugung eines pulsweitenmodulierten Ausgangssignals.
* Vergleichswert-Überprüfung mit Erzeugung eines Ausgangssignals (Output Compare Match).
* Einfangen eines Eingangssignals mit Speicherung des aktuellen Zählerwertes (Input Capturing), mit zuschaltbarer Rauschunterdrückung (Noise Filtering).

Folgende Register sind dem Timer/Counter 1 zugeordnet:

{| border="1"
|-
| '''TCCR1A'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''A''' Timer '''1''' 
In diesem und dem folgenden Register stellen wir ein, wie wir den Timer/Counter verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''COM1A1''', '''COM1A0''' ('''Co'''mpare '''M'''atch Control Bits)
:Diese 2 Bits bestimmen die Aktion, welche am Output-Pin '''OC1''' ausgeführt werden soll, wenn der Wert des Datenregisters des Timer/Counter 1 den Wert des Vergleichsregisters erreicht, also ein so genannter Compare Match auftritt.
:Der Pin '''OC1''' ('''PB3''' beim 2313) muss mit dem Datenrichtungsregister als Ausgang konfiguriert werden.

<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Das Signal am Pin '''OC1''' wird invertiert (Toggle).
|-
| align="center" | 1
| align="center" | 0
| Der Output Pin '''OC1''' wird auf 0 gesetzt.
|-
| align="center" | 1
| align="center" | 1
| Der Output Pin '''OC1''' wird auf 1 gesetzt.
|}
</dd></dl>
:In der PWM-Betriebsart haben diese Bits eine andere Funktion.
<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 1
| align="center" | 0
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 0 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 1 gesetzt.

Man nennt dies ''nicht invertierende PWM''.
|-
| align="center" | 1
| align="center" | 1
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 1 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 0 gesetzt.

Man nennt dies ''invertierende PWM''.
|}
</dd></dl>

'''PWM11''', '''PWM10''' ('''PWM''' Mode Select Bits)
:Mit diesen 2 Bits wird die PWM-Betriebsart des Timer/Counter 1 gesteuert.
<dl><dd>
{| border="1"
|-
| align="center" | PWM11
| align="center" | PWM10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Die PWM-Betriebsart ist nicht aktiviert. Timer/Counter 1 arbeitet als normaler Timer bzw. Zähler.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM Betriebsart aktivieren.
|}
</dd></dl>
|-
| '''TCCR1B'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''B''' Timer '''1'''

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ICNC1'''
| align="center" | '''ICES1'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CTC1'''
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''ICNC1''' ('''I'''nput '''C'''apture '''N'''oise '''C'''anceler (4 CKs) Timer/Counter 1
:oder auf Deutsch Rauschunterdrückung des Eingangssignals.
:Wenn dieses Bit gesetzt ist und mit dem Input Capture Signal gearbeitet wird so werden nach der Triggerung des Signals mit der entsprechenden Flanke (steigend oder fallend) am Input Capture Pin '''ICP''' jeweils 4 Messungen mit der CPU-Frequenz des Eingangssignals abgefragt. Nur dann, wenn alle 4 Messungen den gleichen Zustand aufweisen gilt das Signal als erkannt.

'''ICES1''' ('''I'''nput '''C'''apture '''E'''dge '''S'''elect Timer/Counter '''1''')
:Mit diesem Bit wird bestimmt, ob die steigende ('''ICES1'''=1) oder fallende ('''ICES1'''=0) Flanke zur Auswertung des Input Capture Signals an Pin '''ICP''' heran gezogen wird.

'''CTC1''' ('''C'''lear '''T'''imer/'''C'''ounter on Compare Match Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, so wird nach einer Übereinstimmung des Datenregisters '''TCNT1H'''/'''TCNT1L''' mit dem Vergleichswert in '''OCR1H'''/'''OCR1L''' das Datenregister '''TCNT1H'''/'''TCNT1L''' auf 0 gesetzt.
:Da die Übereinstimmung im Takt nach dem Vergleich behandelt wird, ergibt sich je nach eingestelltem Vorzähler ein etwas anderes Zählverhalten:
:Wenn der Vorteiler auf 1 gestellt ist und C der jeweilige Zählerwert ist, dann nimmt das Datenregister, im CPU-Takt betrachtet, folgende Werte an:
:... | C-2 | C-1 | C | 0 | 1 |...
:Wenn der Vorteiler z.B. auf 8 eingestellt ist, dann nimmt das Datenregister folgende Werte an:
:... | C-2, C-2, C-2, C-2, C-2, C-2, C-2, C-2 | C-1, C-1, C-1, C-1, C-1, C-1, C-1, C-1 | C, 0, 0, 0, 0, 0, 0, 0 |...
:In der PWM-Betriebsart hat dieses Bit keine Funktion.

'''CS12''', '''CS11''', '''CS10''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS12
| align="center" | CS11
| align="center" | CS10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin TO, fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin T0, steigende Flanke
|}
</dd></dl>
:Wenn als Quelle der externe Pin T0 verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin T0 als Ausgang geschaltet ist.
|-
| '''TCNT1H''' '''TCNT1L'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer/Counter '''1'''
Dieses ist als 16-Bit Aufwärtszähler mit Schreib- und Lesezugriff realisiert. Wenn der Zähler den Wert 65535 erreicht hat, beginnt er beim nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''TCNT1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''TCNT1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

In der PWM-Betriebsart wird das Register als Auf/Ab-Zähler verwendet, d.h. der Wert steigt zuerst von 0 bis er den Überlauf von 65535 auf 0 erreicht hat. Dann zählt das Register rückwärts wiederum bis 0.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.

Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''OCR1H''' '''OCR1L'''
| Timer/Counter '''O'''utput '''C'''ompare '''R'''egister Timer/Counter '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''OCR1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''OCR1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Der Wert im Output Compare Register wird ständig mit dem aktuellen Wert im Datenregister TCNT1H/TCNT1L verglichen. Stimmen die beiden Werte überein, so wird ein sogenannter Output Compare Match ausgelöst. Die entsprechenden Aktionen werden über die Timer/Counter 1 Control und Status Register eingestellt.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''ICR1H''' '''ICR1L'''
| Timer/Counter '''I'''nput '''C'''apture '''R'''egister Timer/Counter '''1''' 
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''ICR1''''''H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''ICR1''''''L'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Das Input Capture Register ist ein 16-Bit Register mit Lesezugriff. Es kann nicht beschrieben werden.

Wenn am Input Capture Pin '''ICP''' die gemäß Einstellungen im '''TCCR1B''' definierte Flanke erkannt wird, so wird der aktuelle Inhalt des Datenregisters '''TCNT1H'''/'''TCNT1L''' sofort in dieses Register kopiert und das Input Capture Flag '''ICF1''' im Timer Interrupt Flag Register '''TIFR''' gesetzt.

Wie bereits oben erwähnt, müssen vor dem Zugriff auf dieses Register alle Interrupts gesperrt werden. Zudem müssen Low- und Highbyte des Registers in der richtigen Reihenfolge bearbeitet werden:

{| border="0"
|-
| Lesen:
| '''ICR1L''' -> '''ICR1H'''
|-
| Schreiben:
| '''ICR1H''' -> '''ICR1L'''
|}
|}

=== Die PWM-Betriebsart ===

Wenn der Timer/Counter 1 in der PWM-Betriebsart betrieben wird, so bilden das Datenregister '''TCNT1H'''/'''TCNT1L''' und das Vergleichsregister '''OCR1H'''/'''OCR1L''' einen 8-, 9- oder 10-Bit, frei laufenden PWM-Modulator, welcher als PWM-Signal am '''OC1'''-Pin ('''PB3''' beim 2313) abgegriffen werden kann. Das Datenregister '''TCNT1H'''/'''TCNT1L''' wird dabei als Auf-/Ab-Zähler betrieben, welcher von 0 an aufwärts zählt bis zur Obergrenze und danach wieder zurück auf 0.
Die Obergrenze ergibt sich daraus, ob 8-, 9- oder 10-Bit PWM verwendet wird, und zwar gemäss folgender Tabelle:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Wenn nun der Zählerwert im Datenregister den in '''OCR1H'''/'''OCR1L''' gespeicherten Wert erreicht, wird der Ausgabepin '''OC1''' gesetzt bzw. gelöscht, je nach Einstellung von '''COM1A1''' und '''COM1A0''' im '''TCCR1A'''-Register.

Ich habe versucht, die entsprechenden Signale in der folgenden Grafik zusammenzufassen

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

=== Vergleichswert-Überprüfung ===

Hier wird in ein spezielles Vergleichswertregister ('''OCR1H'''/'''OCR1L''') ein Wert eingeschrieben, welcher ständig mit dem aktuellen Zählerwert verglichen wird.
Erreicht der Zähler den in diesem Register eingetragenen Wert, so kann ein Signal (0 oder 1) am Pin '''OC1''' erzeugt und/oder ein Interrupt ausgelöst werden.

=== Einfangen eines Eingangssignals (Input Capturing) ===

Bei dieser Betriebsart wird an den Input Capturing Pin (ICP) des Controllers eine Signalquelle angeschlossen.
Nun kann je nach Konfiguration entweder ein Signalwechsel von 0 nach 1 (steigende Flanke) oder von 1 nach 0 (fallende Flanke) erkannt werden und der zu diesem Zeitpunkt aktuelle Zählerstand in ein spezielles Register abgelegt werden. Gleichzeitig kann auch ein entsprechender Interrupt ausgelöst werden.
Wenn die Signalquelle ein starkes Rauschen beinhaltet, kann die Rauschunterdrückung eingeschaltet werden. Dann wird beim Erkennen der konfigurierten Flanke über 4 Taktzyklen das Signal überwacht und nur dann, wenn alle 4 Messungen gleich sind, wird die entsprechende Aktion ausgelöst.

== Gemeinsame Register ==

Verschiedene Register beinhalten Zustände und Einstellungen, welche sowohl
für den 8-Bit, als auch für den 16-Bit Timer/Counter in ein und demselben
Register zu finden sind.

{| border="1"
|-
| '''TIMSK'''
| '''T'''imer/Counter '''I'''nterrupt '''M'''a'''sk'''
Register

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOIE1'''
| align="center" | '''OCIE1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''TICIE'''
| align="center" | '''-'''
| align="center" | '''TOIE0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOIE1''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 1 ein Timer Overflow 1 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''OCIE1A''' ('''O'''utput '''C'''ompare Match '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Beim Timer/Counter 1 kann zusätzlich zum Überlauf ein Vergleichswert definiert werden.

:Wenn dieses Bit gesetzt ist, wird beim Erreichen des Vergleichswertes ein Compare Match Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TICIE''' ('''T'''imer/Counter '''I'''nput '''C'''apture '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein Capture Event Interrupt ausgelöst, wenn ein entsprechendes Signalereignis am Pin PD6(ICP) auftritt. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein, wenn auch ein entsprechender Interrupt ausgelöst werden soll.

'''TOIE0''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''0''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 0 ein Timer Overflow 0 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

|-
| '''TIFR'''
| '''T'''imer/Counter '''I'''nterrupt '''F'''lag '''R'''egister

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOV1'''
| align="center" | '''OCF1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''ICF1'''
| align="center" | '''-'''
| align="center" | '''TOV0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOV1''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''1''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 1 ein Überlauf des Datenregisters stattfindet.

:In der PWM-Betriebsart wird das Bit gesetzt, wenn die Zählrichtung von auf- zu abwärts und umgekehrt geändert wird (Zählerwert = 0).

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''OCF1A''' ('''O'''utput '''C'''ompare '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn der aktuelle Wert des Datenregisters von Timer/Counter 1 mit demjenigen im Vergleichsregister '''OCR1''' übereinstimmt.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''ICF1''' ('''I'''nput '''C'''apture '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn ein Capture-Ereignis aufgetreten ist, welches anzeigt, dass der Wert des Datenregisters des Timer/Counter 1 in das Input Capture Register ICR1 übertragen wurde.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''TOV0''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''0''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 0 ein Überlauf des Datenregisters stattfindet.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.
|}

 

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sog. ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comperators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrups den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

* '''set_sleep_mode(uint8_t mode)'''
:Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z.B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
* '''sleep_mode()'''
:Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus.

<pre class="code">
#include <avr/io.h>
#include <avr/sleep.h>
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach auftreten eines entsprechenden "Aufwach-Interrupts" verarbeitet
...
</pre>

Vorsicht: Nicht alle AVR-Controller (v.a. nicht die "Brandneuen") werden von den avr-libc sleep-Funktionen richtig angesteuert. Bei nicht-untersützten Typen erreicht man die gewollte Funktionalität durch direkte "Bitmanipulation" der ensprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler:

<pre class="code">
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep");
...
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes

= Der Watchdog =

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der Watchdog.

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln.

Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

Betrachten wir doch einmal folgende Codesequenz:

<pre class="code">
uint8_t x;

x = 10;

while (x >= 0) {
// tu was

x--;
}
</pre>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm würde sich also hier aufhängen und auf ewig in der Schleife drehen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde beginnt der Counter von 0 an hochzuzählen. Wenn nun die je nach Vorteiler eingestellte Anzahl Zyklen erreicht wurde, löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern müssen wir den Watchdog regelmässig wieder neu starten bzw. Rücksetzen (Watchdog Reset). Dies sollte innerehalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern muss ein spezielles Prozedere verwendet werden, um den WD auszuschalten und zwar müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden. Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| border="1"
|-
| '''WDTCR'''
| '''W'''atchog '''T'''imer  '''C'''ontrol '''R'''egister

In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''WDTOE'''
| align="center" | '''WDE'''
| align="center" | '''WDP2'''
| align="center" | '''WDP1'''
| align="center" | '''WDP0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''WDTOE''' ('''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable)
:Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
:Wenn das Bit einmal gesetzt ist wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.

'''WDE''' ('''W'''atch'''d'''og '''E'''nable)
:Wenn dieses Bit gesetzt wird, so wird der Watchdog aktiviert.
:Das Bit kann nur gelöscht werden, solange das Bit '''WDTOE''' auf 1 steht.

'''WDP2''', '''WDP1''', '''WDP0''' ('''W'''atch'''d'''og Timer '''P'''rescaler Bits)
:Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:
<dl><dd>
{| border="1"
|-
| align="center" | WDP2
| align="center" | WDP1
| align="center" | WDP0
| align="center" | Anzahl Zyklen
| align="center" | Typ. Timeoutzeit bei Vcc = 3V
| align="center" | Typ. Timeoutzeit bei Vcc = 5V
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 16K
| align="center" | 47ms
| align="center" | 15ms
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 32K
| align="center" | 94ms
| align="center" | 30ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 64K
| align="center" | 0.19s
| align="center" | 60ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 128K
| align="center" | 0.38s
| align="center" | 0.12s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 256K
| align="center" | 0.75s
| align="center" | 0.24s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 512K
| align="center" | 1.5s
| align="center" | 0.49s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 1024K
| align="center" | 3s
| align="center" | 0.97s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 2048K
| align="center" | 6s
| align="center" | 1.9s
|}
</dd></dl>
|}

Um den Watchdog mit dem AVR-GCC Compiler zu verwenden, muss die Headerdatei wdt.h in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

* '''wdt_enable(uint8_t timeout)'''
:Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert (z.B. WDTO_30MS).
* '''wdt_disable()'''
:Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
* '''wdt_reset()'''
:Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Ein paar grundsätzliche Gedanken ==

Ob nun so ein Watchdog überhaupt verwendet werden soll, ist wohl eher eine
philosophische Frage und hängt vom Geschmack jedes einzelnen Entwicklers ab.

Ich persönlich habe es lieber, wenn ich auch merke, dass in meine Programm
etwas noch nicht in Ordnung ist, als dass mir ein Watchdog einfach die CPU immer
wieder zurücksetzt, denn immerhin kann es so passieren, dass ein Programm über
Jahre hinweg so einigermassen läuft, obwohl noch ein voll krasser Bock drin
liegt.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Watchdog timer handling

= Programmieren mit Interrupts =

Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

[[Image:Interrupt Programme.gif]]

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

== Anforderungen an die Interrupt-Routine ==

Um unliebsamen Überraschungen vorzubeugen sollten einige Grundregeln bei
der Gestaltung der Interruptroutinen beachtet werden.

* Die Interruptroutine soll möglichst kurz und schnell abarbeitbar sein, daraus folgt:
* Keine unfangreichen Berechnungen innerhalb der Interruptroutine.
* Keine endlos langen Programmschleifen.
* Obschon es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen rate ich dringend von solchen Spielen ab.

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf dem AVR auslösen, wobei
die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

== Register ==

Der AT90S2313 verfügt über 2 Register welche mit den
Interrupts zusammen hängen.

{| border="1"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INT1'''
| align="center" | '''INT0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INT1''' (External '''Int'''errupt Request '''1''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

'''INT0''' (External '''Int'''errupt Request '''0''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INTF1'''
| align="center" | '''INTF0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''INTF1''' (External '''Int'''errupt Flag '''1''')
:Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.

'''INTF0''' (External '''Int'''errupt Flag '''0''')
:Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister.

Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''SE'''
| align="center" | '''SM'''
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''SE''' ('''S'''leep '''E'''nable)
:Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl in den Schlafzustand versetzen zu können.
:Um den Schlafmodus nicht irrtümlich einzuschalten, wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.

'''SM''' ('''S'''leep '''M'''ode)
:Dieses Bit bestimmt der Schlafmodus.
:Ist das Bit gelöscht, so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt, so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")

'''ISC11''', '''ISC10''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.
<dl><dd>
{| border="1"
|-
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}
</dd></dl>
'''ISC01''', '''ISC00''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

<dl><dd>
{| border="1"
|-
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.

In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}
</dd></dl>
|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft, wird automatisch das '''Global
Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle
weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem
Zeitpunkt bereits wieder das GIE-bit zu setzen, rate ich dringend davon ab. Dieses
wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn
in der Zwischenzeit weitere Interrupts eintreffen, werden die zugehörigen
Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden
Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt
ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle
anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe,
weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.

=== Das Status-Register ===

Es gilt auch zu beachten, dass das Status-Register während der Abarbeitung
einer Interruptroutine nicht automatisch gesichert wird. Falls notwendig, muss dies vom
Programmierer selber vorgesehen werden.

== Interrupts mit dem AVR GCC Compiler (WinAVR) ==

Selbstverständlich können alle Interruptspezifischen Registerzugriffe wie gewohnt über I/O-Adressierung vorgenommen werden. Etwas einfacher geht es jedoch, wenn wir die vom Compiler zur Verfügung gestellten Mittel einsetzen.

Damit diese Mittel zur Verfügung stehen, müssen wir die Includedatei ''interrupt.h'' und evtl. ''signal.h'' einbinden mittels:

<pre class="code">
// fuer sei(), cli() und INTERRUPT():
#include <avr/interrupt.h>

// fuer SIGNAL() auch:
#include <avr/signal.h>
</pre>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird
nichts anderes gemacht, als das '''Global Interrupt Enable''' Bit im Status
Register gesetzt.

<pre class="code">
sei();
</pre>

Das Makro '''cli()''' schaltet die Interrupts aus, oder anders
gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird
gelöscht.
<pre class="code">
cli();
</pre>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf.
Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen.
Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren
und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen
Zustands die Interrups aktivieren, was zu unerwünschten Seiteneffekten führen kann.
Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern */

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD); // 2 mal in Folge , vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
...

}
</pre>



Nachdem nun die Interrupts aktiviert sind, braucht es selbstverständlich noch den auszuführenden Code, der ablaufen soll, wenn ein Interrupt eintrifft. Dazu gibt es zwei Definitionen: '''SIGNAL''' und '''INTERRUPT''', welche allerdings AVR-GCC spezifisch sind und bei anderen Compilern womöglich anders heissen können.

=== SIGNAL ===

<pre class="code">
#include <avr/signal.h>
...
SIGNAL (siglabel)
{
/* Interrupt Code */
}
</pre>

Mit ''SIGNAL'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektoren angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Vor Nutzung von SIGNAL muss die Header-Datei signal.h eingebunden werden. Mögliche Funktionsrümpfe für solche Interruptfunktionen sind zum Beispiel:

<pre class="code">
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

SIGNAL (SIG_OVERFLOW1)
{
/* Interrupt Code */
}

SIGNAL (SIG_UART_RECV)
{
/* Interrupt Code */
}

// und so weiter und so fort...
</pre>

Während der Ausführung des Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten, so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== INTERRUPT ===

<pre class="code">
#include <avr/interrupt.h>
...
INTERRUPT (signame)
{
/* Interrupt Code */
}
</pre>

Mit INTERRUPT wird genau gleich gearbeitet wie mit SIGNAL. Der Unterschied ist derjenige, dass bei INTERRUPT beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit automatisch wieder gesetzt und somit weitere Interrupts zugelassen werden. Dies kann zu nicht unerheblichen Problemen von im einfachsten Fall einem Stack overflow bis zu sonstigen unerwarteten Effekten führen und sollte wirklich '''nur dann''' angewendet werden, wenn man sich absolut sicher ist, das Ganze auch im Griff zu haben. Vor Nutzung von INTERRUPT muss die Header-Datei interrupt.h eingebunden werden.

Interruptroutinen (ISRs) sollten möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern des Zustands aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen, s.u.). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

siehe auch: Hinweise in [[AVR-GCC]]

== Datenaustausch mit Interrupt-Routinen ==

Variablen auf die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen wird und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte die Code-Optimierung "greifen" und der Wert der Variablen nur in Prozessorregistern zwischenspeichert werden, die "nichts von der Änderung woanders mitbekommen".

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z.B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt z.B. alle 10ms
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
// hier wird gKeyCounter veraendert, die uebrigen
// Programmteile muessen diese Aenderung "sehen"
// (volatile -> aktuellen Wert immer in den Speicher schreiben)
if ( !(KEY_PIN & (1<<KEY_PINNO)) )
if (gKeyCouter < CNTREPEAT) gKeyCounter++;
else gKeyCounter = 0;
}

...

int main(void)
{
...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
...
// hier wird auf gKeyCounter zugegriffen, dazu muss der in der
// ISR geschrieben Wert bekannt sein.
// (volatile -> aktuellen Wert immer aus dem Speicher lesen)
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt"
}
else {
/* hier: Code fuer "Taste kurz gedrueckt"
}
...
}
</pre>

Bei Variablen größer ein Byte muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes ausserhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<pre class="code">
...
volatile uint16_t gMyCounter16bit
...
SIGNAL(...)
{
...
gMyCounter16Bit++;
...
}

int main(void)
{
uint16_t tmpCnt;
...
// nicht gut: mglw. hier ein Fehler wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor Kopieren des zweiten Bytes
// ein Interrupt auftritt der den Inhalt von MyCounter veraendert
tmpCnt = gMyCounter16bit;

// besser: Aenderungen "ausserhalb" verhindern, alle "Teilbytes"
// bleiben konsistent
cli(); // Interupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren
...
}
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8 (Stand: avr-libc Vers. 1.0.4)

== Was macht das Hauptprogramm ==

Im einfachsten Fall gar nichts mehr.

Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der
main-Funktion lediglich noch die Interrupts aktiviert und dann in eine
Endlosschleife folgender Art verzweigt:

<pre class="code">
...
for (;;) {}
...
</pre>

Normalerweise wird man allerdings in den Interruptroutinen die Interrupts
erfassen und im Hauptprogramm dann gemütlich auswerten.

Wie wir im bisherigen Kursverlauf gesehen haben ist es ohnehin mit so
schnellen Controller meistens gar nicht unbedingt notwendig mit
Interruptfunktionen zu arbeiten. 
Es ist allerdings auch zu bemerken, dass mit den Interruptroutinen ein Programm
sehr schön strukturiert werden kann, wenn man es richtig macht.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (eigentlich [[SRAM]]) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als [[FLASH]]-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z.B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin wenig Sinn macht und auch nur bei einigen RAM-losen Typen nach "Bastelarbeiten" möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory). Die Standard-Laufzeitbibliothek des avr-gcc, die [[avr-libc]], stellt diese Funktionen nach einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Einige Beispiele:

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray1 };
...
</pre>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<pre class="code">
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte...
}
</pre>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel jedoch mit der Funktion pgm_read_word.

<pre class="code">
uint16_t myWord;

myWord = pgm_read_word(&pgmFooWord);
</pre>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "gross". (Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.) Pointer müssen gegebenenfalls "gecastet" werden.

<pre class="code">
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray1

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray2
// da im zweiteb Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmPointerToArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</pre>

=== Floats und Structs lesen ===

Um komplexe Datentypen (structs), nicht-integer Datentypen (floats) aus dem Flash auszulesen, sind Hilfsfunktionen erforderlich. Einige Beispiele:

<pre class="code">

/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
...

/* liest float von Flash-Addresse addr und gibt diese als return-value zurueck */
inline float pgm_read_float(const float *addr)
{
union
{
uint16_t i[2]; // 2 16-bit-Worte
float f;
} u;

u.i[0]=pgm_read_word((PGM_P)addr);
u.i[1]=pgm_read_word((PGM_P)addr+2);

return u.f;
}
...

void egal(void)
{
int i;
float f;

for (i=0;i<3;i++) {
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach' was mit f
}
}
</pre>

TODO: Beispiele fuer structs und pointer aus flash auf struct im flash (menues, state-machines etc.)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuerht, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
...
</pre>

Aber Achtung: Ersetzt man zum Beispiel
<pre class="code">
const char textImFlash[] PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
durch
<pre class="code">
const char textImFlash* PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der textImFlash zu den Konstanten ans Ende des Programmcodes gelegt wird, von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte. Da der lesende Code trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein Bug des AVR-GCC (gesehen bei 3.4.1) zu sein.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<pre class="code">
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
...
</pre>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z.B. 0x01fe), "weiss" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, das der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000) wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z.B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmässig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, das vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgeben sind ("timed sequence"). Diese Prüfung wird nicht implizit durchgeführt. Im Zweifel kann man Sicherheitshalber bei EEPROM-Zugriffen die Interrupts global deaktivieren, z.B. so:

<pre class="code">
...
uint8_t sreg;
...

sreg = SREG;
cli();

/* hier die eeprom-Zugriffe */

SREG = sreg;
...
</pre>

Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Die Nutzung einer [[C-Präprozessor]]-Ersetzung bringt etwas Bequemlichkeit. Siehe dazu folgendes Beispiel.

<pre class="code">
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h>

// alle Textstellen EEPROM im Quellcode durch __attribute__ ... ersetzen
#define EEPROM __attribute__ ((section (".eeprom")))

...

/* Byte */
uint8_t eeFooByte EEPROM = 123;

/* Wort */
uint16_t eeFooWort EEPROM = 12345;

/* float */
float eeFooFloat EEPROM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEPROM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEPROM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */

uint16_t eeFooWordArray1[4] EEPROM;
...
</pre>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heisst eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<pre class="code">
...
uint8_t myByte;
uint8_t sreg;

sreg = SREG; // (1)
cli(); // (1)

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
...
SREG = sreg; // (1)
</pre>

Die mit (1) markierten Zeilen dienen hierbei dem (möglicherweise übertriebenen) Schutz vor Unterbrechnungen durch Interrupts.

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<pre class="code">
...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
...
</pre>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprueft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und mglw. noch mehr.

<pre class="code">
...
unit8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes aber der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnuetze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray[0],3);

/* dito mit etwas Absicherung betr. der Laenge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));

/* Datenlock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));
...
</pre>

"Nicht-Integer"-Datentypen wie z.B. Fliesskommazahlen lassen sich recht praktisch ueber eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<pre class="code">
...
float myFloat = 12.34;

union {
float r;
uint8_t n[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */
...
</pre>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<pre class="code">
...
typedef struct {
uint8_t label[8];
unin8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEPROM;

...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
...
}
...
</pre>

=== EEPROM-Speicherabbild in .eep-Datei ===

Eine besondere Funktion des avr-gcc ist, dass mit einem entsprechenden makefile aus den Initialisierungswerten der Variablen im Quellcode eine Datei erzeugt werden kann, die man auf den Controller programmieren kann (.eep-Datei). Damit können sehr elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Die Vorgehensweise wird aus dem WinAVR-Beispielmakefile ersichtlich. Siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles.

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Nicht alle neuen AVR Controller werden von avr-libc/eeprom.h untersützt (Stand Version 1.0.4). Insbesondere beim ATMega169 funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register) Etwas ältere Typen, oder zu den "etablierten" Controllern kompatible, bereiten jedoch hier keine Proleme. Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Der dort gezeigt Code kann direkt auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste").

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gcc-Toolchain" bietet dazu zwei Möglichkeiten:

;Inline-Assembler:
Die Assembleranweisungen werden in direkt in den C-Code integriert. Eine Quellcode-Datei enhält somit C- und Assembleranweisungen

;Assembler-Dateien:
Der Assembler-Codecode befindet sich in eigenen Quellcodedateien. Dieser werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z.B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen eine NOP-Anweisung. NOP steht für '''NO'''-O'''P'''eration. Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=warte)-Funktionen.

<pre class="code">
...
/* Verzoegern der weiteren Programmausfuehrung um
genau 3 Taktzyklen */
asm volatile ("nop"::);
asm volatile ("nop"::);
asm volatile ("nop"::);
...
</pre>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeindlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<pre class="code">
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i=0;i<1000;i++);

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i=0;i<1000;i++) asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j=0;j<1000;j++);
</pre>

Ein weiterer nützliche "Assembler-Einzeiler" ist der Auruf von sleep (''asm volatile ("sleep"::);''), da hierzu keine eigene Funktion in der avr-libc existiert.

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil des die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<pre class="code">
static inline void delayloop16(uint16_t count)
{
asm volatile ( "cp %A0,__zero_reg__ \n\t" \
"cpc %B0,__zero_reg__ \n\t" \
"breq L_Exit_%= \n\t" \
"L_LOOP_%=: \n\t" \
"sbiw %0,1 \n\t" \
"brne L_LOOP_%= \n\t" \
"L_Exit_%=: \n\t" \
: "=w" (count)
: "0" (count)
);
}
</pre>

* Jede Zeile wird mit '''\n\t''' abgeschlossen, alle Zeilen mit '''\''' verbunden.
* Sprung-Marken (labels) werden mit einm Prozentzeichen abgeschlossen, der Präprozessor (Assembler?) setzt an dieser Stelle eine laufende Nummer ein, die Doppelbezeichnungen bei mehrmaliger Verwendung somit verhindert.

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc.

* siehe auch: Dokumentation der avr-libc/Related Pages/Inline Asm
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

...TODO: Beispiele, Parameteruebergabe, globale Variablen für Datenaustausch

= TODO =

stdio.h, malloc() ???, Code-Optimierungen ("tricks"), "naked"-Functionen ??, IO-Register als Parameter/"Variablen" (volatile uint8_t *mybusport; mybusport=&PORTB; void sendbus(uint8_t *parm)...)

= C-Code und Bibliotheken für externe Baugrupen =
(TODO: sollte in avr-gcc verschoben werden)
[[Linksammlung#Avr]]

==LCD==
=== Text (character-mode) HD44870 ===
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray

=== Grafik-LCD ===
==== Nokia3310 ====
==== Nokia 6100 LCD ====
Das Nokia ist ein 132x132x4096 Farben Display das bei eBay ziemlich preiswert ersteigert werden kann.
[http://www.apetech.de/nokia6100.php Nokia 6100 LCD Library]
==== KS0108 ====
* Procyon avrlib (GPL)
* avrfreaks UP
* apetech.de
==Schnittstellen==
===I2C===
====Master====
[http://jump.to/fleury/ P. Fleurys I2C Master library]
====Slave====

===CAN===
* [http://www.atmel.com] Codesammlung zum AT90CAN128

=== DS18S20/1-Wire ===
* avrfreaks Projekt 59
* mikrocontroller.net/codesammlung (P. Dannegger)

=== UART ===
* Procyon avrlib (GPL)
* avrfreaks UP (viele viele)
* P. Fleury

== Speicherkarten/IDE/FAT ==
* avrfreaks UP (IDE/FAT read write)
== CRC ==
* avrfreaks-forum (O'Flynn)
* avr-hal (GPL)

AVR-GCC-Tutorial

2004-11-12T13:11:03Z

Oxygene: /* Der Watchdog */

[[Category:AVR]]

= Vorwort =

Dieses Tutorial soll Einsteigern helfen, mit der Programmiersprache '''C''' die Mikrocontroller der Atmel AVR-Reihe zu programmieren.


Die ursprüngliche Version stammt von Christian Schifferle, die meisten aktuellen Anpassungen von [[Benutzer:Mthomas]]. Viele der im Original-Dokument verwendeten Funktionen sind in
aktuellen Versionen des avr-gcc C-Compilers und der avr-libc zwar noch enthalten,
aber als überholt (''deprecated'') ausgewiesen. D.h. diese Funktionen sollten nicht mehr verwendet
werden und existieren in zukünftigen Versionen des Compilers/der Library nicht mehr
(z.B. sbi(), cbi(), outp(), inp()). Der Artikel wurde auf die neuen Funktionen/Methoden
angepasst.

In diesem Text wird häufig auf die Standardbibliothek für den avr-gcc-Compiler, die avr-libc, verwiesen. Die '''Dokumentation der avr-libc''' findet sich
[http://www.nongnu.org/avr-libc/user-manual/index.html hier]. Bei WinAVR gehört diese Dokumentation zum Lieferumfang und wird mitinstalliert.

= Benötigte Werkzeuge =

Um die Übungen in diesem Tutorial nachvollziehen zu können benötigen wir folgende Hard- und Software:

* Testboard für die Aufnahme eines AVR Controllers, der vom gcc Compiler untersützt wird (alle ATmegas und die meisten AT90). Dieses Testboard kann durchaus auch selber zusammen gelötet werden. So arbeite ich mit einem Testboard, welches ich mir auf einer Veroboard-Platine zusammen gestellt habe. Für die Versuche bzw. Übungen in diesem Tutorial habe ich jeweils einen AT90S2313 verwendet. Eine brauchbare Testplattform ist auch der [[AVR Butterfly]].
* AVRGCC-Compiler. Kostenlos erhältlich für nahezu alle Plattformen/Betriebssysteme. Für MS-Windows im Packet [[WinAVR]]; für Unix/Linx siehe auch Hinweise im Artikel [[AVR-GCC]].
* Programmiersoftware und Hardware z.B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], [[AVR-Studio]]).
* Nicht unbedingt erforderlich aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Abschnitt Exkurs: makefiles).

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.
* Die [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently Asked Questions = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.
* Das gcc-Forum auf [http://www.mikrocontroller.net www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.
* Das avr-gcc-Forum bei [http://www.avrfreaks.net avrfreaks] nach vergleichbaren Problemen absuchen.
* Das [http://www.avr1.org/pipermail/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.
* Nach Beispielcode suchen. Vor allem in der Academy von [http://www.avrfreaks.net AVRFREAKS] (anmelden).
* Google oder alltheweb befragen schadet nie.
* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal)
* einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei mgl. viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode, genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z.B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: [http://www.lugbz.org/documents/smart-questions_de.html "Wie man Fragen stellt"].

= Exkurs: makefiles =

Wenn man bisher gewohnt ist, mit integrierten Entwicklungsumgebung à la Visual-C Programme zu erstellen, wirkt das makefile-Konzept auf den ersten Blick etwas kryptisch. Nach kurzer Einarbeitung ist diese Vorgehensweise jedoch sehr praktisch. Diese Dateien (üblicher Name: 'Makefile' ohne Dateiendung) dienen der Ablaufsteuerung des Programms make, das auf allen Unix/Linux-Systemen installiert sein sollte, und in einer Fassung fuer MS-Windows auch in [[WinAVR]] (Unterverzeichnis utils/bin) enthalten ist.

Im Unterverzeichnis ''sample'' einer WinAVR-Installation findet man eine sehr brauchbare Vorlage, die sich einfach an das eigene Projekt anpassen lässt ([[Media:Makefile|lokale Kopie Stand Sept. 2004]]). Wahlweise kann man auch [http://www.sax.de/~joerg/mfile/ mfile] von Jörg Wunsch nutzen. mfile erzeugt ein makefile nach Einstellungen in einer grafischen Nutzeroberfläche, wird bei WinAVR mitinstalliert, ist aber als TCL/TK-Programm auf nahezu allen Platformen lauffähig.

''Die folgenden Ausführungen beziehen sich auf das WinAVR Beispiel-Makefile.''

Ist im Makefile alles richtig eingestellt genügt es, sich drei Parameter zu merken, die über die shell bzw. die Windows-Kommandozeile (cmd.exe/command.exe) als Parameter an "make" übergeben werden. Das Programm make sucht sich "automatisch" das makefile im aktuellen Arbeitsverzeichnis und führt die darin definierten Operationen für den entsprechenden Aufrufparameter durch.

{| border=1
| ''make all''
| Erstellt aus den in im makefile angegebenen Quellcodes eine ''hex''-Datei (und ggf. auch ''eep''-Datei).
|-
| ''make program''
| Überträgt die hex-Datei (und wahlweise auch die eep-Datei für den EEPROM) zum AVR.
|-
| ''make clean''
| löscht alle temporären Dateien, also auch die hex-Datei
|}

Diese Aufrufe können in die allermeisten Editoren in "Tool-Menüs" eingebunden werden. Dies erspart den Kontakt mit der Kommandozeile. (Bei WinAVR sind die Aufrufe bereits im Tools-Menü des mitgelieferten Editors Programmers-Notepad eingefügt.)

Üblicherweise sind folgende Daten im makefile anzupassen:
* Controllertyp
* Quellcode-Dateien (c-Dateien)
* Typ und Anschluss des Programmiergeräts

seltener sind folgende Einstellungen durchzuführen:
* Grad der Optimierung
* Methode zur Erzeugung der Debug-Symbole (Debug-Format)
* Assembler-Quellcode-Dateien (S-Dateien)

Die in den folgenden Unterabschnitten gezeigten makefile-Ausschnitte sind für ein Programm, das auf einem ATmega8 ausgeführt werden soll. Der Quellcode besteht aus den c-Dateien superprog.c (darin main()), uart.c, lcd.c und 1wire.c. Im Quellcodeverzeichnis befinden sich diese Dateien: superprog.c, uart.h, uart.c, lcd.h, lcd.c, 1wire.h, 1wire.c und das makefile (die angepasste Kopie des WinAVR-Beispiels).

Der Controller wird mittels [[AVRDUDE]] über ein [[STK200]]-Programmierdongle an der Schnittstelle lpt1 (bzw. /dev/lp0) programmiert. Im Quellcode sind auch Daten für die ''section .eeprom'' definiert (siehe Abschnitt Speicherzugriffe TODO: nach unten verlinken), diese sollen beim Programmieren gleich mit ins EEPROM geschrieben werden.

== Controllertyp setzen ==

Dazu wird die "make-Variable" MCU entsprechend dem Namen des verwendenten Controllers gesetzt. Ein Liste der von avr-gcc und der avr-libc untersützten Typen findet sich in der [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc].

<pre class="code">
# Kommentare in Makefiles beginnen mit einem Doppelkreuz
...

# ATmega8 at work
MCU = atmega8
# oder MCU = atmega16
# oder MCU = at90s8535
# oder ...
...
</pre>

== Quellcode-Dateien einstellen ==

Den Namen der Quellcodedatei welche die Funktion main enthält, wird hinter TARGET eingetragen. Dies jedoch ohne die Endung ''.c''.

<pre class="code">
...
TARGET = superprog
...
</pre>

Besteht das Projekt wie im Beispiel aus mehr als einer Quellcodedatei, sind die weiteren c-Dateien (nicht die Header-Dateien, vgl. [[Include-Files (C)]]) durch Leerzeichen getrennt bei SRC einzutragen. Die bei TARGET definierte Datei ist schon in der SRC-Liste enthalten. Diesen Eintrag nicht löschen!

<pre class="code">
...
SRC = $(TARGET).c uart.c lcd.c 1wire.c
...
</pre>

Alternativ kann man die Liste der Quellcodedateien auch mit dem Operator += erweitern.

<pre class="code">
SRC = $(TARGET).c uart.c 1wire.c
# lcd-Code fuer Controller xyz123 (auskommentiert)
# SRC += lcd_xyz.c
# lcd-Code fuer "Standard-Controller" (genutzt)
SRC += lcd.c
</pre>

== Programmiergerät einstellen ==

Die Vorlagen sind auf die Programmiersoftware [[AVRDUDE]] angepasst, jedoch lässt sich auch andere Programmiersoftware einbinden, sofern diese über Kommandozeile gesteuert werden kann (z.B. stk500.exe, uisp, sp12).

<pre class="code">
...
# Einstellung fuer STK500 an com1 (auskommentiert)
# AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
# AVRDUDE_PORT = com1 # programmer connected to serial device

# Einstellung fuer STK200-Dongle an lpt1
AVRDUDE_PROGRAMMER = stk200
AVRDUDE_PORT = lpt1
...
</pre>

Sollen Flash(=.hex) und EEPROM(=.eep) zusammen auf den Controller programmiert werden, ist das Kommentarzeichen vor AVRDUDE_WRITE_EEPROM zu löschen.

<pre class="code">
...
#Auskommentiert: EERPOM-Inhalt wird nicht mitgeschrieben
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

#Nich-auskommentiert EERPOM-Inhalt wird mitgeschrieben
AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
...
</pre>

== Anwendung ==

Die Eingabe von ''make all'' im Arbeitsverzeichnis mit dem makefile und den Quellcodedateien erzeugt (unter anderem) die Dateien superprog.hex und superprog.eep. Abhängigkeiten zwischen den einzelnen c-Dateien werden dabei automatisch berücksichtigt. Die ''superprog.hex'' und ''superprog.eep'' werden mit ''make program'' zum Controller übertragen. Mit ''make clean'' werden alle temporären Dateien gelöscht (="aufgeräumt").

== Sonstige Einstellungen ==

=== Optimierungsgrad ===

Der gcc-Compiler kennt verschiedene Stufen der Optimierung. Nur zu Testzwecken sollte die Optimierung ganz deaktiviert werden (''OPT = 0''). Die weiteren möglichen Optionen weisen den Compiler an, möglichst kompakten oder möglichst schnellen Code zu erzeugen. In den weitaus meisten Fällen ist ''OPT = s'' die optimale (sic) Einstellung, damit wird kompakter und oft auch der "schnellste" Maschienencode erzeugt.

=== Debug-Format ===

Unterstützt werden die Formate stabs und dwarf-2. Das Format wir hinter ''DEBUG ='' eingestellt. Siehe dazu Abschnitt ''Eingabedateien zur Simulation''.

=== Assembler-Dateien ===

Die im Projekt genutzten Assembler-Dateien werden hinter ASRC durch Leerzeichen getrennt aufgelistet. Assembler-Dateien haben immer die Endung .S (grosses S). Ist zum Beispiel der Assembler-Quellcode eines Software-UARTs in einer Datei softuart.S enthalten lautet die Zeile: ''ASRC = softuart.S''

== Eingabedateien zur Simulation in AVR-Studio ==

Mit älteren AVR-Studio-Versionen kann man nur auf Grundlage sogenannter ''coff''-Dateien simulieren. Neuere Versionen von AVR-Studio (ab 4.10.356) unterstützen zudem das modernere aber noch experimentelle dwarf-2-Format, das ab WinAVR 20040722 (avr-gcc 3.4.1/Binutils inkl. Atmel add-ons) "direkt" vom Compiler erzeugt wird.

; Vorgehensweise bei extcoff:
* im Makefile bei DEBUG: <pre class="code">DEBUG=stabs</pre>
* ''make extcoff'' (evtl. vorher ''make clean'')
* die erzeugte ''cof''-Datei (im Beispiel oben ''superprog.cof'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

; Vorgehensweise bei dwarf-2:
* im Makefile bei DEBUG: <pre class="code">DEBUG=dwarf-2</pre>
* ''make all'' (evtl. vorher ''make clean'')
* die erzeugte ''elf''-Datei (im Beispiel oben ''superprog.elf'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

Beim Simulieren scheinen oft "Variablen zu fehlen". Ursache dafür ist, dass der Compiler die "Variablen" direkt Registern zuweist. Dies kann vermieden werden, indem die Optimierung abgeschaltet wird (im makefile). Man simuliert dann jedoch ein vom optimierten Code stark abweichendes Programm. Das Abschalten der Optimierung wird nicht empfohlen.

Statt des Software-Simulators kann das AVR-Studio auch genutzt werden, um mit dem ATMEL JTAGICE, ein Nachbau davon (BootICE, Evertool o.ä.) oder dem ATMEL JTAGICE MKII "im System" zu debuggen. Dazu sind keine speziellen Einstellungen im makefile erforderlich. Debugging bzw. "In-System-Emulation" mit dem JTAGICE und JTAGICE MKII sind in der AVR-Studio Online-Hilfe beschrieben.

= Definition einiger Datentypen =

Für die Programmierung von Mikrocontrollern ist es sinnvoll, dass wir uns
vorerst einige Datentypen definieren, welche den Zugriff auf die verschiedenen
Komponenten des Controllers vereinfachen oder wenigstens das Programm lesbarer
machen können.

<pre class="code">
typedef unsigned char BYTE;
typedef unsigned short WORD;
</pre>

== BYTE ==

Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 255.

== WORD ==

Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 65535.

== DWORD ==

Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

== QWORD ==

Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

Bei allen vorgenannten Datentypen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z.B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich daher, die im folgenden Abschnitt beschriebenen standardisierten Datentypen zu nutzen und damit "Missverständnissen" vorzubeugen, die z.B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

= Standardisierte Integer(Ganzzahl)-Typen =

Standardisierte Datentypen werden in der Header-Datei inttypes.h definiert.
Will man diese Typen benutzen, bindet man die "Definitionsdatei" wie folgt ein:

<pre class="code">
#include <inttypes.h>
</pre>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<pre class="code">
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
</pre>

Ein Vierfach-Wort (64Bit) entspricht beim AVR ''uint64_t'', ein Doppel-[[Word|Wort]] (32bit) entspricht ''uint32_t'', ein Wort (16bit) entspricht ''uint16_t'' und ein [[Byte]] (8bit) entspricht ''uint8_t''.
Die Typen ohne vorangestelltes ''u'' können auch vorzeichenbehaftete Zahlen speichern. ''int8_t'' geht also von -128 bis 127, ''uint8_t'' dagegen geht von 0 bis 255.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Integer Types

== '''Bitfelder''' ==

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bit breit ist. 
Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in einer einzelnen Bytevariable zusammen fassen und (fast) wie
8 einzelne Variablen ansprechen können. 
Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente
definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<pre class="code">
struct {
unsigned char bStatus_1:1; // 1 Bit für bStatus_1
unsigned char bStatus_2:1; // 1 Bit für bStatus_2
unsigned char bNochNBit:1; // Und hier noch mal ein Bit
unsigned char b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</pre>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<pre class="code">
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</pre>

(mt Empfehlung: Bitfelder sparen zwar Platz, verschlechtern aber unter
Umständen die Les- und Wartbarkeit des Codes. Anfängern wird geraten,
ein "ganzes" ein Byte (uint8_t) zu nutzen auch wenn nur ein Bitwert gespeichert
werden soll.)

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten
Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher
Dinge erledigt werden können, welche nicht zeitkritisch sind. 
Wenn ein Interrupt ausgelöst wird so wird automatisch die zugeordnete
Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Allgemeiner Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heisst, das Programm kann die
Inhalte der Register auslesen und beschreiben. 
Einige Register haben spezielle Funktionen, andere wiederum könne für
allgemeine Zwecke (Speichern von Datenwerten) verwendet werden.

Einzelne Register sind bei allen AVR's vorhanden, andere wiederum nur bei
bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff
auf den UART notwendig sind selbstverständlich nur bei denjenigen Modellen
vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden
AVR-Typen definiert. 

Wenn im Makefile der MCU-Typ definiert ist, wird vom System automatisch die
zum Typen passende Definitionsdatei genutzt, sobald man im Code die allgemeine
"io.h" Header-Datei einbinden.

<pre class="code">
#include <avr/io.h>
</pre>

Ist im Makefile der MCU Type z.B. mit dem Inhalt atmega8 definiert,
wird beim einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit
den Register-Definitionen für den ATmega8 eingelesen.



== I/O-Register ==

Die I/O-Register haben einen besonderen Stellenwert bei den AVR Controllern.
Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. 
Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir mal
die 8-Bit Register.


=== Lesen eines I/O-Registers ===



Zum Lesen kann man auf I/O Register einfach wie auf eine
Variable zugreifen. Die spezielle Funktion inp() ist nicht mehr
notwendig und veraltet.

Beispiel:

<pre class="code">
#include <avr/io.h>
uint8_t foo;
...
int main(void)
{
foo=PINB; /* kopiert den Status der Eingabepins an PortB in die Variable foo */
...
}
</pre>

==== Lesen eines Bits ====

Die AVR-Bibliothek stellt auch Funktionen zur Abfrage eines einzelnen Bits
eines Registers zur Verfügung:

;bit_is_set (<Register>,<Bitnummer>) : Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 4 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>) : Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen bit_is_clear bzw. bit_is_set sind nicht unbedingt erfoderlich, man kann auch "einfachen" C-Syntax verwenden. Der universell verwendbar ist. ''bit_is_set'' entspricht dabei z.B. (Variable & (1<<Bitnummer)). Das Ergebnis ist <>0 wenn das Bit gesetzt und 0 wenn nicht gesetzt ist.

* siehe auch [[Bitmanipulation]]

=== Schreiben eines I/O-Registers ===



Zum Schreiben kann man I/O Register einfach wie eine
Variable setzen. Die spezielle Funktion outp() ist nicht mehr
notwendig, veraltet und sollte nicht mehr genutzt werden.

Beispiel:

<pre class="code">
#include <avr/io.h>
...
int main(void)
{
DDRA=0xff; /* Setzt das Richtungsregister des Ports A auf 0xff (alle Pins als Ausgang) */
PORTA=0x03; /* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low" */
...
}
</pre>

==== Schreiben eines Bits ====



Einzelne Bits setzt man "Standard-C-Konform" mittels logischen (bit-) Operationen.

mit dem Ausduck |=(1<<Bitnummer) wird ein Bit gesetzt, mit dem Ausdruck
&=~(1<<Bitnummer) wird ein Bit geloescht. Die Funktionen sbi und cbi sind
dazu nicht notwendig, veraltet und sollten nicht mehr genutzt werden.

Beispiel:
<pre class="code">
...
#define MEINBIT 2
...
PORTA |= (1<<MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1<<MEINBIT); /* loescht Bit 2 an PortA */
</pre>

* siehe auch:
** [[Bitmanipulation]]
** [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

=== Warten auf einen bestimmten Zustand ===

Es gibt in der Bibliothek sogar Funktionen, die Warten, bis ein bestimmter
Zustand auf einem Bit erreicht ist. 
Es ist allerdings normalerweise eine eher unschöne Programmiertechnik.

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das
definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits
gesetzt ist wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT 2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1<<WARTEBIT)) ) ;
</pre>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das
definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits
gelöscht ist wird die Funktion sofort wieder verlassen. 
Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT 4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// ungleich 0 ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
</pre>

Universeller und auch auf andere Platformen besser übertragbar ist die Verwendung von C-Standardoperationen.

siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]



= Zugriff auf Ports =

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind
jedem Port 3 Register zugeordnet:

{| border="1"
|-
| '''DDRx'''
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (anhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
| '''PORTx'''
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Wird ein Port als Eingang geschaltet, so können mit diesem Register
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|-
| '''PINx'''
| Eingangadresse für Port'''x'''.

Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der Portspins. Bit gesetzt (1) wenn Pin "high/an", Bit gelöscht (0) wenn Portpin "low/aus".
|}

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.


Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Wollen wir also beispielsweise Pin 0 bis 4 von Port B als Ausgänge
definieren so schreiben wir folgende Zeile:


<pre class="code">
#include <avr/io.h>
...
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F

DDRB=0x1F; /* direkte Zuweisung - unuebersichtlich */
/* mehr Tipparbeit aber uebersichtlicher: */
DDRB=(1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3)|(1<<DDB4);
...
</pre>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet.

=== Ganze Ports ===

Um einen ganzen Port als Ausgang zu definieren, kann der folgende Befehl
verwendet werden:

<pre class="code">
DDRB=0xff;
</pre>

Im Beispiel wird der Port B als Ganzes als Ausgang geschaltet.

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen
bzw. auszugeben.

== Ausgänge ==

Wir wollen nun einen als Ausgang definierten Pin auf Logisch 1 setzen. Dazu schreiben wir den entsprechenden Wert in das Portregister des entsprechenden Ports.

Mit dem Befehl

<pre class="code">
PORTB=0x04; /* besser PORTB=(1<<DDB2) */
</pre>

wird also der Ausgang an Pin 2 gesetzt (Beachte, dass die Bits immer ''von 0 an''
gezählt werden, das niederwertigste Bit ist also Bit 0 und nicht etwa Bit 1).

Man beachte bitte, dass bei der Zuweisung mittels '''='''  immer alle Pins gleichzeitig angegeben werden. Man sollte also zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfliessen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an PortB auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<pre class="code">
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<DDB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<DDB2)
</pre>


Die Funktionen cbi und sbi sind dazu nicht notwendig, veraltet und sollten
nicht mehr genutzt werden.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wird den Pegel über entsprechende Hardware (z.B. Optokoppler, Spannunsteiler "Levelshifter") anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unserer Controllers eine logische 1 (Vcc) oder eine logische 0 (Masse) anliegt.

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.



Wobei es hier sehr wichtig ist, zur Abfrage der Eingänge nicht etwa das Portregister '''PORTx''' zu verwenden, sondern die Porteingangsadresse '''PINx'''. Dies ist
ein oft gemachter Fehler!

Wollen wir also die aktuellen Signalzustände von Port D abfragen und in einer
Variable namens bPortD abspeichern so schreiben wir dazu folgende Befehlszeile:

<pre class="code">
#include <avr/io.h>
...
bPortD = PIND;
...
</pre>


=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen (''Active Low'' und ''Active High''):

{| border="1"
|-
| '''Active Low'''
| '''Active High'''
|-
| [[Image:Active Low.gif]]
| [[Image:Active High.gif]]
|-
| Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet.

Damit bei offenem Schalter der Controller kein undefiniertes Signal
bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein
sogenannter Pull-Up Widerstand geschaltet. Dieser dient dazu, den Pegel
bei geöffnetem Schalter auf logisch 1 zu ziehen. 
Der Widerstandswert des Pull-Up Widerstands ist an sich nicht kritisch. Es
muss jedoch beachtet werden, dass über den Widerstand ein Strom in den
Eingang fliesst, also sollte er nicht zu klein gewählt werden um den
Controller nicht zu zerstören. Wird er allerdings zu hoch gewählt ist
die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10
Kiloohm eingebürgert.

Die AVR's haben sogar an den meisten Pins softwaremässig zuschaltbare
interne Pull-Up Widerstände, welche wir natürlich auch verwenden
können.
| Hier wird der Kontakt zwischen die Versorgungsspannung und Masse geschaltet.

Damit bei offener Schalterstellung kein undefiniertes Signal am Controller
ansteht, wird zwischen den Eingangspin und die Masse ein Pull-Down
Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter
Schalterstellung auf logisch 0 zu halten.
|}

==== Pull-Up Widerstände aktivieren ====

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden
über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang'''
geschaltet ist. 

Wird der Wert des entsprechenden Portpins auf 1 gesetzt so ist
der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up
Widerstand nicht aktiv. 
Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand
verwenden, aber nicht beide zusammen.



<pre class="code">
#include <avr/io.h>
...
DDRD=0x00; /* alle Pins von Port D als Eingang */
PORTD=0xff: /* interer Pull-Up an allen Port-Pins aktivieren */
...
</pre>

Im Beispiel wird der gesamte Port D als Eingang geschaltet und alle Pull-Up
Widerstände aktiviert.

===== Tastenentprellung =====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von
Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim
Schliessen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern
mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes. 
Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein
solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen
als mehrfache Impulse gezählt wird. 
Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen
werden.

ToDo Bsp Quellcode

== Analog ==

Leider können wir mit unseren Controllern keine analogen Werte direkt
ausgeben oder einlesen. Dazu müssen wir Umwege gehen, doch dies wird in einem späteren
Kapitel behandelt.

=== 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1) ===

Einige der Portregister in den AVR-Controllern sind 16 Bit breit, Man spricht
dann von einem '''Wort'''.


Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<pre class="code">
#include <avr/io.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8

= Der UART, Teil 1 =

Wir werden in zukünftigen Übungen in die Situation kommen, dass wir
Informationen vom Controller auswerten bzw. anzeigen müssen wobei es vielleicht
dann nicht mehr reicht, ein paar Leuchtdioden anzusteuern. 
Somit brauchen wir eine Verbindung vom AVR zu unserem PC, und dies am besten
über die serielle Schnittstelle.

== Allgemeines zum UART ==

Einige AVR-Controller haben einen vollduplexfähigen UART ('''U'''niversal
'''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut.
Dies ist eine wirklich feine Sache, haben wir doch damit schon das nötige
Werkzeug, um mit anderen Geräten, welche über eine serielle Schnittstelle
verfügen (insbesondere mit unserem PC), zu kommunizieren.

Übrigens: Vollduplex heisst nichts anderes, als dass der Baustein gleichzeitig
senden und empfangen kann.

Neuere AVRs (ATmega) verfügen über einen oder zwei U'''S'''ART(s), dieser unterschiedet sich vom UART häuptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

Der UART wird über vier separate Register angesprochen. USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurations/Datenregister. Das Datenblatt gibt darüber Auskunft. Die Folgende Tabelle gibt nur die Register für die (veralteten) UARTs wieder.

{| border="1"
|-
| '''UCR   '''
| '''U'''ART '''C'''ontrol '''R'''egister. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXCIE'''
| align="center" | '''TXCIE'''
| align="center" | '''UDRIE'''
| align="center" | '''RXEN'''
| align="center" | '''TXEN'''
| align="center" | '''CHR9'''
| align="center" | '''RXB8'''
| align="center" | '''TXB8'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''CHR9''' (9 Bit Characters)
:Wenn dieses Bit gesetzt ist, können 9 Bit lange Zeichen übertragen und empfangen werden. Das 9. Bit kann bei Bedarf als zusätzliches Stopbit oder als Paritätsbit verwendet werden. Man spricht dann von einem 11-Bit Zeichenrahmen:
:1 Startbit + 8 Datenbits + 1 Stopbit + 1 Paritätsbit = 11 Bits

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.

|-
| '''USR   '''
| '''U'''ART '''S'''tatus '''R'''egister. 
Hier teilt uns der UART mit, was er gerade so macht.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXC'''
| align="center" | '''TXC'''
| align="center" | '''UDRE'''
| align="center" | '''FE'''
| align="center" | '''OR'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt bevor ein weiteres Zeichen komplett empfangen wurde wird eine Überlauf-Fehlersituation eintreffen. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, wenn die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit wird vom AVR gesetzt, wenn ein Zeichen vom Sendedatenregister in das Send-Schieberegister übernommen wurde und der UART nun wieder bereit ist, ein neues Zeichen zum Senden aufzunehmen.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''OR''' ('''O'''ver'''R'''un) 
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne
kommunizieren möchten. Der Wert, der in dieses Register geschrieben
werden muss, errechnet sich nach folgender Formel:

<math>
\begin{matrix}
UBBR = \frac{Taktfrequenz}{Baudrate * 16} - 1
\end{matrix}
</math>

Es sind Baudraten bis zu 115200 Baud und höher möglich.
|}

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (LOW) und 5V (HIGH). Die
Schnittstellenspezifikation für RS232 definiert jedoch -3V ... -12V (LOW) und
+3 ... +12V (HIGH). Zudem muss der Signalaustausch zwischen AVR und
Partnergerät invertiert werden. Für die Anpassung der Pegel und das
Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste
davon ist wohl der MAX232. Allerdings kostet der auch wieder Geld und benötigt
zusätzlich immerhin 4 externe Elkos.

Die in den PC eingebauten Schnittstellen vertragen ohne Klagen auch den
TTL-Pegel vom AVR. Allerdings müssen wir immer noch die Signale invertieren. Im
einfachtesn Fall verwenden wir dazu jeweils einen einfachen NPN-Transistor und 2
Widerstände. Näheres dazu erfahrt ihr in den folgenden Übungen.

Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z.B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfielt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Senden mit dem UART ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. 
Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach
gewünschter Funktionsweise die
benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister. 
Da wir vorerst nur senden möchten und (noch) keine Interrupts auswerten wollen,
gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das
'''Transmitter Enable''' Bit setzen müssen:


<pre class="code">
UCR |= (1<<TXEN);
</pre>

Der Atmega16 hat mehrere Konfigurationsregister für USART und erfordert eine etwas andere Konfiguration

<pre class="code">
UCSRB |= (1<<TXEN); //UART TX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1
</pre>

Nun müssen wir noch die Baudrate festlegen. Gemäß unserer Formel brauchen
wir dazu die Taktfrequenz des angeschlossenen Oszillators bzw. Quarz in die
Formel einzufügen und das Resultat der Berechnung in das Baudratenregister des
UART einzuschreiben:

<pre class="code">
/* UART-Init beim AT90S2313 */
#define F_CPU 4000000; // Zum Beispiel 4Mhz-Quarz
#define UART_BAUD_RATE 9600 // Wir versuchen mal mit 9600 Baud
UBRR = F_CPU / (UART_BAUD_RATE * 16L) - 1;
</pre>

Wieder für den Mega16 mit einem 16bit-Register eine andere Programmierung

<pre class="code">
/* USART-Init beim ATmegaXX */
#define F_OSC 3686400 /* Oszillator-Frequenz in Hz */
#define UART_BAUD_RATE 9600
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)

UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

/* alternativ bei der avr-libc "direkt 16bit" : */
UBRR=UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);
</pre>

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben.

<pre class="code">
while (USR & (1<<UDRE)); /* warten bis Senden moeglich */
UDR = 'x'; // Schreibt das Zeichen x auf die Schnittstelle
</pre>

=== Schreiben einer Zeichenkette (String) ===

Es ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

Zu diesem Zweck können wir uns für's Erste eine einfache Funktion basteln:

<pre class="code">
void SendeString (char *szBuf)
{
while (*szBuf) {
loop_until_bit_is_set (USR, UDRE); /* warten bis Senden moeglich */
UDR=*szBuf;
szBuf++;
}
}
</pre>

Warteschleifen sind insofern etwas kritisch, da während des Sendens eines
Strings nicht mehr auf andere Ereignisse reagieren werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. emfangenen Zeichen/Bytes zwischengespeichert und mittels Interruptroutinen an den U(S)ART weitergebgen bzw. ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

* siehe auch: Weiterführende Informationen inkl. Beispielen für die Nutzung von stdio-Funktionen (prinf etc.) im [[AVR-Tutorial - UART]].
* [http://homepage.sunrise.ch/mysunrise/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc

= Analoge Ein- und Ausgabe =

Leider können wir mit unseren Controllern keine analogen Werte direkt
verarbeiten. Dazu bedarf es jeweils einer Umwandlung des analogen Signals in
einen digitalen Zahlenwert. Je nachdem, ob wir Daten einlesen oder ausgeben
wollen reden wir dabei von '''ADC''' oder '''DAC'''.

== ADC (Analog Digital Converter) ==

Der '''ADC''' wandelt analoge Signale in digitale Werte um, welche vom Controller
interpretiert werden können. Einige AVR-Typen haben bereits einen oder mehrere
solcher '''ADC''''s eingebaut, bei den kleineren AVR's müssen wir uns anders aus der
Affäre ziehen. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst
werden kann, wird durch die Auflösung des '''ADC''' in Anzahl Bits angegeben, man
hört bzw. liest jeweils von 8-Bit '''ADC''' oder 10-Bit ''' ADC''' oder noch höher. 
Ein '''ADC''' mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit
von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten
eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

<div align="center"><center>

{| border="1"
|-
| align="center" | '''Eingangsspannung am ADC'''
| align="center" | '''Entsprechender Messwert'''
|-
| align="center" | 0...<0.625V
| align="center" | 0
|-
| align="center" | 0.625...<1.25V
| align="center" | 1
|-
| align="center" | 1.25...<1.875V
| align="center" | 2
|-
| align="center" | 1.875...<2.5V
| align="center" | 3
|-
| align="center" | 2.5...<3.125V
| align="center" | 4
|-
| align="center" | 3.125...<3.75V
| align="center" | 5
|-
| align="center" | 3.75...<4.375V
| align="center" | 6
|-
| align="center" | 4.375...5V
| align="center" | 7
|}

</center>
</div>

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des '''
ADC''' ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Messen eines Widerstandes ===

Wir wollen hier einmal die wohl einfachste Methode zur Erfassung eines
analogen Wertes realisieren und zwar das Messen eines veränderlichen
Widerstandes wie z.B. eines Potentiometers.

Man stelle sich vor, wir schalten einen Kondensator in Reihe zu einem
Widerstand zwischen die Versorgungsspannung und Masse und dazwischen nehmen wir
das Signal ab und führen es auf einen der Pins an unserem Controller, genau so
wie es in folgender Grafik dargestellt ist.

[[Image:Poti.gif]]

Wenn wir nun den Pin des AVR als Ausgang schalten und auf
Logisch 1 (HIGH) legen, dann liegt an beiden Platten des Kondensators ''' Vcc''' an und
dieser wird entladen (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen). 
Nachdem nun der Kondensator genügend entladen ist schalten wir einfach den Pin
als Eingang wodurch dieser hochohmig wird. Der Kondensator lädt sich jetzt
über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und
derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti
unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), dann schaltet der
Eingang von HIGH auf LOW um. Wenn wir nun messen (zählen), wie lange es dauert,
bis der Kondensator so weit geladen ist, dann haben wir einen ungefähren Wert
der Potentiometerstellung. 
Der 220 Ohm Widerstand dient dem Schutz des Controllers. Wenn nämlich sonst die
Potentiometerstellung auf Maximum steht (0 Ohm), dann würde in den Eingang des
Controllers ein viel zu hoher Strom fliessen und der AVR würde in Rauch
aufgehen.

Dies ist meines Wissens die einzige Schaltung zur Erfassung von
Analogwerten, welche mit nur einem einzigen Pin auskommt. 
Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine
Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B:
0...100 % oder so) umzurechnen.

Wer Lust hat, sich selber mal an ein solches Programm
heranzuwagen, der sollte das jetzt tun. Für diejenigen, die es gern schnell
mögen, hier das Beispielprogramm, welches den UART-Printf aus den
vorangegangenen Kapiteln benötigt, inkl. Makefile:

{| border="0"
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Poti.c Poti.c ]
| Hauptprogramm.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.c Pot.c]
| Separate Routine zur Ermittlung des Messwertes.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.h Pot.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c UartPrintF.c]
| Für die Debugausgabe auf den UART.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h UartPrintF.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile Makefile]
| Makefile.
|}

Nachdem das Programm auf den AVR geladen wurde, muss dieser
kalibriert werden. Dazu wird der Kalibrierungsschalter geschlossen und das Poti
einige Male zwischen minimaler und maximaler Stellung hin und her gedreht. Dabei
werden die jeweiligen Maximalwerte bestimmt. Wenn der Kalibrierschalter wieder
geöffnet wird werden die Kalibrierungsdaten in's EEPROM des AVR geschrieben,
damit die Prozedur nicht nach jedem Reset wiederholt werden muss.

Auf Pin 4 habe ich noch ein Triggersignal gelegt, welches auf
HIGH geht wenn die Messung beginnt und auf LOW, wenn der Messvorgang beendet
wird. Mit Hilfe dieses Signals kann der Vorgang wunderschön auf einem
Oszillographen dargestellt werden.

=== ADC über Komparator ===

Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

[[Image:ADC ueber Komparator.gif]]

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert. 
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

=== Der ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem '''ADC-Wandler''' zurückgreifen. Wir wollen hier einmal den AT90S8535 besprechen, welcher über 8 ADC-Kanäle verfügt. (TODO: nur ein Wandler, Mulitiplexbetrieb, nur eine Pin zur gleichen Zeit)

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung.

Verfügt der AVR über eine interne Referenzspannung (Datenblatt typisch 2,56 oder 1,1V je nach AVR), bleibt der ''Anschluss AREF'' unbeschaltet und man stellt die ADC-Register so ein, dass die interne Referenzspannung als "AREF" genutzt wird. Ansonsten ist eine externe Referenzspannung von maximal '''Vcc''' an den Abschluss '''AREF''' anzulegen. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden.

==== Einfache Wandlung (Single Conversion) ====

In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestossen für jeweils eine Messung.

==== Frei laufend (Free Running) ====

In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register, welche hier aufgelistet werden.

{| border="1"
|-
| '''ADCSR   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ADEN'''
| align="center" | '''ADSC'''
| align="center" | '''ADFR'''
| align="center" | '''ADIF'''
| align="center" | '''ADIE'''
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt, ist können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''Fr'''ee Running Select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Eine logische 1 aktiviert den frei laufenden Modus. Der ''' ADC''' misst nun ständig den ausgewählten Kanal und schreibt den gemessenen Wert in das '''ADC Data Register'''.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, wenn eine Umwandlung erfolgt und das '''ADC Data Register''' aktualisiert ist.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird (So steht es in der AVR-Dokumentation).

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200kHz}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50kHz}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.
<dl><dd>
{| style="" border="1"
|-
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
| align="center" | '''Teilungsfaktor'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 2
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 2
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 4
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 8
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 16
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 32
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 64
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 128
|}
</dd></dl>
|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<pre class="code">
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
C-Operatorprioritaet sichergestellt)
</pre>

oder

<pre class="code">
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</pre>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''MUX2'''
| align="center" | '''MUX1'''
| align="center" | '''MUX0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''MUX2...MUX0'''
:Mit diesem 3 Bits wird der zu messende Kanal bestimmt. Es wird einfach die entsprechende Pinnummer des Ports eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Meine Empfehlung ist deswegen klar diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Aktivieren des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register
setzen. Im gleichen Schritt legen wir auch gleich die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls mit Spannungsteiler konditionieren. Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1024 für V_ref-Volt.

<pre class="code">

#define CHANNELOFFSET 4

uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result;

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler setzen auf 8 (1)
ADCSRA |= (1<<ADEN); // ADC aktivieren (1)

ADMUX = CHANNELOFFSET+channel; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)

result = 0;

/* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
for(i=0;i<4;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)
result += ADC; // Wandlungsergebnisse aufaddieren
}

ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)

result >>= 2; // Summe durch vier teilen = arithm. Mittelwert

return result;
}
</pre>

Im Beispiel wird bei jedem Aufruf der ADC aktiviert und nach der Wandlung wieder abgeschaltet, das spart Strom. Will man dies nicht, verschiebt man die mit (1) gekenntzeichneten Zeilen in eine Funktion adc_init() o.ä. und löscht die mit (2) markierten Zeilen.



== DAC (Digital Analog Converter) ==

Mit Hilfe eines ''' DAC''' können wir nun auch Analogsignale ausgeben. Es gibt hier
mehrere Verfahren. Wenn wir beim ''' ADC''' die Möglichkeit haben, mit externen
Komponenten zu operieren, müssen wir bei der '''DAC'''-Wandlung mit dem auskommen, was
der Controller selber zu bieten hat.

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie ''' PWM''' eigentlich funktioniert.

Wie wir alle wissen ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber
wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. 
Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen
HIGH und LOW umschalten? 
Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen geometrischen Mittelwert, der je nach Pulsbreite
kleiner oder grösser ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein
RC-Glied filtern dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVR's können wir direkt '''PWM'''-Signale erzeugen. Dazu
dient der 16-Bit Zähler, welcher im sogenannten '''PWM'''-Modus betrieben werden
kann.

Hinweis:
:In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist allerdings bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt.

Um den '''PWM'''-Modus zu aktivieren müssen im Timer/Counter1 Control
Register A '''TCCR1A''' die Pulsweiten-Modulatorbits '''PWM10''' bzw. '''PWM11''' entsprechend
nachfolgender Tabelle gesetzt werden:

{| border="1"
|-
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| PWM-Modus des Timers ist nicht aktiv.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM.
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben. Die
Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| border="1"
|-
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden heisst dann:

<pre class="code">
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</pre>

Damit der Timer/Counter überhaupt läuft müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorzähler) einstellen, und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| border="1"
|-
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<pre class="code">
TCCR1B = (1<<CS12) | (1<<CS10);
</pre>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<pre class="code">
OCR1A = xxx;
</pre>

Die folgende Grafik soll den Zusammenhang zwischen dem
Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren.

= Die Timer/Counter des AVR =

Die heutigen Mikrocontroller und insbesondere die RISC-AVR's sind für viele
Steuerungsaufgaben natürlich viel zu schnell. Wenn wir beispielsweise eine LED
oder Lampe blinken lassen wollen, können wir selbstverständlich nicht die
CPU-Frequenz verwenden da ja dann nichts mehr vom Blinken zu bemerken wäre.

Wir brauchen also eine Möglichkeit, die Taktfrequenz auf vernünftige Werte
herunter zu brechen. Selbstverständlich sollte die resultierende Frequenz dann
auch noch einigermassen genau und stabil sein.

Hier kommen die im AVR vorhandenen Timer/Counter zum Einsatz.

Ein anderes Anwendungsgebiet ist die Zählung von Signalen, welche über
einen I/O-Pin zugeführt werden können.

Die folgenden Ausführungen beziehen sich auch den AT90S2313. Für andere
Modelltypen müsst ihr euch die allenfalls notwendigen Anpassungen aus den
Datenblättern der entsprechenden Controller herauslesen.

Wir unterscheiden grundsätzlich zwischen 8-Bit Timern, welche eine
Auflösung von 256 aufweisen und 16-Bit Timern mit (logischerweise) einer
Auflösung von 65536.

Als Eingangstakt für die Timer/Counter kann entweder die CPU-Taktfrequenz,
der Vorteiler-Ausgang oder ein an einen I/O-Pin angelegtes Signal verwendet
werden. Wenn ein externes Signal verwendet wird, so darf dessen Frequenz nicht
höher sein als die Hälfte des CPU-Taktes.

=== Der Vorzähler (Prescaler) ===

Beide Timer/Counter werden im Timerbetrieb über den gleichen Vorzähler
versorgt.

Der Vorzähler dient dazu, den CPU-Takt vorerst mal runter zu brechen auf eine
wählbare Teilung. Die so geteilte Frequenz wird den Eingängen der Timer
zugeführt.

Wenn wir mit einer einem CPU-Takt von 4 MHz arbeiten und den Vorteiler auf 1024
einstellen wird also der Timer mit einer Frequenz von 4 MHz / 1024, also mit ca.
4 kHz versorgt. Wenn also der Timer läuft, so wird das Daten- bzw.
Zählregister mit dieser Frequenz inkrementiert.

== 8-Bit Timer/Counter ==

Alle AVR-Modelle weisen mindestens einen, teilweise sogar zwei, 8-Bit Timer
auf.

Der 8-Bit Timer wird über folgende Register angesprochen:

{| border="1"
|-
| '''TCCR0'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
Timer '''0'''

In diesem Register stellen wir ein, wie wir den Timer/Counter verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CS02'''
| align="center" | '''CS01'''
| align="center" | '''CS00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''CS02, CS01, CS00''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS02
| align="center" | CS01
| align="center" | CS00
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin '''TO''', fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin '''TO''', steigende Flanke
|}
</dd>
</dl>
:Wenn als Quelle der externe Pin '''TO''' verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin '''TO''' als Ausgang geschaltet ist.

|-
| '''TCNT0'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer '''0''' 
Dieses ist als 8-Bit Aufwärtszähler mit Schreib- und Lesezugriff
realisiert. Wenn der Zähler den Wert 255 erreicht hat beginnt er beim
nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}
|}

Um nun also den Timer0 in Betrieb zu setzen und ihn mit einer Frequenz von 1/1024-tel des CPU-Taktes zählen zu lassen, schreiben wir die folgende Befehlszeile:

<pre class="code">
TCCR0 = (1<<CS00)|(1<<CS02);
</pre>

Der Zähler zählt nun aufwärts bis 255, um dann wieder bei 0 zu beginnen. Der aktuelle Zählerstand steht in TCNT0. Bei jedem Überlauf von 255 auf 0 wird das Timer Overflow Flag '''TOV0''' im Timer Interrupt Flag '''TIFR'''-Register gesetzt und, falls so konfiguriert, ein entsprechender Timer-Overflow-Interrupt ausgelöst.

== 16-Bit Timer/Counter ==

Viele AVR-Modelle besitzen ausser den 8-Bit Timers auch einen oder sogar zwei
(einige ATmega-Modelle) 16-Bit Timer.

Die 16-Bit Timer/Counter sind wesentlich komplexer aufgebaut als die 8-Bit
Timer/Counter, bieten dafür aber auch viel mehr Möglichkeiten, als da sind:

* Die [[PWM]]-Betriebsart Erzeugung eines pulsweitenmodulierten Ausgangssignals.
* Vergleichswert-Überprüfung mit Erzeugung eines Ausgangssignals (Output Compare Match).
* Einfangen eines Eingangssignals mit Speicherung des aktuellen Zählerwertes (Input Capturing), mit zuschaltbarer Rauschunterdrückung (Noise Filtering).

Folgende Register sind dem Timer/Counter 1 zugeordnet:

{| border="1"
|-
| '''TCCR1A'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''A''' Timer '''1''' 
In diesem und dem folgenden Register stellen wir ein, wie wir den Timer/Counter verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''COM1A1''', '''COM1A0''' ('''Co'''mpare '''M'''atch Control Bits)
:Diese 2 Bits bestimmen die Aktion, welche am Output-Pin '''OC1''' ausgeführt werden soll, wenn der Wert des Datenregisters des Timer/Counter 1 den Wert des Vergleichsregisters erreicht, also ein so genannter Compare Match auftritt.
:Der Pin '''OC1''' ('''PB3''' beim 2313) muss mit dem Datenrichtungsregister als Ausgang konfiguriert werden.

<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Das Signal am Pin '''OC1''' wird invertiert (Toggle).
|-
| align="center" | 1
| align="center" | 0
| Der Output Pin '''OC1''' wird auf 0 gesetzt.
|-
| align="center" | 1
| align="center" | 1
| Der Output Pin '''OC1''' wird auf 1 gesetzt.
|}
</dd></dl>
:In der PWM-Betriebsart haben diese Bits eine andere Funktion.
<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 1
| align="center" | 0
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 0 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 1 gesetzt.

Man nennt dies ''nicht invertierende PWM''.
|-
| align="center" | 1
| align="center" | 1
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 1 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 0 gesetzt.

Man nennt dies ''invertierende PWM''.
|}
</dd></dl>

'''PWM11''', '''PWM10''' ('''PWM''' Mode Select Bits)
:Mit diesen 2 Bits wird die PWM-Betriebsart des Timer/Counter 1 gesteuert.
<dl><dd>
{| border="1"
|-
| align="center" | PWM11
| align="center" | PWM10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Die PWM-Betriebsart ist nicht aktiviert. Timer/Counter 1 arbeitet als normaler Timer bzw. Zähler.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM Betriebsart aktivieren.
|}
</dd></dl>
|-
| '''TCCR1B'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''B''' Timer '''1'''

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ICNC1'''
| align="center" | '''ICES1'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CTC1'''
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''ICNC1''' ('''I'''nput '''C'''apture '''N'''oise '''C'''anceler (4 CKs) Timer/Counter 1
:oder auf Deutsch Rauschunterdrückung des Eingangssignals.
:Wenn dieses Bit gesetzt ist und mit dem Input Capture Signal gearbeitet wird so werden nach der Triggerung des Signals mit der entsprechenden Flanke (steigend oder fallend) am Input Capture Pin '''ICP''' jeweils 4 Messungen mit der CPU-Frequenz des Eingangssignals abgefragt. Nur dann, wenn alle 4 Messungen den gleichen Zustand aufweisen gilt das Signal als erkannt.

'''ICES1''' ('''I'''nput '''C'''apture '''E'''dge '''S'''elect Timer/Counter '''1''')
:Mit diesem Bit wird bestimmt, ob die steigende ('''ICES1'''=1) oder fallende ('''ICES1'''=0) Flanke zur Auswertung des Input Capture Signals an Pin '''ICP''' heran gezogen wird.

'''CTC1''' ('''C'''lear '''T'''imer/'''C'''ounter on Compare Match Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, so wird nach einer Übereinstimmung des Datenregisters '''TCNT1H'''/'''TCNT1L''' mit dem Vergleichswert in '''OCR1H'''/'''OCR1L''' das Datenregister '''TCNT1H'''/'''TCNT1L''' auf 0 gesetzt.
:Da die Übereinstimmung im Takt nach dem Vergleich behandelt wird, ergibt sich je nach eingestelltem Vorzähler ein etwas anderes Zählverhalten:
:Wenn der Vorteiler auf 1 gestellt ist und C der jeweilige Zählerwert ist, dann nimmt das Datenregister, im CPU-Takt betrachtet, folgende Werte an:
:... | C-2 | C-1 | C | 0 | 1 |...
:Wenn der Vorteiler z.B. auf 8 eingestellt ist, dann nimmt das Datenregister folgende Werte an:
:... | C-2, C-2, C-2, C-2, C-2, C-2, C-2, C-2 | C-1, C-1, C-1, C-1, C-1, C-1, C-1, C-1 | C, 0, 0, 0, 0, 0, 0, 0 |...
:In der PWM-Betriebsart hat dieses Bit keine Funktion.

'''CS12''', '''CS11''', '''CS10''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS12
| align="center" | CS11
| align="center" | CS10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin TO, fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin T0, steigende Flanke
|}
</dd></dl>
:Wenn als Quelle der externe Pin T0 verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin T0 als Ausgang geschaltet ist.
|-
| '''TCNT1H''' '''TCNT1L'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer/Counter '''1'''
Dieses ist als 16-Bit Aufwärtszähler mit Schreib- und Lesezugriff realisiert. Wenn der Zähler den Wert 65535 erreicht hat, beginnt er beim nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''TCNT1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''TCNT1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

In der PWM-Betriebsart wird das Register als Auf/Ab-Zähler verwendet, d.h. der Wert steigt zuerst von 0 bis er den Überlauf von 65535 auf 0 erreicht hat. Dann zählt das Register rückwärts wiederum bis 0.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.

Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''OCR1H''' '''OCR1L'''
| Timer/Counter '''O'''utput '''C'''ompare '''R'''egister Timer/Counter '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''OCR1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''OCR1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Der Wert im Output Compare Register wird ständig mit dem aktuellen Wert im Datenregister TCNT1H/TCNT1L verglichen. Stimmen die beiden Werte überein, so wird ein sogenannter Output Compare Match ausgelöst. Die entsprechenden Aktionen werden über die Timer/Counter 1 Control und Status Register eingestellt.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''ICR1H''' '''ICR1L'''
| Timer/Counter '''I'''nput '''C'''apture '''R'''egister Timer/Counter '''1''' 
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''ICR1''''''H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''ICR1''''''L'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Das Input Capture Register ist ein 16-Bit Register mit Lesezugriff. Es kann nicht beschrieben werden.

Wenn am Input Capture Pin '''ICP''' die gemäß Einstellungen im '''TCCR1B''' definierte Flanke erkannt wird, so wird der aktuelle Inhalt des Datenregisters '''TCNT1H'''/'''TCNT1L''' sofort in dieses Register kopiert und das Input Capture Flag '''ICF1''' im Timer Interrupt Flag Register '''TIFR''' gesetzt.

Wie bereits oben erwähnt, müssen vor dem Zugriff auf dieses Register alle Interrupts gesperrt werden. Zudem müssen Low- und Highbyte des Registers in der richtigen Reihenfolge bearbeitet werden:

{| border="0"
|-
| Lesen:
| '''ICR1L''' -> '''ICR1H'''
|-
| Schreiben:
| '''ICR1H''' -> '''ICR1L'''
|}
|}

=== Die PWM-Betriebsart ===

Wenn der Timer/Counter 1 in der PWM-Betriebsart betrieben wird, so bilden das Datenregister '''TCNT1H'''/'''TCNT1L''' und das Vergleichsregister '''OCR1H'''/'''OCR1L''' einen 8-, 9- oder 10-Bit, frei laufenden PWM-Modulator, welcher als PWM-Signal am '''OC1'''-Pin ('''PB3''' beim 2313) abgegriffen werden kann. Das Datenregister '''TCNT1H'''/'''TCNT1L''' wird dabei als Auf-/Ab-Zähler betrieben, welcher von 0 an aufwärts zählt bis zur Obergrenze und danach wieder zurück auf 0.
Die Obergrenze ergibt sich daraus, ob 8-, 9- oder 10-Bit PWM verwendet wird, und zwar gemäss folgender Tabelle:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Wenn nun der Zählerwert im Datenregister den in '''OCR1H'''/'''OCR1L''' gespeicherten Wert erreicht, wird der Ausgabepin '''OC1''' gesetzt bzw. gelöscht, je nach Einstellung von '''COM1A1''' und '''COM1A0''' im '''TCCR1A'''-Register.

Ich habe versucht, die entsprechenden Signale in der folgenden Grafik zusammenzufassen

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

=== Vergleichswert-Überprüfung ===

Hier wird in ein spezielles Vergleichswertregister ('''OCR1H'''/'''OCR1L''') ein Wert eingeschrieben, welcher ständig mit dem aktuellen Zählerwert verglichen wird.
Erreicht der Zähler den in diesem Register eingetragenen Wert, so kann ein Signal (0 oder 1) am Pin '''OC1''' erzeugt und/oder ein Interrupt ausgelöst werden.

=== Einfangen eines Eingangssignals (Input Capturing) ===

Bei dieser Betriebsart wird an den Input Capturing Pin (ICP) des Controllers eine Signalquelle angeschlossen.
Nun kann je nach Konfiguration entweder ein Signalwechsel von 0 nach 1 (steigende Flanke) oder von 1 nach 0 (fallende Flanke) erkannt werden und der zu diesem Zeitpunkt aktuelle Zählerstand in ein spezielles Register abgelegt werden. Gleichzeitig kann auch ein entsprechender Interrupt ausgelöst werden.
Wenn die Signalquelle ein starkes Rauschen beinhaltet, kann die Rauschunterdrückung eingeschaltet werden. Dann wird beim Erkennen der konfigurierten Flanke über 4 Taktzyklen das Signal überwacht und nur dann, wenn alle 4 Messungen gleich sind, wird die entsprechende Aktion ausgelöst.

== Gemeinsame Register ==

Verschiedene Register beinhalten Zustände und Einstellungen, welche sowohl
für den 8-Bit, als auch für den 16-Bit Timer/Counter in ein und demselben
Register zu finden sind.

{| border="1"
|-
| '''TIMSK'''
| '''T'''imer/Counter '''I'''nterrupt '''M'''a'''sk'''
Register

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOIE1'''
| align="center" | '''OCIE1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''TICIE'''
| align="center" | '''-'''
| align="center" | '''TOIE0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOIE1''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 1 ein Timer Overflow 1 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''OCIE1A''' ('''O'''utput '''C'''ompare Match '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Beim Timer/Counter 1 kann zusätzlich zum Überlauf ein Vergleichswert definiert werden.

:Wenn dieses Bit gesetzt ist, wird beim Erreichen des Vergleichswertes ein Compare Match Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TICIE''' ('''T'''imer/Counter '''I'''nput '''C'''apture '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein Capture Event Interrupt ausgelöst, wenn ein entsprechendes Signalereignis am Pin PD6(ICP) auftritt. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein, wenn auch ein entsprechender Interrupt ausgelöst werden soll.

'''TOIE0''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''0''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 0 ein Timer Overflow 0 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

|-
| '''TIFR'''
| '''T'''imer/Counter '''I'''nterrupt '''F'''lag '''R'''egister

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOV1'''
| align="center" | '''OCF1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''ICF1'''
| align="center" | '''-'''
| align="center" | '''TOV0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOV1''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''1''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 1 ein Überlauf des Datenregisters stattfindet.

:In der PWM-Betriebsart wird das Bit gesetzt, wenn die Zählrichtung von auf- zu abwärts und umgekehrt geändert wird (Zählerwert = 0).

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''OCF1A''' ('''O'''utput '''C'''ompare '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn der aktuelle Wert des Datenregisters von Timer/Counter 1 mit demjenigen im Vergleichsregister '''OCR1''' übereinstimmt.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''ICF1''' ('''I'''nput '''C'''apture '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn ein Capture-Ereignis aufgetreten ist, welches anzeigt, dass der Wert des Datenregisters des Timer/Counter 1 in das Input Capture Register ICR1 übertragen wurde.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''TOV0''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''0''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 0 ein Überlauf des Datenregisters stattfindet.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.
|}

 

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sog. ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comperators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrups den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

* '''set_sleep_mode(uint8_t mode)'''
:Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z.B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
* '''sleep_mode()'''
:Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus.

<pre class="code">
#include <avr/io.h>
#include <avr/sleep.h>
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach auftreten eines entsprechenden "Aufwach-Interrupts" verarbeitet
...
</pre>

Vorsicht: Nicht alle AVR-Controller (v.a. nicht die "Brandneuen") werden von den avr-libc sleep-Funktionen richtig angesteuert. Bei nicht-untersützten Typen erreicht man die gewollte Funktionalität durch direkte "Bitmanipulation" der ensprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler:

<pre class="code">
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep");
...
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes

= Der Watchdog =

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der Watchdog.

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln.

Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

Betrachten wir doch einmal folgende Codesequenz:

<pre class="code">
uint8_t x;

x = 10;

while (x >= 0) {
// tu was

x--;
}
</pre>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm würde sich also hier aufhängen und auf ewig in der Schleife drehen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde beginnt der Counter von 0 an hochzuzählen. Wenn nun die je nach Vorteiler eingestellte Anzahl Zyklen erreicht wurde, löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern müssen wir den Watchdog regelmässig wieder neu starten bzw. Rücksetzen (Watchdog Reset). Dies sollte innerehalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern muss ein spezielles Prozedere verwendet werden, um den WD auszuschalten und zwar müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden. Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| border="1"
|-
| '''WDTCR'''
| '''W'''atchog '''T'''imer  '''C'''ontrol '''R'''egister

In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''WDTOE'''
| align="center" | '''WDE'''
| align="center" | '''WDP2'''
| align="center" | '''WDP1'''
| align="center" | '''WDP0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''WDTOE''' ('''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable)
:Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
:Wenn das Bit einmal gesetzt ist wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.

'''WDE''' ('''W'''atch'''d'''og '''E'''nable)
:Wenn dieses Bit gesetzt wird, so wird der Watchdog aktiviert.
:Das Bit kann nur gelöscht werden, solange das Bit '''WDTOE''' auf 1 steht.

'''WDP2''', '''WDP1''', '''WDP0''' ('''W'''atch'''d'''og Timer '''P'''rescaler Bits)
:Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:
<dl><dd>
{| border="1"
|-
| align="center" | WDP2
| align="center" | WDP1
| align="center" | WDP0
| align="center" | Anzahl Zyklen
| align="center" | Typ. Timeoutzeit bei Vcc = 3V
| align="center" | Typ. Timeoutzeit bei Vcc = 5V
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 16K
| align="center" | 47ms
| align="center" | 15ms
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 32K
| align="center" | 94ms
| align="center" | 30ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 64K
| align="center" | 0.19s
| align="center" | 60ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 128K
| align="center" | 0.38s
| align="center" | 0.12s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 256K
| align="center" | 0.75s
| align="center" | 0.24s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 512K
| align="center" | 1.5s
| align="center" | 0.49s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 1024K
| align="center" | 3s
| align="center" | 0.97s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 2048K
| align="center" | 6s
| align="center" | 1.9s
|}
</dd></dl>
|}

Um den Watchdog mit dem AVR-GCC Compiler zu verwenden, muss die Headerdatei wdt.h in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

* '''wdt_enable(uint8_t timeout)'''
:Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert (z.B. WDTO_30MS).
* '''wdt_disable()'''
:Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
* '''wdt_reset()'''
:Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Ein paar grundsätzliche Gedanken ==

Ob nun so ein Watchdog überhaupt verwendet werden soll, ist wohl eher eine
philosophische Frage und hängt vom Geschmack jedes einzelnen Entwicklers ab.

Ich persönlich habe es lieber, wenn ich auch merke, dass in meine Programm
etwas noch nicht in Ordnung ist, als dass mir ein Watchdog einfach die CPU immer
wieder zurücksetzt, denn immerhin kann es so passieren, dass ein Programm über
Jahre hinweg so einigermassen läuft, obwohl noch ein voll krasser Bock drin
liegt.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Watchdog timer handling

= Programmieren mit Interrupts =

Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

[[Image:Interrupt Programme.gif]]

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

== Anforderungen an die Interrupt-Routine ==

Um unliebsamen Überraschungen vorzubeugen sollten einige Grundregeln bei
der Gestaltung der Interruptroutinen beachtet werden.

* Die Interruptroutine soll möglichst kurz und schnell abarbeitbar sein, daraus folgt:
* Keine unfangreichen Berechnungen innerhalb der Interruptroutine.
* Keine endlos langen Programmschleifen.
* Obschon es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen rate ich dringend von solchen Spielen ab.

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf dem AVR auslösen, wobei
die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

== Register ==

Der AT90S2313 verfügt über 2 Register welche mit den
Interrupts zusammen hängen.

{| border="1"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INT1'''
| align="center" | '''INT0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''INT1'''
| External '''Int'''errupt Request '''1''' Enable
Wenn dieses Bit gesetzt ist wird ein Interrupt ausgelöst wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.
|-
| '''INT0'''
| External '''Int'''errupt Request '''0''' Enable
Wenn dieses Bit gesetzt ist wird ein Interrupt ausgelöst wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.
|}
|}

{| border="1"
|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INTF1'''
| align="center" | '''INTF0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''INTF1'''
| External '''Int'''errupt Flag '''1'''
Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist wird die
Interruptroutine angesprungen.
Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist.
Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''INTF0'''
| External '''Int'''errupt Flag '''0''' 
Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist wird die
Interruptroutine angesprungen.
Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist.
Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|}
|}

{| border="1"
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister. 
Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''SE'''
| align="center" | '''SM'''
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''SE'''
| '''S'''leep '''E'''nable
Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl
in den Schlafzustand versetzen zu können.
Um den Schlafmodus nicht irrtümlich einzuschalten wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.
|-
| '''SM'''
| '''S'''leep '''M'''ode
Dieses Bit bestimmt der Schlafmodus.
Ist das Bit gelöscht so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")
|-
| '''ISC11''' '''ISC10'''
| '''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits
Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.

{| border="1"
|-
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt. 
In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}
|-
| '''ISC01''' '''ISC00'''
| '''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits
Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

{| border="1"
|-
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.
In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}
|}
|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft wird automatisch das '''Global
Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle
weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem
Zeitpunkt bereits wieder das GIE-bit zu setzen rate ich dringend davon ab. Dieses
wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn
in der Zwischenzeit weitere Interrupts eintreffen werden die zugehörigen
Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden
Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt
ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle
anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe,
weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.

=== Das Status-Register ===

Es gilt auch zu beachten, dass das Status-Register während der Abarbeitung
einer Interruptroutine nicht automatisch gesichert wird. Falls notwendig muss dies vom
Programmierer selber vorgesehen werden.

== Interrupts mit dem AVR GCC Compiler (WinAVR) ==

Selbstverständlich können alle Interruptspezifischen Registerzugriffe wie gewohnt über I/O-Adressierung vorgenommen werden. Etwas einfacher geht es jedoch, wenn wir die vom Compiler zur Verfügung gestellten Mittel einsetzen.

Damit diese Mittel zur Verfügung stehen müssen wir die Includedatei interrupt.h und evtl. signal.h einbinden mittels:

<pre class="code">
// fuer sei(), cli() und INTERRUPT():
#include <avr/interrupt.h>

// fuer SIGNAL() auch:
#include <avr/signal.h>
</pre>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird
nichts anderes gemacht als das '''Global Interrupt Enable''' Bit im Status
Register gesetzt.

<pre class="code">
sei();
</pre>

Das Makro '''cli()''' schaltet die Interrupts aus oder anders
gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird
gelöscht.
<pre class="code">
cli();
</pre>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf.
Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen.
Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren
und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen
Zustands die Interrups aktivieren, was zu unerwünschten Seiteneffekten führen kann.
Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern */

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD); // 2 mal in Folge , vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
...

}
</pre>



Nachdem nun die Interrupts aktiviert sind braucht es selbstverständlich noch den auszuführenden Code, der ablaufen soll wenn ein Interrupt eintrifft. Dazu gibt es zwei Definitionen: '''SIGNAL''' und '''INTERRUPT''', welche allerdings AVR-GCC spezifisch sind und bei anderen Compilern womöglich anders heissen können.

=== SIGNAL ===

<pre class="code">
#include <avr/signal.h>
...
SIGNAL (siglabel)
{
/* Interrupt Code */
}
</pre>

Mit ''SIGNAL'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektoren angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Vor Nutzung von SIGNAL muss die Header-Datei signal.h eingebunden werden. Mögliche Funktionsrümpfe für solche Interruptfunktionen sind zum Beispiel:

<pre class="code">
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

SIGNAL (SIG_OVERFLOW1)
{
/* Interrupt Code */
}

SIGNAL (SIG_UART_RECV)
{
/* Interrupt Code */
}

// und so weiter und so fort...
</pre>

Während der Ausführung des Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== INTERRUPT ===

<pre class="code">
#include <avr/interrupt.h>
...
INTERRUPT (signame)
{
/* Interrupt Code */
}
</pre>

Mit INTERRUPT wird genau gleich gearbeitet wie mit SIGNAL. Der Unterschied ist derjenige, dass bei INTERRUPT beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit automatisch wieder gesetzt und somit weitere Interrupts zugelassen werden. Dies kann zu nicht unerheblichen Problemen von im einfachsten Fall einem Stack overflow bis zu sonstigen unerwarteten Effekten führen und sollte wirklich '''nur dann''' angewendet werden, wenn man sich absolut sicher ist, das Ganze auch im Griff zu haben. Vor Nutzung von INTERRUPT muss die Header-Datei interrupt.h eingebunden werden.

Interruptroutinen (ISRs) sollten möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern den Zustand aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

siehe auch: Hinweise in [[AVR-GCC]]

== Datenaustausch mit Interrupt-Routinen ==

Variablen auf die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen wird und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte die Code-Optimierung "greifen" und der Wert der Variablen nur in Prozessorregistern zwischenspeichert werden, die "nichts von der Änderung woanders mitbekommen".

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z.B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt z.B. alle 10ms
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
// hier wird gKeyCounter veraendert, die uebrigen
// Programmteile muessen diese Aenderung "sehen"
// (volatile -> aktuellen Wert immer in den Speicher schreiben)
if ( !(KEY_PIN & (1<<KEY_PINNO)) )
if (gKeyCouter < CNTREPEAT) gKeyCounter++;
else gKeyCounter = 0;
}

...

int main(void)
{
...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
...
// hier wird auf gKeyCounter zugegriffen, dazu muss der in der
// ISR geschrieben Wert bekannt sein.
// (volatile -> aktuellen Wert immer aus dem Speicher lesen)
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt"
}
else {
/* hier: Code fuer "Taste kurz gedrueckt"
}
...
}
</pre>

Bei Variablen größer ein Byte muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes ausserhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<pre class="code">
...
volatile uint16_t gMyCounter16bit
...
SIGNAL(...)
{
...
gMyCounter16Bit++;
...
}

int main(void)
{
uint16_t tmpCnt;
...
// nicht gut: mglw. hier ein Fehler wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor Kopieren des zweiten Bytes
// ein Interrupt auftritt der den Inhalt von MyCounter veraendert
tmpCnt = gMyCounter16bit;

// besser: Aenderungen "ausserhalb" verhindern, alle "Teilbytes"
// bleiben konsistent
cli(); // Interupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren
...
}
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8 (Stand: avr-libc Vers. 1.0.4)

== Was macht das Hauptprogramm ==

Im einfachsten Fall gar nichts mehr. 
Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der
main-Funktion lediglich noch die Interrupts aktiviert und dann in eine
Endlosschleife folgender Art verzweigt:

<pre class="code">
...
for (;;) {}
...
</pre>

Normalerweise wird man allerdings in den Interruptroutinen die Interrupts
erfassen und im Hauptprogramm dann gemütlich auswerten.

Wie wir im bisherigen Kursverlauf gesehen haben ist es ohnehin mit so
schnellen Controller meistens gar nicht unbedingt notwendig mit
Interruptfunktionen zu arbeiten. 
Es ist allerdings auch zu bemerken, dass mit den Interruptroutinen ein Programm
sehr schön strukturiert werden kann, wenn man es richtig macht.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (eigentlich [[SRAM]]) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als [[FLASH]]-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z.B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin wenig Sinn macht und auch nur bei einigen RAM-losen Typen nach "Bastelarbeiten" möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory). Die Standard-Laufzeitbibliothek des avr-gcc, die [[avr-libc]], stellt diese Funktionen nach einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Einige Beispiele:

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray1 };
...
</pre>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<pre class="code">
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte...
}
</pre>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel jedoch mit der Funktion pgm_read_word.

<pre class="code">
uint16_t myWord;

myWord = pgm_read_word(&pgmFooWord);
</pre>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "gross". (Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.) Pointer müssen gegebenenfalls "gecastet" werden.

<pre class="code">
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray1

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray2
// da im zweiteb Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmPointerToArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</pre>

=== Floats und Structs lesen ===

Um komplexe Datentypen (structs), nicht-integer Datentypen (floats) aus dem Flash auszulesen, sind Hilfsfunktionen erforderlich. Einige Beispiele:

<pre class="code">

/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
...

/* liest float von Flash-Addresse addr und gibt diese als return-value zurueck */
inline float pgm_read_float(const float *addr)
{
union
{
uint16_t i[2]; // 2 16-bit-Worte
float f;
} u;

u.i[0]=pgm_read_word((PGM_P)addr);
u.i[1]=pgm_read_word((PGM_P)addr+2);

return u.f;
}
...

void egal(void)
{
int i;
float f;

for (i=0;i<3;i++) {
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach' was mit f
}
}
</pre>

TODO: Beispiele fuer structs und pointer aus flash auf struct im flash (menues, state-machines etc.)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuerht, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
...
</pre>

Aber Achtung: Ersetzt man zum Beispiel
<pre class="code">
const char textImFlash[] PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
durch
<pre class="code">
const char textImFlash* PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der textImFlash zu den Konstanten ans Ende des Programmcodes gelegt wird, von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte. Da der lesende Code trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein Bug des AVR-GCC (gesehen bei 3.4.1) zu sein.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<pre class="code">
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
...
</pre>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z.B. 0x01fe), "weiss" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, das der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000) wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z.B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmässig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, das vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgeben sind ("timed sequence"). Diese Prüfung wird nicht implizit durchgeführt. Im Zweifel kann man Sicherheitshalber bei EEPROM-Zugriffen die Interrupts global deaktivieren, z.B. so:

<pre class="code">
...
uint8_t sreg;
...

sreg = SREG;
cli();

/* hier die eeprom-Zugriffe */

SREG = sreg;
...
</pre>

Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Die Nutzung einer [[C-Präprozessor]]-Ersetzung bringt etwas Bequemlichkeit. Siehe dazu folgendes Beispiel.

<pre class="code">
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h>

// alle Textstellen EEPROM im Quellcode durch __attribute__ ... ersetzen
#define EEPROM __attribute__ ((section (".eeprom")))

...

/* Byte */
uint8_t eeFooByte EEPROM = 123;

/* Wort */
uint16_t eeFooWort EEPROM = 12345;

/* float */
float eeFooFloat EEPROM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEPROM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEPROM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */

uint16_t eeFooWordArray1[4] EEPROM;
...
</pre>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heisst eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<pre class="code">
...
uint8_t myByte;
uint8_t sreg;

sreg = SREG; // (1)
cli(); // (1)

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
...
SREG = sreg; // (1)
</pre>

Die mit (1) markierten Zeilen dienen hierbei dem (möglicherweise übertriebenen) Schutz vor Unterbrechnungen durch Interrupts.

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<pre class="code">
...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
...
</pre>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprueft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und mglw. noch mehr.

<pre class="code">
...
unit8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes aber der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnuetze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray[0],3);

/* dito mit etwas Absicherung betr. der Laenge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));

/* Datenlock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));
...
</pre>

"Nicht-Integer"-Datentypen wie z.B. Fliesskommazahlen lassen sich recht praktisch ueber eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<pre class="code">
...
float myFloat = 12.34;

union {
float r;
uint8_t n[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */
...
</pre>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<pre class="code">
...
typedef struct {
uint8_t label[8];
unin8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEPROM;

...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
...
}
...
</pre>

=== EEPROM-Speicherabbild in .eep-Datei ===

Eine besondere Funktion des avr-gcc ist, dass mit einem entsprechenden makefile aus den Initialisierungswerten der Variablen im Quellcode eine Datei erzeugt werden kann, die man auf den Controller programmieren kann (.eep-Datei). Damit können sehr elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Die Vorgehensweise wird aus dem WinAVR-Beispielmakefile ersichtlich. Siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles.

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Nicht alle neuen AVR Controller werden von avr-libc/eeprom.h untersützt (Stand Version 1.0.4). Insbesondere beim ATMega169 funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register) Etwas ältere Typen, oder zu den "etablierten" Controllern kompatible, bereiten jedoch hier keine Proleme. Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Der dort gezeigt Code kann direkt auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste").

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gcc-Toolchain" bietet dazu zwei Möglichkeiten:

;Inline-Assembler:
Die Assembleranweisungen werden in direkt in den C-Code integriert. Eine Quellcode-Datei enhält somit C- und Assembleranweisungen

;Assembler-Dateien:
Der Assembler-Codecode befindet sich in eigenen Quellcodedateien. Dieser werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z.B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen eine NOP-Anweisung. NOP steht für '''NO'''-O'''P'''eration. Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=warte)-Funktionen.

<pre class="code">
...
/* Verzoegern der weiteren Programmausfuehrung um
genau 3 Taktzyklen */
asm volatile ("nop"::);
asm volatile ("nop"::);
asm volatile ("nop"::);
...
</pre>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeindlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<pre class="code">
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i=0;i<1000;i++);

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i=0;i<1000;i++) asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j=0;j<1000;j++);
</pre>

Ein weiterer nützliche "Assembler-Einzeiler" ist der Auruf von sleep (''asm volatile ("sleep"::);''), da hierzu keine eigene Funktion in der avr-libc existiert.

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil des die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<pre class="code">
static inline void delayloop16(uint16_t count)
{
asm volatile ( "cp %A0,__zero_reg__ \n\t" \
"cpc %B0,__zero_reg__ \n\t" \
"breq L_Exit_%= \n\t" \
"L_LOOP_%=: \n\t" \
"sbiw %0,1 \n\t" \
"brne L_LOOP_%= \n\t" \
"L_Exit_%=: \n\t" \
: "=w" (count)
: "0" (count)
);
}
</pre>

* Jede Zeile wird mit '''\n\t''' abgeschlossen, alle Zeilen mit '''\''' verbunden.
* Sprung-Marken (labels) werden mit einm Prozentzeichen abgeschlossen, der Präprozessor (Assembler?) setzt an dieser Stelle eine laufende Nummer ein, die Doppelbezeichnungen bei mehrmaliger Verwendung somit verhindert.

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc.

* siehe auch: Dokumentation der avr-libc/Related Pages/Inline Asm
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

...TODO: Beispiele, Parameteruebergabe, globale Variablen für Datenaustausch

= TODO =

stdio.h, malloc() ???, Code-Optimierungen ("tricks"), "naked"-Functionen ??, IO-Register als Parameter/"Variablen" (volatile uint8_t *mybusport; mybusport=&PORTB; void sendbus(uint8_t *parm)...)

= C-Code und Bibliotheken für externe Baugrupen =
(TODO: sollte in avr-gcc verschoben werden)
[[Linksammlung#Avr]]

==LCD==
=== Text (character-mode) HD44870 ===
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray

=== Grafik-LCD ===
==== Nokia3310 ====
==== Nokia 6100 LCD ====
Das Nokia ist ein 132x132x4096 Farben Display das bei eBay ziemlich preiswert ersteigert werden kann.
[http://www.apetech.de/nokia6100.php Nokia 6100 LCD Library]
==== KS0108 ====
* Procyon avrlib (GPL)
* avrfreaks UP
* apetech.de
==Schnittstellen==
===I2C===
====Master====
[http://jump.to/fleury/ P. Fleurys I2C Master library]
====Slave====

===CAN===
* [http://www.atmel.com] Codesammlung zum AT90CAN128

=== DS18S20/1-Wire ===
* avrfreaks Projekt 59
* mikrocontroller.net/codesammlung (P. Dannegger)

=== UART ===
* Procyon avrlib (GPL)
* avrfreaks UP (viele viele)
* P. Fleury

== Speicherkarten/IDE/FAT ==
* avrfreaks UP (IDE/FAT read write)
== CRC ==
* avrfreaks-forum (O'Flynn)
* avr-hal (GPL)

AVR-GCC-Tutorial

2004-11-12T13:02:38Z

Oxygene: /* Sleep-Modes */

[[Category:AVR]]

= Vorwort =

Dieses Tutorial soll Einsteigern helfen, mit der Programmiersprache '''C''' die Mikrocontroller der Atmel AVR-Reihe zu programmieren.


Die ursprüngliche Version stammt von Christian Schifferle, die meisten aktuellen Anpassungen von [[Benutzer:Mthomas]]. Viele der im Original-Dokument verwendeten Funktionen sind in
aktuellen Versionen des avr-gcc C-Compilers und der avr-libc zwar noch enthalten,
aber als überholt (''deprecated'') ausgewiesen. D.h. diese Funktionen sollten nicht mehr verwendet
werden und existieren in zukünftigen Versionen des Compilers/der Library nicht mehr
(z.B. sbi(), cbi(), outp(), inp()). Der Artikel wurde auf die neuen Funktionen/Methoden
angepasst.

In diesem Text wird häufig auf die Standardbibliothek für den avr-gcc-Compiler, die avr-libc, verwiesen. Die '''Dokumentation der avr-libc''' findet sich
[http://www.nongnu.org/avr-libc/user-manual/index.html hier]. Bei WinAVR gehört diese Dokumentation zum Lieferumfang und wird mitinstalliert.

= Benötigte Werkzeuge =

Um die Übungen in diesem Tutorial nachvollziehen zu können benötigen wir folgende Hard- und Software:

* Testboard für die Aufnahme eines AVR Controllers, der vom gcc Compiler untersützt wird (alle ATmegas und die meisten AT90). Dieses Testboard kann durchaus auch selber zusammen gelötet werden. So arbeite ich mit einem Testboard, welches ich mir auf einer Veroboard-Platine zusammen gestellt habe. Für die Versuche bzw. Übungen in diesem Tutorial habe ich jeweils einen AT90S2313 verwendet. Eine brauchbare Testplattform ist auch der [[AVR Butterfly]].
* AVRGCC-Compiler. Kostenlos erhältlich für nahezu alle Plattformen/Betriebssysteme. Für MS-Windows im Packet [[WinAVR]]; für Unix/Linx siehe auch Hinweise im Artikel [[AVR-GCC]].
* Programmiersoftware und Hardware z.B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], [[AVR-Studio]]).
* Nicht unbedingt erforderlich aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Abschnitt Exkurs: makefiles).

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.
* Die [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently Asked Questions = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.
* Das gcc-Forum auf [http://www.mikrocontroller.net www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.
* Das avr-gcc-Forum bei [http://www.avrfreaks.net avrfreaks] nach vergleichbaren Problemen absuchen.
* Das [http://www.avr1.org/pipermail/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.
* Nach Beispielcode suchen. Vor allem in der Academy von [http://www.avrfreaks.net AVRFREAKS] (anmelden).
* Google oder alltheweb befragen schadet nie.
* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal)
* einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei mgl. viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode, genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z.B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: [http://www.lugbz.org/documents/smart-questions_de.html "Wie man Fragen stellt"].

= Exkurs: makefiles =

Wenn man bisher gewohnt ist, mit integrierten Entwicklungsumgebung à la Visual-C Programme zu erstellen, wirkt das makefile-Konzept auf den ersten Blick etwas kryptisch. Nach kurzer Einarbeitung ist diese Vorgehensweise jedoch sehr praktisch. Diese Dateien (üblicher Name: 'Makefile' ohne Dateiendung) dienen der Ablaufsteuerung des Programms make, das auf allen Unix/Linux-Systemen installiert sein sollte, und in einer Fassung fuer MS-Windows auch in [[WinAVR]] (Unterverzeichnis utils/bin) enthalten ist.

Im Unterverzeichnis ''sample'' einer WinAVR-Installation findet man eine sehr brauchbare Vorlage, die sich einfach an das eigene Projekt anpassen lässt ([[Media:Makefile|lokale Kopie Stand Sept. 2004]]). Wahlweise kann man auch [http://www.sax.de/~joerg/mfile/ mfile] von Jörg Wunsch nutzen. mfile erzeugt ein makefile nach Einstellungen in einer grafischen Nutzeroberfläche, wird bei WinAVR mitinstalliert, ist aber als TCL/TK-Programm auf nahezu allen Platformen lauffähig.

''Die folgenden Ausführungen beziehen sich auf das WinAVR Beispiel-Makefile.''

Ist im Makefile alles richtig eingestellt genügt es, sich drei Parameter zu merken, die über die shell bzw. die Windows-Kommandozeile (cmd.exe/command.exe) als Parameter an "make" übergeben werden. Das Programm make sucht sich "automatisch" das makefile im aktuellen Arbeitsverzeichnis und führt die darin definierten Operationen für den entsprechenden Aufrufparameter durch.

{| border=1
| ''make all''
| Erstellt aus den in im makefile angegebenen Quellcodes eine ''hex''-Datei (und ggf. auch ''eep''-Datei).
|-
| ''make program''
| Überträgt die hex-Datei (und wahlweise auch die eep-Datei für den EEPROM) zum AVR.
|-
| ''make clean''
| löscht alle temporären Dateien, also auch die hex-Datei
|}

Diese Aufrufe können in die allermeisten Editoren in "Tool-Menüs" eingebunden werden. Dies erspart den Kontakt mit der Kommandozeile. (Bei WinAVR sind die Aufrufe bereits im Tools-Menü des mitgelieferten Editors Programmers-Notepad eingefügt.)

Üblicherweise sind folgende Daten im makefile anzupassen:
* Controllertyp
* Quellcode-Dateien (c-Dateien)
* Typ und Anschluss des Programmiergeräts

seltener sind folgende Einstellungen durchzuführen:
* Grad der Optimierung
* Methode zur Erzeugung der Debug-Symbole (Debug-Format)
* Assembler-Quellcode-Dateien (S-Dateien)

Die in den folgenden Unterabschnitten gezeigten makefile-Ausschnitte sind für ein Programm, das auf einem ATmega8 ausgeführt werden soll. Der Quellcode besteht aus den c-Dateien superprog.c (darin main()), uart.c, lcd.c und 1wire.c. Im Quellcodeverzeichnis befinden sich diese Dateien: superprog.c, uart.h, uart.c, lcd.h, lcd.c, 1wire.h, 1wire.c und das makefile (die angepasste Kopie des WinAVR-Beispiels).

Der Controller wird mittels [[AVRDUDE]] über ein [[STK200]]-Programmierdongle an der Schnittstelle lpt1 (bzw. /dev/lp0) programmiert. Im Quellcode sind auch Daten für die ''section .eeprom'' definiert (siehe Abschnitt Speicherzugriffe TODO: nach unten verlinken), diese sollen beim Programmieren gleich mit ins EEPROM geschrieben werden.

== Controllertyp setzen ==

Dazu wird die "make-Variable" MCU entsprechend dem Namen des verwendenten Controllers gesetzt. Ein Liste der von avr-gcc und der avr-libc untersützten Typen findet sich in der [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc].

<pre class="code">
# Kommentare in Makefiles beginnen mit einem Doppelkreuz
...

# ATmega8 at work
MCU = atmega8
# oder MCU = atmega16
# oder MCU = at90s8535
# oder ...
...
</pre>

== Quellcode-Dateien einstellen ==

Den Namen der Quellcodedatei welche die Funktion main enthält, wird hinter TARGET eingetragen. Dies jedoch ohne die Endung ''.c''.

<pre class="code">
...
TARGET = superprog
...
</pre>

Besteht das Projekt wie im Beispiel aus mehr als einer Quellcodedatei, sind die weiteren c-Dateien (nicht die Header-Dateien, vgl. [[Include-Files (C)]]) durch Leerzeichen getrennt bei SRC einzutragen. Die bei TARGET definierte Datei ist schon in der SRC-Liste enthalten. Diesen Eintrag nicht löschen!

<pre class="code">
...
SRC = $(TARGET).c uart.c lcd.c 1wire.c
...
</pre>

Alternativ kann man die Liste der Quellcodedateien auch mit dem Operator += erweitern.

<pre class="code">
SRC = $(TARGET).c uart.c 1wire.c
# lcd-Code fuer Controller xyz123 (auskommentiert)
# SRC += lcd_xyz.c
# lcd-Code fuer "Standard-Controller" (genutzt)
SRC += lcd.c
</pre>

== Programmiergerät einstellen ==

Die Vorlagen sind auf die Programmiersoftware [[AVRDUDE]] angepasst, jedoch lässt sich auch andere Programmiersoftware einbinden, sofern diese über Kommandozeile gesteuert werden kann (z.B. stk500.exe, uisp, sp12).

<pre class="code">
...
# Einstellung fuer STK500 an com1 (auskommentiert)
# AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
# AVRDUDE_PORT = com1 # programmer connected to serial device

# Einstellung fuer STK200-Dongle an lpt1
AVRDUDE_PROGRAMMER = stk200
AVRDUDE_PORT = lpt1
...
</pre>

Sollen Flash(=.hex) und EEPROM(=.eep) zusammen auf den Controller programmiert werden, ist das Kommentarzeichen vor AVRDUDE_WRITE_EEPROM zu löschen.

<pre class="code">
...
#Auskommentiert: EERPOM-Inhalt wird nicht mitgeschrieben
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

#Nich-auskommentiert EERPOM-Inhalt wird mitgeschrieben
AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
...
</pre>

== Anwendung ==

Die Eingabe von ''make all'' im Arbeitsverzeichnis mit dem makefile und den Quellcodedateien erzeugt (unter anderem) die Dateien superprog.hex und superprog.eep. Abhängigkeiten zwischen den einzelnen c-Dateien werden dabei automatisch berücksichtigt. Die ''superprog.hex'' und ''superprog.eep'' werden mit ''make program'' zum Controller übertragen. Mit ''make clean'' werden alle temporären Dateien gelöscht (="aufgeräumt").

== Sonstige Einstellungen ==

=== Optimierungsgrad ===

Der gcc-Compiler kennt verschiedene Stufen der Optimierung. Nur zu Testzwecken sollte die Optimierung ganz deaktiviert werden (''OPT = 0''). Die weiteren möglichen Optionen weisen den Compiler an, möglichst kompakten oder möglichst schnellen Code zu erzeugen. In den weitaus meisten Fällen ist ''OPT = s'' die optimale (sic) Einstellung, damit wird kompakter und oft auch der "schnellste" Maschienencode erzeugt.

=== Debug-Format ===

Unterstützt werden die Formate stabs und dwarf-2. Das Format wir hinter ''DEBUG ='' eingestellt. Siehe dazu Abschnitt ''Eingabedateien zur Simulation''.

=== Assembler-Dateien ===

Die im Projekt genutzten Assembler-Dateien werden hinter ASRC durch Leerzeichen getrennt aufgelistet. Assembler-Dateien haben immer die Endung .S (grosses S). Ist zum Beispiel der Assembler-Quellcode eines Software-UARTs in einer Datei softuart.S enthalten lautet die Zeile: ''ASRC = softuart.S''

== Eingabedateien zur Simulation in AVR-Studio ==

Mit älteren AVR-Studio-Versionen kann man nur auf Grundlage sogenannter ''coff''-Dateien simulieren. Neuere Versionen von AVR-Studio (ab 4.10.356) unterstützen zudem das modernere aber noch experimentelle dwarf-2-Format, das ab WinAVR 20040722 (avr-gcc 3.4.1/Binutils inkl. Atmel add-ons) "direkt" vom Compiler erzeugt wird.

; Vorgehensweise bei extcoff:
* im Makefile bei DEBUG: <pre class="code">DEBUG=stabs</pre>
* ''make extcoff'' (evtl. vorher ''make clean'')
* die erzeugte ''cof''-Datei (im Beispiel oben ''superprog.cof'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

; Vorgehensweise bei dwarf-2:
* im Makefile bei DEBUG: <pre class="code">DEBUG=dwarf-2</pre>
* ''make all'' (evtl. vorher ''make clean'')
* die erzeugte ''elf''-Datei (im Beispiel oben ''superprog.elf'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

Beim Simulieren scheinen oft "Variablen zu fehlen". Ursache dafür ist, dass der Compiler die "Variablen" direkt Registern zuweist. Dies kann vermieden werden, indem die Optimierung abgeschaltet wird (im makefile). Man simuliert dann jedoch ein vom optimierten Code stark abweichendes Programm. Das Abschalten der Optimierung wird nicht empfohlen.

Statt des Software-Simulators kann das AVR-Studio auch genutzt werden, um mit dem ATMEL JTAGICE, ein Nachbau davon (BootICE, Evertool o.ä.) oder dem ATMEL JTAGICE MKII "im System" zu debuggen. Dazu sind keine speziellen Einstellungen im makefile erforderlich. Debugging bzw. "In-System-Emulation" mit dem JTAGICE und JTAGICE MKII sind in der AVR-Studio Online-Hilfe beschrieben.

= Definition einiger Datentypen =

Für die Programmierung von Mikrocontrollern ist es sinnvoll, dass wir uns
vorerst einige Datentypen definieren, welche den Zugriff auf die verschiedenen
Komponenten des Controllers vereinfachen oder wenigstens das Programm lesbarer
machen können.

<pre class="code">
typedef unsigned char BYTE;
typedef unsigned short WORD;
</pre>

== BYTE ==

Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 255.

== WORD ==

Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 65535.

== DWORD ==

Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

== QWORD ==

Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

Bei allen vorgenannten Datentypen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z.B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich daher, die im folgenden Abschnitt beschriebenen standardisierten Datentypen zu nutzen und damit "Missverständnissen" vorzubeugen, die z.B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

= Standardisierte Integer(Ganzzahl)-Typen =

Standardisierte Datentypen werden in der Header-Datei inttypes.h definiert.
Will man diese Typen benutzen, bindet man die "Definitionsdatei" wie folgt ein:

<pre class="code">
#include <inttypes.h>
</pre>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<pre class="code">
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
</pre>

Ein Vierfach-Wort (64Bit) entspricht beim AVR ''uint64_t'', ein Doppel-[[Word|Wort]] (32bit) entspricht ''uint32_t'', ein Wort (16bit) entspricht ''uint16_t'' und ein [[Byte]] (8bit) entspricht ''uint8_t''.
Die Typen ohne vorangestelltes ''u'' können auch vorzeichenbehaftete Zahlen speichern. ''int8_t'' geht also von -128 bis 127, ''uint8_t'' dagegen geht von 0 bis 255.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Integer Types

== '''Bitfelder''' ==

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bit breit ist. 
Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in einer einzelnen Bytevariable zusammen fassen und (fast) wie
8 einzelne Variablen ansprechen können. 
Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente
definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<pre class="code">
struct {
unsigned char bStatus_1:1; // 1 Bit für bStatus_1
unsigned char bStatus_2:1; // 1 Bit für bStatus_2
unsigned char bNochNBit:1; // Und hier noch mal ein Bit
unsigned char b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</pre>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<pre class="code">
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</pre>

(mt Empfehlung: Bitfelder sparen zwar Platz, verschlechtern aber unter
Umständen die Les- und Wartbarkeit des Codes. Anfängern wird geraten,
ein "ganzes" ein Byte (uint8_t) zu nutzen auch wenn nur ein Bitwert gespeichert
werden soll.)

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten
Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher
Dinge erledigt werden können, welche nicht zeitkritisch sind. 
Wenn ein Interrupt ausgelöst wird so wird automatisch die zugeordnete
Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Allgemeiner Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heisst, das Programm kann die
Inhalte der Register auslesen und beschreiben. 
Einige Register haben spezielle Funktionen, andere wiederum könne für
allgemeine Zwecke (Speichern von Datenwerten) verwendet werden.

Einzelne Register sind bei allen AVR's vorhanden, andere wiederum nur bei
bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff
auf den UART notwendig sind selbstverständlich nur bei denjenigen Modellen
vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden
AVR-Typen definiert. 

Wenn im Makefile der MCU-Typ definiert ist, wird vom System automatisch die
zum Typen passende Definitionsdatei genutzt, sobald man im Code die allgemeine
"io.h" Header-Datei einbinden.

<pre class="code">
#include <avr/io.h>
</pre>

Ist im Makefile der MCU Type z.B. mit dem Inhalt atmega8 definiert,
wird beim einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit
den Register-Definitionen für den ATmega8 eingelesen.



== I/O-Register ==

Die I/O-Register haben einen besonderen Stellenwert bei den AVR Controllern.
Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. 
Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir mal
die 8-Bit Register.


=== Lesen eines I/O-Registers ===



Zum Lesen kann man auf I/O Register einfach wie auf eine
Variable zugreifen. Die spezielle Funktion inp() ist nicht mehr
notwendig und veraltet.

Beispiel:

<pre class="code">
#include <avr/io.h>
uint8_t foo;
...
int main(void)
{
foo=PINB; /* kopiert den Status der Eingabepins an PortB in die Variable foo */
...
}
</pre>

==== Lesen eines Bits ====

Die AVR-Bibliothek stellt auch Funktionen zur Abfrage eines einzelnen Bits
eines Registers zur Verfügung:

;bit_is_set (<Register>,<Bitnummer>) : Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 4 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>) : Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen bit_is_clear bzw. bit_is_set sind nicht unbedingt erfoderlich, man kann auch "einfachen" C-Syntax verwenden. Der universell verwendbar ist. ''bit_is_set'' entspricht dabei z.B. (Variable & (1<<Bitnummer)). Das Ergebnis ist <>0 wenn das Bit gesetzt und 0 wenn nicht gesetzt ist.

* siehe auch [[Bitmanipulation]]

=== Schreiben eines I/O-Registers ===



Zum Schreiben kann man I/O Register einfach wie eine
Variable setzen. Die spezielle Funktion outp() ist nicht mehr
notwendig, veraltet und sollte nicht mehr genutzt werden.

Beispiel:

<pre class="code">
#include <avr/io.h>
...
int main(void)
{
DDRA=0xff; /* Setzt das Richtungsregister des Ports A auf 0xff (alle Pins als Ausgang) */
PORTA=0x03; /* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low" */
...
}
</pre>

==== Schreiben eines Bits ====



Einzelne Bits setzt man "Standard-C-Konform" mittels logischen (bit-) Operationen.

mit dem Ausduck |=(1<<Bitnummer) wird ein Bit gesetzt, mit dem Ausdruck
&=~(1<<Bitnummer) wird ein Bit geloescht. Die Funktionen sbi und cbi sind
dazu nicht notwendig, veraltet und sollten nicht mehr genutzt werden.

Beispiel:
<pre class="code">
...
#define MEINBIT 2
...
PORTA |= (1<<MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1<<MEINBIT); /* loescht Bit 2 an PortA */
</pre>

* siehe auch:
** [[Bitmanipulation]]
** [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

=== Warten auf einen bestimmten Zustand ===

Es gibt in der Bibliothek sogar Funktionen, die Warten, bis ein bestimmter
Zustand auf einem Bit erreicht ist. 
Es ist allerdings normalerweise eine eher unschöne Programmiertechnik.

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das
definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits
gesetzt ist wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT 2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1<<WARTEBIT)) ) ;
</pre>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das
definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits
gelöscht ist wird die Funktion sofort wieder verlassen. 
Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT 4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// ungleich 0 ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
</pre>

Universeller und auch auf andere Platformen besser übertragbar ist die Verwendung von C-Standardoperationen.

siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]



= Zugriff auf Ports =

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind
jedem Port 3 Register zugeordnet:

{| border="1"
|-
| '''DDRx'''
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (anhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
| '''PORTx'''
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Wird ein Port als Eingang geschaltet, so können mit diesem Register
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|-
| '''PINx'''
| Eingangadresse für Port'''x'''.

Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der Portspins. Bit gesetzt (1) wenn Pin "high/an", Bit gelöscht (0) wenn Portpin "low/aus".
|}

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.


Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Wollen wir also beispielsweise Pin 0 bis 4 von Port B als Ausgänge
definieren so schreiben wir folgende Zeile:


<pre class="code">
#include <avr/io.h>
...
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F

DDRB=0x1F; /* direkte Zuweisung - unuebersichtlich */
/* mehr Tipparbeit aber uebersichtlicher: */
DDRB=(1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3)|(1<<DDB4);
...
</pre>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet.

=== Ganze Ports ===

Um einen ganzen Port als Ausgang zu definieren, kann der folgende Befehl
verwendet werden:

<pre class="code">
DDRB=0xff;
</pre>

Im Beispiel wird der Port B als Ganzes als Ausgang geschaltet.

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen
bzw. auszugeben.

== Ausgänge ==

Wir wollen nun einen als Ausgang definierten Pin auf Logisch 1 setzen. Dazu schreiben wir den entsprechenden Wert in das Portregister des entsprechenden Ports.

Mit dem Befehl

<pre class="code">
PORTB=0x04; /* besser PORTB=(1<<DDB2) */
</pre>

wird also der Ausgang an Pin 2 gesetzt (Beachte, dass die Bits immer ''von 0 an''
gezählt werden, das niederwertigste Bit ist also Bit 0 und nicht etwa Bit 1).

Man beachte bitte, dass bei der Zuweisung mittels '''='''  immer alle Pins gleichzeitig angegeben werden. Man sollte also zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfliessen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an PortB auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<pre class="code">
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<DDB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<DDB2)
</pre>


Die Funktionen cbi und sbi sind dazu nicht notwendig, veraltet und sollten
nicht mehr genutzt werden.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wird den Pegel über entsprechende Hardware (z.B. Optokoppler, Spannunsteiler "Levelshifter") anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unserer Controllers eine logische 1 (Vcc) oder eine logische 0 (Masse) anliegt.

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.



Wobei es hier sehr wichtig ist, zur Abfrage der Eingänge nicht etwa das Portregister '''PORTx''' zu verwenden, sondern die Porteingangsadresse '''PINx'''. Dies ist
ein oft gemachter Fehler!

Wollen wir also die aktuellen Signalzustände von Port D abfragen und in einer
Variable namens bPortD abspeichern so schreiben wir dazu folgende Befehlszeile:

<pre class="code">
#include <avr/io.h>
...
bPortD = PIND;
...
</pre>


=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen (''Active Low'' und ''Active High''):

{| border="1"
|-
| '''Active Low'''
| '''Active High'''
|-
| [[Image:Active Low.gif]]
| [[Image:Active High.gif]]
|-
| Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet.

Damit bei offenem Schalter der Controller kein undefiniertes Signal
bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein
sogenannter Pull-Up Widerstand geschaltet. Dieser dient dazu, den Pegel
bei geöffnetem Schalter auf logisch 1 zu ziehen. 
Der Widerstandswert des Pull-Up Widerstands ist an sich nicht kritisch. Es
muss jedoch beachtet werden, dass über den Widerstand ein Strom in den
Eingang fliesst, also sollte er nicht zu klein gewählt werden um den
Controller nicht zu zerstören. Wird er allerdings zu hoch gewählt ist
die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10
Kiloohm eingebürgert.

Die AVR's haben sogar an den meisten Pins softwaremässig zuschaltbare
interne Pull-Up Widerstände, welche wir natürlich auch verwenden
können.
| Hier wird der Kontakt zwischen die Versorgungsspannung und Masse geschaltet.

Damit bei offener Schalterstellung kein undefiniertes Signal am Controller
ansteht, wird zwischen den Eingangspin und die Masse ein Pull-Down
Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter
Schalterstellung auf logisch 0 zu halten.
|}

==== Pull-Up Widerstände aktivieren ====

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden
über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang'''
geschaltet ist. 

Wird der Wert des entsprechenden Portpins auf 1 gesetzt so ist
der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up
Widerstand nicht aktiv. 
Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand
verwenden, aber nicht beide zusammen.



<pre class="code">
#include <avr/io.h>
...
DDRD=0x00; /* alle Pins von Port D als Eingang */
PORTD=0xff: /* interer Pull-Up an allen Port-Pins aktivieren */
...
</pre>

Im Beispiel wird der gesamte Port D als Eingang geschaltet und alle Pull-Up
Widerstände aktiviert.

===== Tastenentprellung =====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von
Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim
Schliessen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern
mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes. 
Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein
solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen
als mehrfache Impulse gezählt wird. 
Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen
werden.

ToDo Bsp Quellcode

== Analog ==

Leider können wir mit unseren Controllern keine analogen Werte direkt
ausgeben oder einlesen. Dazu müssen wir Umwege gehen, doch dies wird in einem späteren
Kapitel behandelt.

=== 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1) ===

Einige der Portregister in den AVR-Controllern sind 16 Bit breit, Man spricht
dann von einem '''Wort'''.


Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<pre class="code">
#include <avr/io.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8

= Der UART, Teil 1 =

Wir werden in zukünftigen Übungen in die Situation kommen, dass wir
Informationen vom Controller auswerten bzw. anzeigen müssen wobei es vielleicht
dann nicht mehr reicht, ein paar Leuchtdioden anzusteuern. 
Somit brauchen wir eine Verbindung vom AVR zu unserem PC, und dies am besten
über die serielle Schnittstelle.

== Allgemeines zum UART ==

Einige AVR-Controller haben einen vollduplexfähigen UART ('''U'''niversal
'''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut.
Dies ist eine wirklich feine Sache, haben wir doch damit schon das nötige
Werkzeug, um mit anderen Geräten, welche über eine serielle Schnittstelle
verfügen (insbesondere mit unserem PC), zu kommunizieren.

Übrigens: Vollduplex heisst nichts anderes, als dass der Baustein gleichzeitig
senden und empfangen kann.

Neuere AVRs (ATmega) verfügen über einen oder zwei U'''S'''ART(s), dieser unterschiedet sich vom UART häuptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

Der UART wird über vier separate Register angesprochen. USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurations/Datenregister. Das Datenblatt gibt darüber Auskunft. Die Folgende Tabelle gibt nur die Register für die (veralteten) UARTs wieder.

{| border="1"
|-
| '''UCR   '''
| '''U'''ART '''C'''ontrol '''R'''egister. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXCIE'''
| align="center" | '''TXCIE'''
| align="center" | '''UDRIE'''
| align="center" | '''RXEN'''
| align="center" | '''TXEN'''
| align="center" | '''CHR9'''
| align="center" | '''RXB8'''
| align="center" | '''TXB8'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''CHR9''' (9 Bit Characters)
:Wenn dieses Bit gesetzt ist, können 9 Bit lange Zeichen übertragen und empfangen werden. Das 9. Bit kann bei Bedarf als zusätzliches Stopbit oder als Paritätsbit verwendet werden. Man spricht dann von einem 11-Bit Zeichenrahmen:
:1 Startbit + 8 Datenbits + 1 Stopbit + 1 Paritätsbit = 11 Bits

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.

|-
| '''USR   '''
| '''U'''ART '''S'''tatus '''R'''egister. 
Hier teilt uns der UART mit, was er gerade so macht.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXC'''
| align="center" | '''TXC'''
| align="center" | '''UDRE'''
| align="center" | '''FE'''
| align="center" | '''OR'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt bevor ein weiteres Zeichen komplett empfangen wurde wird eine Überlauf-Fehlersituation eintreffen. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, wenn die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit wird vom AVR gesetzt, wenn ein Zeichen vom Sendedatenregister in das Send-Schieberegister übernommen wurde und der UART nun wieder bereit ist, ein neues Zeichen zum Senden aufzunehmen.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''OR''' ('''O'''ver'''R'''un) 
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne
kommunizieren möchten. Der Wert, der in dieses Register geschrieben
werden muss, errechnet sich nach folgender Formel:

<math>
\begin{matrix}
UBBR = \frac{Taktfrequenz}{Baudrate * 16} - 1
\end{matrix}
</math>

Es sind Baudraten bis zu 115200 Baud und höher möglich.
|}

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (LOW) und 5V (HIGH). Die
Schnittstellenspezifikation für RS232 definiert jedoch -3V ... -12V (LOW) und
+3 ... +12V (HIGH). Zudem muss der Signalaustausch zwischen AVR und
Partnergerät invertiert werden. Für die Anpassung der Pegel und das
Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste
davon ist wohl der MAX232. Allerdings kostet der auch wieder Geld und benötigt
zusätzlich immerhin 4 externe Elkos.

Die in den PC eingebauten Schnittstellen vertragen ohne Klagen auch den
TTL-Pegel vom AVR. Allerdings müssen wir immer noch die Signale invertieren. Im
einfachtesn Fall verwenden wir dazu jeweils einen einfachen NPN-Transistor und 2
Widerstände. Näheres dazu erfahrt ihr in den folgenden Übungen.

Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z.B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfielt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Senden mit dem UART ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. 
Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach
gewünschter Funktionsweise die
benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister. 
Da wir vorerst nur senden möchten und (noch) keine Interrupts auswerten wollen,
gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das
'''Transmitter Enable''' Bit setzen müssen:


<pre class="code">
UCR |= (1<<TXEN);
</pre>

Der Atmega16 hat mehrere Konfigurationsregister für USART und erfordert eine etwas andere Konfiguration

<pre class="code">
UCSRB |= (1<<TXEN); //UART TX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1
</pre>

Nun müssen wir noch die Baudrate festlegen. Gemäß unserer Formel brauchen
wir dazu die Taktfrequenz des angeschlossenen Oszillators bzw. Quarz in die
Formel einzufügen und das Resultat der Berechnung in das Baudratenregister des
UART einzuschreiben:

<pre class="code">
/* UART-Init beim AT90S2313 */
#define F_CPU 4000000; // Zum Beispiel 4Mhz-Quarz
#define UART_BAUD_RATE 9600 // Wir versuchen mal mit 9600 Baud
UBRR = F_CPU / (UART_BAUD_RATE * 16L) - 1;
</pre>

Wieder für den Mega16 mit einem 16bit-Register eine andere Programmierung

<pre class="code">
/* USART-Init beim ATmegaXX */
#define F_OSC 3686400 /* Oszillator-Frequenz in Hz */
#define UART_BAUD_RATE 9600
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)

UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

/* alternativ bei der avr-libc "direkt 16bit" : */
UBRR=UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);
</pre>

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben.

<pre class="code">
while (USR & (1<<UDRE)); /* warten bis Senden moeglich */
UDR = 'x'; // Schreibt das Zeichen x auf die Schnittstelle
</pre>

=== Schreiben einer Zeichenkette (String) ===

Es ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

Zu diesem Zweck können wir uns für's Erste eine einfache Funktion basteln:

<pre class="code">
void SendeString (char *szBuf)
{
while (*szBuf) {
loop_until_bit_is_set (USR, UDRE); /* warten bis Senden moeglich */
UDR=*szBuf;
szBuf++;
}
}
</pre>

Warteschleifen sind insofern etwas kritisch, da während des Sendens eines
Strings nicht mehr auf andere Ereignisse reagieren werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. emfangenen Zeichen/Bytes zwischengespeichert und mittels Interruptroutinen an den U(S)ART weitergebgen bzw. ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

* siehe auch: Weiterführende Informationen inkl. Beispielen für die Nutzung von stdio-Funktionen (prinf etc.) im [[AVR-Tutorial - UART]].
* [http://homepage.sunrise.ch/mysunrise/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc

= Analoge Ein- und Ausgabe =

Leider können wir mit unseren Controllern keine analogen Werte direkt
verarbeiten. Dazu bedarf es jeweils einer Umwandlung des analogen Signals in
einen digitalen Zahlenwert. Je nachdem, ob wir Daten einlesen oder ausgeben
wollen reden wir dabei von '''ADC''' oder '''DAC'''.

== ADC (Analog Digital Converter) ==

Der '''ADC''' wandelt analoge Signale in digitale Werte um, welche vom Controller
interpretiert werden können. Einige AVR-Typen haben bereits einen oder mehrere
solcher '''ADC''''s eingebaut, bei den kleineren AVR's müssen wir uns anders aus der
Affäre ziehen. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst
werden kann, wird durch die Auflösung des '''ADC''' in Anzahl Bits angegeben, man
hört bzw. liest jeweils von 8-Bit '''ADC''' oder 10-Bit ''' ADC''' oder noch höher. 
Ein '''ADC''' mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit
von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten
eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

<div align="center"><center>

{| border="1"
|-
| align="center" | '''Eingangsspannung am ADC'''
| align="center" | '''Entsprechender Messwert'''
|-
| align="center" | 0...<0.625V
| align="center" | 0
|-
| align="center" | 0.625...<1.25V
| align="center" | 1
|-
| align="center" | 1.25...<1.875V
| align="center" | 2
|-
| align="center" | 1.875...<2.5V
| align="center" | 3
|-
| align="center" | 2.5...<3.125V
| align="center" | 4
|-
| align="center" | 3.125...<3.75V
| align="center" | 5
|-
| align="center" | 3.75...<4.375V
| align="center" | 6
|-
| align="center" | 4.375...5V
| align="center" | 7
|}

</center>
</div>

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des '''
ADC''' ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Messen eines Widerstandes ===

Wir wollen hier einmal die wohl einfachste Methode zur Erfassung eines
analogen Wertes realisieren und zwar das Messen eines veränderlichen
Widerstandes wie z.B. eines Potentiometers.

Man stelle sich vor, wir schalten einen Kondensator in Reihe zu einem
Widerstand zwischen die Versorgungsspannung und Masse und dazwischen nehmen wir
das Signal ab und führen es auf einen der Pins an unserem Controller, genau so
wie es in folgender Grafik dargestellt ist.

[[Image:Poti.gif]]

Wenn wir nun den Pin des AVR als Ausgang schalten und auf
Logisch 1 (HIGH) legen, dann liegt an beiden Platten des Kondensators ''' Vcc''' an und
dieser wird entladen (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen). 
Nachdem nun der Kondensator genügend entladen ist schalten wir einfach den Pin
als Eingang wodurch dieser hochohmig wird. Der Kondensator lädt sich jetzt
über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und
derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti
unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), dann schaltet der
Eingang von HIGH auf LOW um. Wenn wir nun messen (zählen), wie lange es dauert,
bis der Kondensator so weit geladen ist, dann haben wir einen ungefähren Wert
der Potentiometerstellung. 
Der 220 Ohm Widerstand dient dem Schutz des Controllers. Wenn nämlich sonst die
Potentiometerstellung auf Maximum steht (0 Ohm), dann würde in den Eingang des
Controllers ein viel zu hoher Strom fliessen und der AVR würde in Rauch
aufgehen.

Dies ist meines Wissens die einzige Schaltung zur Erfassung von
Analogwerten, welche mit nur einem einzigen Pin auskommt. 
Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine
Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B:
0...100 % oder so) umzurechnen.

Wer Lust hat, sich selber mal an ein solches Programm
heranzuwagen, der sollte das jetzt tun. Für diejenigen, die es gern schnell
mögen, hier das Beispielprogramm, welches den UART-Printf aus den
vorangegangenen Kapiteln benötigt, inkl. Makefile:

{| border="0"
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Poti.c Poti.c ]
| Hauptprogramm.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.c Pot.c]
| Separate Routine zur Ermittlung des Messwertes.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.h Pot.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c UartPrintF.c]
| Für die Debugausgabe auf den UART.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h UartPrintF.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile Makefile]
| Makefile.
|}

Nachdem das Programm auf den AVR geladen wurde, muss dieser
kalibriert werden. Dazu wird der Kalibrierungsschalter geschlossen und das Poti
einige Male zwischen minimaler und maximaler Stellung hin und her gedreht. Dabei
werden die jeweiligen Maximalwerte bestimmt. Wenn der Kalibrierschalter wieder
geöffnet wird werden die Kalibrierungsdaten in's EEPROM des AVR geschrieben,
damit die Prozedur nicht nach jedem Reset wiederholt werden muss.

Auf Pin 4 habe ich noch ein Triggersignal gelegt, welches auf
HIGH geht wenn die Messung beginnt und auf LOW, wenn der Messvorgang beendet
wird. Mit Hilfe dieses Signals kann der Vorgang wunderschön auf einem
Oszillographen dargestellt werden.

=== ADC über Komparator ===

Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

[[Image:ADC ueber Komparator.gif]]

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert. 
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

=== Der ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem '''ADC-Wandler''' zurückgreifen. Wir wollen hier einmal den AT90S8535 besprechen, welcher über 8 ADC-Kanäle verfügt. (TODO: nur ein Wandler, Mulitiplexbetrieb, nur eine Pin zur gleichen Zeit)

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung.

Verfügt der AVR über eine interne Referenzspannung (Datenblatt typisch 2,56 oder 1,1V je nach AVR), bleibt der ''Anschluss AREF'' unbeschaltet und man stellt die ADC-Register so ein, dass die interne Referenzspannung als "AREF" genutzt wird. Ansonsten ist eine externe Referenzspannung von maximal '''Vcc''' an den Abschluss '''AREF''' anzulegen. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden.

==== Einfache Wandlung (Single Conversion) ====

In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestossen für jeweils eine Messung.

==== Frei laufend (Free Running) ====

In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register, welche hier aufgelistet werden.

{| border="1"
|-
| '''ADCSR   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ADEN'''
| align="center" | '''ADSC'''
| align="center" | '''ADFR'''
| align="center" | '''ADIF'''
| align="center" | '''ADIE'''
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt, ist können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''Fr'''ee Running Select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Eine logische 1 aktiviert den frei laufenden Modus. Der ''' ADC''' misst nun ständig den ausgewählten Kanal und schreibt den gemessenen Wert in das '''ADC Data Register'''.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, wenn eine Umwandlung erfolgt und das '''ADC Data Register''' aktualisiert ist.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird (So steht es in der AVR-Dokumentation).

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200kHz}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50kHz}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.
<dl><dd>
{| style="" border="1"
|-
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
| align="center" | '''Teilungsfaktor'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 2
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 2
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 4
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 8
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 16
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 32
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 64
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 128
|}
</dd></dl>
|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<pre class="code">
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
C-Operatorprioritaet sichergestellt)
</pre>

oder

<pre class="code">
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</pre>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''MUX2'''
| align="center" | '''MUX1'''
| align="center" | '''MUX0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''MUX2...MUX0'''
:Mit diesem 3 Bits wird der zu messende Kanal bestimmt. Es wird einfach die entsprechende Pinnummer des Ports eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Meine Empfehlung ist deswegen klar diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Aktivieren des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register
setzen. Im gleichen Schritt legen wir auch gleich die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls mit Spannungsteiler konditionieren. Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1024 für V_ref-Volt.

<pre class="code">

#define CHANNELOFFSET 4

uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result;

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler setzen auf 8 (1)
ADCSRA |= (1<<ADEN); // ADC aktivieren (1)

ADMUX = CHANNELOFFSET+channel; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)

result = 0;

/* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
for(i=0;i<4;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)
result += ADC; // Wandlungsergebnisse aufaddieren
}

ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)

result >>= 2; // Summe durch vier teilen = arithm. Mittelwert

return result;
}
</pre>

Im Beispiel wird bei jedem Aufruf der ADC aktiviert und nach der Wandlung wieder abgeschaltet, das spart Strom. Will man dies nicht, verschiebt man die mit (1) gekenntzeichneten Zeilen in eine Funktion adc_init() o.ä. und löscht die mit (2) markierten Zeilen.



== DAC (Digital Analog Converter) ==

Mit Hilfe eines ''' DAC''' können wir nun auch Analogsignale ausgeben. Es gibt hier
mehrere Verfahren. Wenn wir beim ''' ADC''' die Möglichkeit haben, mit externen
Komponenten zu operieren, müssen wir bei der '''DAC'''-Wandlung mit dem auskommen, was
der Controller selber zu bieten hat.

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie ''' PWM''' eigentlich funktioniert.

Wie wir alle wissen ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber
wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. 
Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen
HIGH und LOW umschalten? 
Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen geometrischen Mittelwert, der je nach Pulsbreite
kleiner oder grösser ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein
RC-Glied filtern dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVR's können wir direkt '''PWM'''-Signale erzeugen. Dazu
dient der 16-Bit Zähler, welcher im sogenannten '''PWM'''-Modus betrieben werden
kann.

Hinweis:
:In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist allerdings bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt.

Um den '''PWM'''-Modus zu aktivieren müssen im Timer/Counter1 Control
Register A '''TCCR1A''' die Pulsweiten-Modulatorbits '''PWM10''' bzw. '''PWM11''' entsprechend
nachfolgender Tabelle gesetzt werden:

{| border="1"
|-
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| PWM-Modus des Timers ist nicht aktiv.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM.
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben. Die
Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| border="1"
|-
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden heisst dann:

<pre class="code">
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</pre>

Damit der Timer/Counter überhaupt läuft müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorzähler) einstellen, und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| border="1"
|-
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<pre class="code">
TCCR1B = (1<<CS12) | (1<<CS10);
</pre>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<pre class="code">
OCR1A = xxx;
</pre>

Die folgende Grafik soll den Zusammenhang zwischen dem
Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren.

= Die Timer/Counter des AVR =

Die heutigen Mikrocontroller und insbesondere die RISC-AVR's sind für viele
Steuerungsaufgaben natürlich viel zu schnell. Wenn wir beispielsweise eine LED
oder Lampe blinken lassen wollen, können wir selbstverständlich nicht die
CPU-Frequenz verwenden da ja dann nichts mehr vom Blinken zu bemerken wäre.

Wir brauchen also eine Möglichkeit, die Taktfrequenz auf vernünftige Werte
herunter zu brechen. Selbstverständlich sollte die resultierende Frequenz dann
auch noch einigermassen genau und stabil sein.

Hier kommen die im AVR vorhandenen Timer/Counter zum Einsatz.

Ein anderes Anwendungsgebiet ist die Zählung von Signalen, welche über
einen I/O-Pin zugeführt werden können.

Die folgenden Ausführungen beziehen sich auch den AT90S2313. Für andere
Modelltypen müsst ihr euch die allenfalls notwendigen Anpassungen aus den
Datenblättern der entsprechenden Controller herauslesen.

Wir unterscheiden grundsätzlich zwischen 8-Bit Timern, welche eine
Auflösung von 256 aufweisen und 16-Bit Timern mit (logischerweise) einer
Auflösung von 65536.

Als Eingangstakt für die Timer/Counter kann entweder die CPU-Taktfrequenz,
der Vorteiler-Ausgang oder ein an einen I/O-Pin angelegtes Signal verwendet
werden. Wenn ein externes Signal verwendet wird, so darf dessen Frequenz nicht
höher sein als die Hälfte des CPU-Taktes.

=== Der Vorzähler (Prescaler) ===

Beide Timer/Counter werden im Timerbetrieb über den gleichen Vorzähler
versorgt.

Der Vorzähler dient dazu, den CPU-Takt vorerst mal runter zu brechen auf eine
wählbare Teilung. Die so geteilte Frequenz wird den Eingängen der Timer
zugeführt.

Wenn wir mit einer einem CPU-Takt von 4 MHz arbeiten und den Vorteiler auf 1024
einstellen wird also der Timer mit einer Frequenz von 4 MHz / 1024, also mit ca.
4 kHz versorgt. Wenn also der Timer läuft, so wird das Daten- bzw.
Zählregister mit dieser Frequenz inkrementiert.

== 8-Bit Timer/Counter ==

Alle AVR-Modelle weisen mindestens einen, teilweise sogar zwei, 8-Bit Timer
auf.

Der 8-Bit Timer wird über folgende Register angesprochen:

{| border="1"
|-
| '''TCCR0'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
Timer '''0'''

In diesem Register stellen wir ein, wie wir den Timer/Counter verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CS02'''
| align="center" | '''CS01'''
| align="center" | '''CS00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''CS02, CS01, CS00''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS02
| align="center" | CS01
| align="center" | CS00
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin '''TO''', fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin '''TO''', steigende Flanke
|}
</dd>
</dl>
:Wenn als Quelle der externe Pin '''TO''' verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin '''TO''' als Ausgang geschaltet ist.

|-
| '''TCNT0'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer '''0''' 
Dieses ist als 8-Bit Aufwärtszähler mit Schreib- und Lesezugriff
realisiert. Wenn der Zähler den Wert 255 erreicht hat beginnt er beim
nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}
|}

Um nun also den Timer0 in Betrieb zu setzen und ihn mit einer Frequenz von 1/1024-tel des CPU-Taktes zählen zu lassen, schreiben wir die folgende Befehlszeile:

<pre class="code">
TCCR0 = (1<<CS00)|(1<<CS02);
</pre>

Der Zähler zählt nun aufwärts bis 255, um dann wieder bei 0 zu beginnen. Der aktuelle Zählerstand steht in TCNT0. Bei jedem Überlauf von 255 auf 0 wird das Timer Overflow Flag '''TOV0''' im Timer Interrupt Flag '''TIFR'''-Register gesetzt und, falls so konfiguriert, ein entsprechender Timer-Overflow-Interrupt ausgelöst.

== 16-Bit Timer/Counter ==

Viele AVR-Modelle besitzen ausser den 8-Bit Timers auch einen oder sogar zwei
(einige ATmega-Modelle) 16-Bit Timer.

Die 16-Bit Timer/Counter sind wesentlich komplexer aufgebaut als die 8-Bit
Timer/Counter, bieten dafür aber auch viel mehr Möglichkeiten, als da sind:

* Die [[PWM]]-Betriebsart Erzeugung eines pulsweitenmodulierten Ausgangssignals.
* Vergleichswert-Überprüfung mit Erzeugung eines Ausgangssignals (Output Compare Match).
* Einfangen eines Eingangssignals mit Speicherung des aktuellen Zählerwertes (Input Capturing), mit zuschaltbarer Rauschunterdrückung (Noise Filtering).

Folgende Register sind dem Timer/Counter 1 zugeordnet:

{| border="1"
|-
| '''TCCR1A'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''A''' Timer '''1''' 
In diesem und dem folgenden Register stellen wir ein, wie wir den Timer/Counter verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''COM1A1''', '''COM1A0''' ('''Co'''mpare '''M'''atch Control Bits)
:Diese 2 Bits bestimmen die Aktion, welche am Output-Pin '''OC1''' ausgeführt werden soll, wenn der Wert des Datenregisters des Timer/Counter 1 den Wert des Vergleichsregisters erreicht, also ein so genannter Compare Match auftritt.
:Der Pin '''OC1''' ('''PB3''' beim 2313) muss mit dem Datenrichtungsregister als Ausgang konfiguriert werden.

<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Das Signal am Pin '''OC1''' wird invertiert (Toggle).
|-
| align="center" | 1
| align="center" | 0
| Der Output Pin '''OC1''' wird auf 0 gesetzt.
|-
| align="center" | 1
| align="center" | 1
| Der Output Pin '''OC1''' wird auf 1 gesetzt.
|}
</dd></dl>
:In der PWM-Betriebsart haben diese Bits eine andere Funktion.
<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 1
| align="center" | 0
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 0 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 1 gesetzt.

Man nennt dies ''nicht invertierende PWM''.
|-
| align="center" | 1
| align="center" | 1
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 1 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 0 gesetzt.

Man nennt dies ''invertierende PWM''.
|}
</dd></dl>

'''PWM11''', '''PWM10''' ('''PWM''' Mode Select Bits)
:Mit diesen 2 Bits wird die PWM-Betriebsart des Timer/Counter 1 gesteuert.
<dl><dd>
{| border="1"
|-
| align="center" | PWM11
| align="center" | PWM10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Die PWM-Betriebsart ist nicht aktiviert. Timer/Counter 1 arbeitet als normaler Timer bzw. Zähler.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM Betriebsart aktivieren.
|}
</dd></dl>
|-
| '''TCCR1B'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''B''' Timer '''1'''

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ICNC1'''
| align="center" | '''ICES1'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CTC1'''
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''ICNC1''' ('''I'''nput '''C'''apture '''N'''oise '''C'''anceler (4 CKs) Timer/Counter 1
:oder auf Deutsch Rauschunterdrückung des Eingangssignals.
:Wenn dieses Bit gesetzt ist und mit dem Input Capture Signal gearbeitet wird so werden nach der Triggerung des Signals mit der entsprechenden Flanke (steigend oder fallend) am Input Capture Pin '''ICP''' jeweils 4 Messungen mit der CPU-Frequenz des Eingangssignals abgefragt. Nur dann, wenn alle 4 Messungen den gleichen Zustand aufweisen gilt das Signal als erkannt.

'''ICES1''' ('''I'''nput '''C'''apture '''E'''dge '''S'''elect Timer/Counter '''1''')
:Mit diesem Bit wird bestimmt, ob die steigende ('''ICES1'''=1) oder fallende ('''ICES1'''=0) Flanke zur Auswertung des Input Capture Signals an Pin '''ICP''' heran gezogen wird.

'''CTC1''' ('''C'''lear '''T'''imer/'''C'''ounter on Compare Match Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, so wird nach einer Übereinstimmung des Datenregisters '''TCNT1H'''/'''TCNT1L''' mit dem Vergleichswert in '''OCR1H'''/'''OCR1L''' das Datenregister '''TCNT1H'''/'''TCNT1L''' auf 0 gesetzt.
:Da die Übereinstimmung im Takt nach dem Vergleich behandelt wird, ergibt sich je nach eingestelltem Vorzähler ein etwas anderes Zählverhalten:
:Wenn der Vorteiler auf 1 gestellt ist und C der jeweilige Zählerwert ist, dann nimmt das Datenregister, im CPU-Takt betrachtet, folgende Werte an:
:... | C-2 | C-1 | C | 0 | 1 |...
:Wenn der Vorteiler z.B. auf 8 eingestellt ist, dann nimmt das Datenregister folgende Werte an:
:... | C-2, C-2, C-2, C-2, C-2, C-2, C-2, C-2 | C-1, C-1, C-1, C-1, C-1, C-1, C-1, C-1 | C, 0, 0, 0, 0, 0, 0, 0 |...
:In der PWM-Betriebsart hat dieses Bit keine Funktion.

'''CS12''', '''CS11''', '''CS10''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS12
| align="center" | CS11
| align="center" | CS10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin TO, fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin T0, steigende Flanke
|}
</dd></dl>
:Wenn als Quelle der externe Pin T0 verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin T0 als Ausgang geschaltet ist.
|-
| '''TCNT1H''' '''TCNT1L'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer/Counter '''1'''
Dieses ist als 16-Bit Aufwärtszähler mit Schreib- und Lesezugriff realisiert. Wenn der Zähler den Wert 65535 erreicht hat, beginnt er beim nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''TCNT1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''TCNT1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

In der PWM-Betriebsart wird das Register als Auf/Ab-Zähler verwendet, d.h. der Wert steigt zuerst von 0 bis er den Überlauf von 65535 auf 0 erreicht hat. Dann zählt das Register rückwärts wiederum bis 0.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.

Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''OCR1H''' '''OCR1L'''
| Timer/Counter '''O'''utput '''C'''ompare '''R'''egister Timer/Counter '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''OCR1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''OCR1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Der Wert im Output Compare Register wird ständig mit dem aktuellen Wert im Datenregister TCNT1H/TCNT1L verglichen. Stimmen die beiden Werte überein, so wird ein sogenannter Output Compare Match ausgelöst. Die entsprechenden Aktionen werden über die Timer/Counter 1 Control und Status Register eingestellt.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''ICR1H''' '''ICR1L'''
| Timer/Counter '''I'''nput '''C'''apture '''R'''egister Timer/Counter '''1''' 
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''ICR1''''''H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''ICR1''''''L'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Das Input Capture Register ist ein 16-Bit Register mit Lesezugriff. Es kann nicht beschrieben werden.

Wenn am Input Capture Pin '''ICP''' die gemäß Einstellungen im '''TCCR1B''' definierte Flanke erkannt wird, so wird der aktuelle Inhalt des Datenregisters '''TCNT1H'''/'''TCNT1L''' sofort in dieses Register kopiert und das Input Capture Flag '''ICF1''' im Timer Interrupt Flag Register '''TIFR''' gesetzt.

Wie bereits oben erwähnt, müssen vor dem Zugriff auf dieses Register alle Interrupts gesperrt werden. Zudem müssen Low- und Highbyte des Registers in der richtigen Reihenfolge bearbeitet werden:

{| border="0"
|-
| Lesen:
| '''ICR1L''' -> '''ICR1H'''
|-
| Schreiben:
| '''ICR1H''' -> '''ICR1L'''
|}
|}

=== Die PWM-Betriebsart ===

Wenn der Timer/Counter 1 in der PWM-Betriebsart betrieben wird, so bilden das Datenregister '''TCNT1H'''/'''TCNT1L''' und das Vergleichsregister '''OCR1H'''/'''OCR1L''' einen 8-, 9- oder 10-Bit, frei laufenden PWM-Modulator, welcher als PWM-Signal am '''OC1'''-Pin ('''PB3''' beim 2313) abgegriffen werden kann. Das Datenregister '''TCNT1H'''/'''TCNT1L''' wird dabei als Auf-/Ab-Zähler betrieben, welcher von 0 an aufwärts zählt bis zur Obergrenze und danach wieder zurück auf 0.
Die Obergrenze ergibt sich daraus, ob 8-, 9- oder 10-Bit PWM verwendet wird, und zwar gemäss folgender Tabelle:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Wenn nun der Zählerwert im Datenregister den in '''OCR1H'''/'''OCR1L''' gespeicherten Wert erreicht, wird der Ausgabepin '''OC1''' gesetzt bzw. gelöscht, je nach Einstellung von '''COM1A1''' und '''COM1A0''' im '''TCCR1A'''-Register.

Ich habe versucht, die entsprechenden Signale in der folgenden Grafik zusammenzufassen

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

=== Vergleichswert-Überprüfung ===

Hier wird in ein spezielles Vergleichswertregister ('''OCR1H'''/'''OCR1L''') ein Wert eingeschrieben, welcher ständig mit dem aktuellen Zählerwert verglichen wird.
Erreicht der Zähler den in diesem Register eingetragenen Wert, so kann ein Signal (0 oder 1) am Pin '''OC1''' erzeugt und/oder ein Interrupt ausgelöst werden.

=== Einfangen eines Eingangssignals (Input Capturing) ===

Bei dieser Betriebsart wird an den Input Capturing Pin (ICP) des Controllers eine Signalquelle angeschlossen.
Nun kann je nach Konfiguration entweder ein Signalwechsel von 0 nach 1 (steigende Flanke) oder von 1 nach 0 (fallende Flanke) erkannt werden und der zu diesem Zeitpunkt aktuelle Zählerstand in ein spezielles Register abgelegt werden. Gleichzeitig kann auch ein entsprechender Interrupt ausgelöst werden.
Wenn die Signalquelle ein starkes Rauschen beinhaltet, kann die Rauschunterdrückung eingeschaltet werden. Dann wird beim Erkennen der konfigurierten Flanke über 4 Taktzyklen das Signal überwacht und nur dann, wenn alle 4 Messungen gleich sind, wird die entsprechende Aktion ausgelöst.

== Gemeinsame Register ==

Verschiedene Register beinhalten Zustände und Einstellungen, welche sowohl
für den 8-Bit, als auch für den 16-Bit Timer/Counter in ein und demselben
Register zu finden sind.

{| border="1"
|-
| '''TIMSK'''
| '''T'''imer/Counter '''I'''nterrupt '''M'''a'''sk'''
Register

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOIE1'''
| align="center" | '''OCIE1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''TICIE'''
| align="center" | '''-'''
| align="center" | '''TOIE0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOIE1''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 1 ein Timer Overflow 1 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''OCIE1A''' ('''O'''utput '''C'''ompare Match '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Beim Timer/Counter 1 kann zusätzlich zum Überlauf ein Vergleichswert definiert werden.

:Wenn dieses Bit gesetzt ist, wird beim Erreichen des Vergleichswertes ein Compare Match Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TICIE''' ('''T'''imer/Counter '''I'''nput '''C'''apture '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein Capture Event Interrupt ausgelöst, wenn ein entsprechendes Signalereignis am Pin PD6(ICP) auftritt. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein, wenn auch ein entsprechender Interrupt ausgelöst werden soll.

'''TOIE0''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''0''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 0 ein Timer Overflow 0 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

|-
| '''TIFR'''
| '''T'''imer/Counter '''I'''nterrupt '''F'''lag '''R'''egister

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOV1'''
| align="center" | '''OCF1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''ICF1'''
| align="center" | '''-'''
| align="center" | '''TOV0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOV1''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''1''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 1 ein Überlauf des Datenregisters stattfindet.

:In der PWM-Betriebsart wird das Bit gesetzt, wenn die Zählrichtung von auf- zu abwärts und umgekehrt geändert wird (Zählerwert = 0).

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''OCF1A''' ('''O'''utput '''C'''ompare '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn der aktuelle Wert des Datenregisters von Timer/Counter 1 mit demjenigen im Vergleichsregister '''OCR1''' übereinstimmt.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''ICF1''' ('''I'''nput '''C'''apture '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn ein Capture-Ereignis aufgetreten ist, welches anzeigt, dass der Wert des Datenregisters des Timer/Counter 1 in das Input Capture Register ICR1 übertragen wurde.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''TOV0''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''0''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 0 ein Überlauf des Datenregisters stattfindet.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.
|}

 

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sog. ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comperators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrups den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

* '''set_sleep_mode(uint8_t mode)'''
:Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z.B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
* '''sleep_mode()'''
:Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus.

<pre class="code">
#include <avr/io.h>
#include <avr/sleep.h>
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach auftreten eines entsprechenden "Aufwach-Interrupts" verarbeitet
...
</pre>

Vorsicht: Nicht alle AVR-Controller (v.a. nicht die "Brandneuen") werden von den avr-libc sleep-Funktionen richtig angesteuert. Bei nicht-untersützten Typen erreicht man die gewollte Funktionalität durch direkte "Bitmanipulation" der ensprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler:

<pre class="code">
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep");
...
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes

= Der Watchdog =

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der Watchdog.

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln. 
Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

Betrachten wir doch einmal folgende Codesequenz:

<pre class="code">
uint8_t x;

x = 10;

while (x >= 0) {
// tu was 
x--;
}
</pre>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm würde sich also hier aufhängen und auf ewig in der Schleife drehen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde beginnt der Counter von 0 an hochzuzählen. Wenn nun die je nach Vorteiler eingestellte Anzahl
Zyklen erreicht wurde löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern müssen wir den Watchdog regelmässig wieder neu starten bzw. Rücksetzen (Watchdog Reset). Dies sollte innerehalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern muss ein spezielles Prozedere verwendet werden um den WD auszuschalten und zwar müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden. Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| border="1"
|-
| '''WDTCR'''
| '''W'''atchog '''T'''imer  '''C'''ontrol '''R'''egister 
In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''WDTOE'''
| align="center" | '''WDE'''
| align="center" | '''WDP2'''
| align="center" | '''WDP1'''
| align="center" | '''WDP0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''WDTOE'''
| '''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable 
Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
Wenn das Bit einmal gesetzt ist wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.
|-
| '''WDE'''
| '''W'''atch'''d'''og '''E'''nable 
Wenn dieses Bit gesetzt wird so wird der Watchdog aktiviert.
Das Bit kann nur gelöscht werden solange das Bit '''WDTOE''' auf 1 steht.
|-
| '''WDP2''' '''WDP1''' '''WDP0'''
| '''W'''atch'''d'''og Timer '''P'''rescaler Bits 
Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:

{| border="1"
|-
| align="center" | WDP2
| align="center" | WDP1
| align="center" | WDP0
| align="center" | Anzahl Zyklen
| align="center" | Typ. Timeoutzeit bei Vcc = 3V
| align="center" | Typ. Timeoutzeit bei Vcc = 5V
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 16K
| align="center" | 47ms
| align="center" | 15ms
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 32K
| align="center" | 94ms
| align="center" | 30ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 64K
| align="center" | 0.19s
| align="center" | 60ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 128K
| align="center" | 0.38s
| align="center" | 0.12s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 256K
| align="center" | 0.75s
| align="center" | 0.24s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 512K
| align="center" | 1.5s
| align="center" | 0.49s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 1024K
| align="center" | 3s
| align="center" | 0.97s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 2048K
| align="center" | 6s
| align="center" | 1.9s
|}
|}
|}

Um den Watchdog mit dem AVR-GCC Compiler zu verwenden muss die Headerdatei wdt.h in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

{| border=1
| wdt_enable(uint8_t timeout)
|Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert (z.B. WDTO_30MS).
|-
| wdt_disable()
| Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
|-
| wdt_reset()
| Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.
|}

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Ein paar grundsätzliche Gedanken ==

Ob nun so ein Watchdog überhaupt verwendet werden soll ist wohl eher eine
philosophische Frage und hängt vom Geschmack jedes einzelnen Entwicklers ab.

Ich persönlich habe es lieber, wenn ich auch merke, dass in meine Programm
etwas noch nicht in Ordnung ist, als dass mir ein Watchdog einfach die CPU immer
wieder zurücksetzt, denn immerhin kann es so passieren, dass ein Programm über
Jahre hinweg so einigermassen läuft, obwohl noch ein voll krasser Bock drin
liegt.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Watchdog timer handling

= Programmieren mit Interrupts =

Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

[[Image:Interrupt Programme.gif]]

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

== Anforderungen an die Interrupt-Routine ==

Um unliebsamen Überraschungen vorzubeugen sollten einige Grundregeln bei
der Gestaltung der Interruptroutinen beachtet werden.

* Die Interruptroutine soll möglichst kurz und schnell abarbeitbar sein, daraus folgt:
* Keine unfangreichen Berechnungen innerhalb der Interruptroutine.
* Keine endlos langen Programmschleifen.
* Obschon es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen rate ich dringend von solchen Spielen ab.

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf dem AVR auslösen, wobei
die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

== Register ==

Der AT90S2313 verfügt über 2 Register welche mit den
Interrupts zusammen hängen.

{| border="1"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INT1'''
| align="center" | '''INT0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''INT1'''
| External '''Int'''errupt Request '''1''' Enable
Wenn dieses Bit gesetzt ist wird ein Interrupt ausgelöst wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.
|-
| '''INT0'''
| External '''Int'''errupt Request '''0''' Enable
Wenn dieses Bit gesetzt ist wird ein Interrupt ausgelöst wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.
|}
|}

{| border="1"
|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INTF1'''
| align="center" | '''INTF0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''INTF1'''
| External '''Int'''errupt Flag '''1'''
Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist wird die
Interruptroutine angesprungen.
Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist.
Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''INTF0'''
| External '''Int'''errupt Flag '''0''' 
Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist wird die
Interruptroutine angesprungen.
Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist.
Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|}
|}

{| border="1"
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister. 
Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''SE'''
| align="center" | '''SM'''
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''SE'''
| '''S'''leep '''E'''nable
Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl
in den Schlafzustand versetzen zu können.
Um den Schlafmodus nicht irrtümlich einzuschalten wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.
|-
| '''SM'''
| '''S'''leep '''M'''ode
Dieses Bit bestimmt der Schlafmodus.
Ist das Bit gelöscht so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")
|-
| '''ISC11''' '''ISC10'''
| '''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits
Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.

{| border="1"
|-
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt. 
In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}
|-
| '''ISC01''' '''ISC00'''
| '''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits
Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

{| border="1"
|-
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.
In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}
|}
|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft wird automatisch das '''Global
Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle
weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem
Zeitpunkt bereits wieder das GIE-bit zu setzen rate ich dringend davon ab. Dieses
wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn
in der Zwischenzeit weitere Interrupts eintreffen werden die zugehörigen
Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden
Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt
ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle
anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe,
weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.

=== Das Status-Register ===

Es gilt auch zu beachten, dass das Status-Register während der Abarbeitung
einer Interruptroutine nicht automatisch gesichert wird. Falls notwendig muss dies vom
Programmierer selber vorgesehen werden.

== Interrupts mit dem AVR GCC Compiler (WinAVR) ==

Selbstverständlich können alle Interruptspezifischen Registerzugriffe wie gewohnt über I/O-Adressierung vorgenommen werden. Etwas einfacher geht es jedoch, wenn wir die vom Compiler zur Verfügung gestellten Mittel einsetzen.

Damit diese Mittel zur Verfügung stehen müssen wir die Includedatei interrupt.h und evtl. signal.h einbinden mittels:

<pre class="code">
// fuer sei(), cli() und INTERRUPT():
#include <avr/interrupt.h>

// fuer SIGNAL() auch:
#include <avr/signal.h>
</pre>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird
nichts anderes gemacht als das '''Global Interrupt Enable''' Bit im Status
Register gesetzt.

<pre class="code">
sei();
</pre>

Das Makro '''cli()''' schaltet die Interrupts aus oder anders
gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird
gelöscht.
<pre class="code">
cli();
</pre>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf.
Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen.
Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren
und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen
Zustands die Interrups aktivieren, was zu unerwünschten Seiteneffekten führen kann.
Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern */

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD); // 2 mal in Folge , vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
...

}
</pre>



Nachdem nun die Interrupts aktiviert sind braucht es selbstverständlich noch den auszuführenden Code, der ablaufen soll wenn ein Interrupt eintrifft. Dazu gibt es zwei Definitionen: '''SIGNAL''' und '''INTERRUPT''', welche allerdings AVR-GCC spezifisch sind und bei anderen Compilern womöglich anders heissen können.

=== SIGNAL ===

<pre class="code">
#include <avr/signal.h>
...
SIGNAL (siglabel)
{
/* Interrupt Code */
}
</pre>

Mit ''SIGNAL'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektoren angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Vor Nutzung von SIGNAL muss die Header-Datei signal.h eingebunden werden. Mögliche Funktionsrümpfe für solche Interruptfunktionen sind zum Beispiel:

<pre class="code">
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

SIGNAL (SIG_OVERFLOW1)
{
/* Interrupt Code */
}

SIGNAL (SIG_UART_RECV)
{
/* Interrupt Code */
}

// und so weiter und so fort...
</pre>

Während der Ausführung des Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== INTERRUPT ===

<pre class="code">
#include <avr/interrupt.h>
...
INTERRUPT (signame)
{
/* Interrupt Code */
}
</pre>

Mit INTERRUPT wird genau gleich gearbeitet wie mit SIGNAL. Der Unterschied ist derjenige, dass bei INTERRUPT beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit automatisch wieder gesetzt und somit weitere Interrupts zugelassen werden. Dies kann zu nicht unerheblichen Problemen von im einfachsten Fall einem Stack overflow bis zu sonstigen unerwarteten Effekten führen und sollte wirklich '''nur dann''' angewendet werden, wenn man sich absolut sicher ist, das Ganze auch im Griff zu haben. Vor Nutzung von INTERRUPT muss die Header-Datei interrupt.h eingebunden werden.

Interruptroutinen (ISRs) sollten möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern den Zustand aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

siehe auch: Hinweise in [[AVR-GCC]]

== Datenaustausch mit Interrupt-Routinen ==

Variablen auf die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen wird und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte die Code-Optimierung "greifen" und der Wert der Variablen nur in Prozessorregistern zwischenspeichert werden, die "nichts von der Änderung woanders mitbekommen".

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z.B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt z.B. alle 10ms
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
// hier wird gKeyCounter veraendert, die uebrigen
// Programmteile muessen diese Aenderung "sehen"
// (volatile -> aktuellen Wert immer in den Speicher schreiben)
if ( !(KEY_PIN & (1<<KEY_PINNO)) )
if (gKeyCouter < CNTREPEAT) gKeyCounter++;
else gKeyCounter = 0;
}

...

int main(void)
{
...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
...
// hier wird auf gKeyCounter zugegriffen, dazu muss der in der
// ISR geschrieben Wert bekannt sein.
// (volatile -> aktuellen Wert immer aus dem Speicher lesen)
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt"
}
else {
/* hier: Code fuer "Taste kurz gedrueckt"
}
...
}
</pre>

Bei Variablen größer ein Byte muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes ausserhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<pre class="code">
...
volatile uint16_t gMyCounter16bit
...
SIGNAL(...)
{
...
gMyCounter16Bit++;
...
}

int main(void)
{
uint16_t tmpCnt;
...
// nicht gut: mglw. hier ein Fehler wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor Kopieren des zweiten Bytes
// ein Interrupt auftritt der den Inhalt von MyCounter veraendert
tmpCnt = gMyCounter16bit;

// besser: Aenderungen "ausserhalb" verhindern, alle "Teilbytes"
// bleiben konsistent
cli(); // Interupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren
...
}
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8 (Stand: avr-libc Vers. 1.0.4)

== Was macht das Hauptprogramm ==

Im einfachsten Fall gar nichts mehr. 
Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der
main-Funktion lediglich noch die Interrupts aktiviert und dann in eine
Endlosschleife folgender Art verzweigt:

<pre class="code">
...
for (;;) {}
...
</pre>

Normalerweise wird man allerdings in den Interruptroutinen die Interrupts
erfassen und im Hauptprogramm dann gemütlich auswerten.

Wie wir im bisherigen Kursverlauf gesehen haben ist es ohnehin mit so
schnellen Controller meistens gar nicht unbedingt notwendig mit
Interruptfunktionen zu arbeiten. 
Es ist allerdings auch zu bemerken, dass mit den Interruptroutinen ein Programm
sehr schön strukturiert werden kann, wenn man es richtig macht.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (eigentlich [[SRAM]]) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als [[FLASH]]-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z.B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin wenig Sinn macht und auch nur bei einigen RAM-losen Typen nach "Bastelarbeiten" möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory). Die Standard-Laufzeitbibliothek des avr-gcc, die [[avr-libc]], stellt diese Funktionen nach einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Einige Beispiele:

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray1 };
...
</pre>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<pre class="code">
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte...
}
</pre>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel jedoch mit der Funktion pgm_read_word.

<pre class="code">
uint16_t myWord;

myWord = pgm_read_word(&pgmFooWord);
</pre>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "gross". (Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.) Pointer müssen gegebenenfalls "gecastet" werden.

<pre class="code">
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray1

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray2
// da im zweiteb Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmPointerToArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</pre>

=== Floats und Structs lesen ===

Um komplexe Datentypen (structs), nicht-integer Datentypen (floats) aus dem Flash auszulesen, sind Hilfsfunktionen erforderlich. Einige Beispiele:

<pre class="code">

/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
...

/* liest float von Flash-Addresse addr und gibt diese als return-value zurueck */
inline float pgm_read_float(const float *addr)
{
union
{
uint16_t i[2]; // 2 16-bit-Worte
float f;
} u;

u.i[0]=pgm_read_word((PGM_P)addr);
u.i[1]=pgm_read_word((PGM_P)addr+2);

return u.f;
}
...

void egal(void)
{
int i;
float f;

for (i=0;i<3;i++) {
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach' was mit f
}
}
</pre>

TODO: Beispiele fuer structs und pointer aus flash auf struct im flash (menues, state-machines etc.)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuerht, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
...
</pre>

Aber Achtung: Ersetzt man zum Beispiel
<pre class="code">
const char textImFlash[] PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
durch
<pre class="code">
const char textImFlash* PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der textImFlash zu den Konstanten ans Ende des Programmcodes gelegt wird, von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte. Da der lesende Code trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein Bug des AVR-GCC (gesehen bei 3.4.1) zu sein.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<pre class="code">
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
...
</pre>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z.B. 0x01fe), "weiss" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, das der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000) wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z.B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmässig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, das vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgeben sind ("timed sequence"). Diese Prüfung wird nicht implizit durchgeführt. Im Zweifel kann man Sicherheitshalber bei EEPROM-Zugriffen die Interrupts global deaktivieren, z.B. so:

<pre class="code">
...
uint8_t sreg;
...

sreg = SREG;
cli();

/* hier die eeprom-Zugriffe */

SREG = sreg;
...
</pre>

Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Die Nutzung einer [[C-Präprozessor]]-Ersetzung bringt etwas Bequemlichkeit. Siehe dazu folgendes Beispiel.

<pre class="code">
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h>

// alle Textstellen EEPROM im Quellcode durch __attribute__ ... ersetzen
#define EEPROM __attribute__ ((section (".eeprom")))

...

/* Byte */
uint8_t eeFooByte EEPROM = 123;

/* Wort */
uint16_t eeFooWort EEPROM = 12345;

/* float */
float eeFooFloat EEPROM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEPROM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEPROM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */

uint16_t eeFooWordArray1[4] EEPROM;
...
</pre>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heisst eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<pre class="code">
...
uint8_t myByte;
uint8_t sreg;

sreg = SREG; // (1)
cli(); // (1)

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
...
SREG = sreg; // (1)
</pre>

Die mit (1) markierten Zeilen dienen hierbei dem (möglicherweise übertriebenen) Schutz vor Unterbrechnungen durch Interrupts.

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<pre class="code">
...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
...
</pre>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprueft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und mglw. noch mehr.

<pre class="code">
...
unit8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes aber der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnuetze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray[0],3);

/* dito mit etwas Absicherung betr. der Laenge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));

/* Datenlock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));
...
</pre>

"Nicht-Integer"-Datentypen wie z.B. Fliesskommazahlen lassen sich recht praktisch ueber eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<pre class="code">
...
float myFloat = 12.34;

union {
float r;
uint8_t n[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */
...
</pre>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<pre class="code">
...
typedef struct {
uint8_t label[8];
unin8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEPROM;

...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
...
}
...
</pre>

=== EEPROM-Speicherabbild in .eep-Datei ===

Eine besondere Funktion des avr-gcc ist, dass mit einem entsprechenden makefile aus den Initialisierungswerten der Variablen im Quellcode eine Datei erzeugt werden kann, die man auf den Controller programmieren kann (.eep-Datei). Damit können sehr elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Die Vorgehensweise wird aus dem WinAVR-Beispielmakefile ersichtlich. Siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles.

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Nicht alle neuen AVR Controller werden von avr-libc/eeprom.h untersützt (Stand Version 1.0.4). Insbesondere beim ATMega169 funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register) Etwas ältere Typen, oder zu den "etablierten" Controllern kompatible, bereiten jedoch hier keine Proleme. Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Der dort gezeigt Code kann direkt auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste").

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gcc-Toolchain" bietet dazu zwei Möglichkeiten:

;Inline-Assembler:
Die Assembleranweisungen werden in direkt in den C-Code integriert. Eine Quellcode-Datei enhält somit C- und Assembleranweisungen

;Assembler-Dateien:
Der Assembler-Codecode befindet sich in eigenen Quellcodedateien. Dieser werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z.B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen eine NOP-Anweisung. NOP steht für '''NO'''-O'''P'''eration. Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=warte)-Funktionen.

<pre class="code">
...
/* Verzoegern der weiteren Programmausfuehrung um
genau 3 Taktzyklen */
asm volatile ("nop"::);
asm volatile ("nop"::);
asm volatile ("nop"::);
...
</pre>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeindlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<pre class="code">
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i=0;i<1000;i++);

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i=0;i<1000;i++) asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j=0;j<1000;j++);
</pre>

Ein weiterer nützliche "Assembler-Einzeiler" ist der Auruf von sleep (''asm volatile ("sleep"::);''), da hierzu keine eigene Funktion in der avr-libc existiert.

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil des die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<pre class="code">
static inline void delayloop16(uint16_t count)
{
asm volatile ( "cp %A0,__zero_reg__ \n\t" \
"cpc %B0,__zero_reg__ \n\t" \
"breq L_Exit_%= \n\t" \
"L_LOOP_%=: \n\t" \
"sbiw %0,1 \n\t" \
"brne L_LOOP_%= \n\t" \
"L_Exit_%=: \n\t" \
: "=w" (count)
: "0" (count)
);
}
</pre>

* Jede Zeile wird mit '''\n\t''' abgeschlossen, alle Zeilen mit '''\''' verbunden.
* Sprung-Marken (labels) werden mit einm Prozentzeichen abgeschlossen, der Präprozessor (Assembler?) setzt an dieser Stelle eine laufende Nummer ein, die Doppelbezeichnungen bei mehrmaliger Verwendung somit verhindert.

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc.

* siehe auch: Dokumentation der avr-libc/Related Pages/Inline Asm
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

...TODO: Beispiele, Parameteruebergabe, globale Variablen für Datenaustausch

= TODO =

stdio.h, malloc() ???, Code-Optimierungen ("tricks"), "naked"-Functionen ??, IO-Register als Parameter/"Variablen" (volatile uint8_t *mybusport; mybusport=&PORTB; void sendbus(uint8_t *parm)...)

= C-Code und Bibliotheken für externe Baugrupen =
(TODO: sollte in avr-gcc verschoben werden)
[[Linksammlung#Avr]]

==LCD==
=== Text (character-mode) HD44870 ===
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray

=== Grafik-LCD ===
==== Nokia3310 ====
==== Nokia 6100 LCD ====
Das Nokia ist ein 132x132x4096 Farben Display das bei eBay ziemlich preiswert ersteigert werden kann.
[http://www.apetech.de/nokia6100.php Nokia 6100 LCD Library]
==== KS0108 ====
* Procyon avrlib (GPL)
* avrfreaks UP
* apetech.de
==Schnittstellen==
===I2C===
====Master====
[http://jump.to/fleury/ P. Fleurys I2C Master library]
====Slave====

===CAN===
* [http://www.atmel.com] Codesammlung zum AT90CAN128

=== DS18S20/1-Wire ===
* avrfreaks Projekt 59
* mikrocontroller.net/codesammlung (P. Dannegger)

=== UART ===
* Procyon avrlib (GPL)
* avrfreaks UP (viele viele)
* P. Fleury

== Speicherkarten/IDE/FAT ==
* avrfreaks UP (IDE/FAT read write)
== CRC ==
* avrfreaks-forum (O'Flynn)
* avr-hal (GPL)

AVR-GCC-Tutorial

2004-11-12T12:59:30Z

Oxygene: /* Die Timer/Counter des AVR */

[[Category:AVR]]

= Vorwort =

Dieses Tutorial soll Einsteigern helfen, mit der Programmiersprache '''C''' die Mikrocontroller der Atmel AVR-Reihe zu programmieren.


Die ursprüngliche Version stammt von Christian Schifferle, die meisten aktuellen Anpassungen von [[Benutzer:Mthomas]]. Viele der im Original-Dokument verwendeten Funktionen sind in
aktuellen Versionen des avr-gcc C-Compilers und der avr-libc zwar noch enthalten,
aber als überholt (''deprecated'') ausgewiesen. D.h. diese Funktionen sollten nicht mehr verwendet
werden und existieren in zukünftigen Versionen des Compilers/der Library nicht mehr
(z.B. sbi(), cbi(), outp(), inp()). Der Artikel wurde auf die neuen Funktionen/Methoden
angepasst.

In diesem Text wird häufig auf die Standardbibliothek für den avr-gcc-Compiler, die avr-libc, verwiesen. Die '''Dokumentation der avr-libc''' findet sich
[http://www.nongnu.org/avr-libc/user-manual/index.html hier]. Bei WinAVR gehört diese Dokumentation zum Lieferumfang und wird mitinstalliert.

= Benötigte Werkzeuge =

Um die Übungen in diesem Tutorial nachvollziehen zu können benötigen wir folgende Hard- und Software:

* Testboard für die Aufnahme eines AVR Controllers, der vom gcc Compiler untersützt wird (alle ATmegas und die meisten AT90). Dieses Testboard kann durchaus auch selber zusammen gelötet werden. So arbeite ich mit einem Testboard, welches ich mir auf einer Veroboard-Platine zusammen gestellt habe. Für die Versuche bzw. Übungen in diesem Tutorial habe ich jeweils einen AT90S2313 verwendet. Eine brauchbare Testplattform ist auch der [[AVR Butterfly]].
* AVRGCC-Compiler. Kostenlos erhältlich für nahezu alle Plattformen/Betriebssysteme. Für MS-Windows im Packet [[WinAVR]]; für Unix/Linx siehe auch Hinweise im Artikel [[AVR-GCC]].
* Programmiersoftware und Hardware z.B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], [[AVR-Studio]]).
* Nicht unbedingt erforderlich aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Abschnitt Exkurs: makefiles).

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.
* Die [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently Asked Questions = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.
* Das gcc-Forum auf [http://www.mikrocontroller.net www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.
* Das avr-gcc-Forum bei [http://www.avrfreaks.net avrfreaks] nach vergleichbaren Problemen absuchen.
* Das [http://www.avr1.org/pipermail/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.
* Nach Beispielcode suchen. Vor allem in der Academy von [http://www.avrfreaks.net AVRFREAKS] (anmelden).
* Google oder alltheweb befragen schadet nie.
* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal)
* einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei mgl. viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode, genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z.B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: [http://www.lugbz.org/documents/smart-questions_de.html "Wie man Fragen stellt"].

= Exkurs: makefiles =

Wenn man bisher gewohnt ist, mit integrierten Entwicklungsumgebung à la Visual-C Programme zu erstellen, wirkt das makefile-Konzept auf den ersten Blick etwas kryptisch. Nach kurzer Einarbeitung ist diese Vorgehensweise jedoch sehr praktisch. Diese Dateien (üblicher Name: 'Makefile' ohne Dateiendung) dienen der Ablaufsteuerung des Programms make, das auf allen Unix/Linux-Systemen installiert sein sollte, und in einer Fassung fuer MS-Windows auch in [[WinAVR]] (Unterverzeichnis utils/bin) enthalten ist.

Im Unterverzeichnis ''sample'' einer WinAVR-Installation findet man eine sehr brauchbare Vorlage, die sich einfach an das eigene Projekt anpassen lässt ([[Media:Makefile|lokale Kopie Stand Sept. 2004]]). Wahlweise kann man auch [http://www.sax.de/~joerg/mfile/ mfile] von Jörg Wunsch nutzen. mfile erzeugt ein makefile nach Einstellungen in einer grafischen Nutzeroberfläche, wird bei WinAVR mitinstalliert, ist aber als TCL/TK-Programm auf nahezu allen Platformen lauffähig.

''Die folgenden Ausführungen beziehen sich auf das WinAVR Beispiel-Makefile.''

Ist im Makefile alles richtig eingestellt genügt es, sich drei Parameter zu merken, die über die shell bzw. die Windows-Kommandozeile (cmd.exe/command.exe) als Parameter an "make" übergeben werden. Das Programm make sucht sich "automatisch" das makefile im aktuellen Arbeitsverzeichnis und führt die darin definierten Operationen für den entsprechenden Aufrufparameter durch.

{| border=1
| ''make all''
| Erstellt aus den in im makefile angegebenen Quellcodes eine ''hex''-Datei (und ggf. auch ''eep''-Datei).
|-
| ''make program''
| Überträgt die hex-Datei (und wahlweise auch die eep-Datei für den EEPROM) zum AVR.
|-
| ''make clean''
| löscht alle temporären Dateien, also auch die hex-Datei
|}

Diese Aufrufe können in die allermeisten Editoren in "Tool-Menüs" eingebunden werden. Dies erspart den Kontakt mit der Kommandozeile. (Bei WinAVR sind die Aufrufe bereits im Tools-Menü des mitgelieferten Editors Programmers-Notepad eingefügt.)

Üblicherweise sind folgende Daten im makefile anzupassen:
* Controllertyp
* Quellcode-Dateien (c-Dateien)
* Typ und Anschluss des Programmiergeräts

seltener sind folgende Einstellungen durchzuführen:
* Grad der Optimierung
* Methode zur Erzeugung der Debug-Symbole (Debug-Format)
* Assembler-Quellcode-Dateien (S-Dateien)

Die in den folgenden Unterabschnitten gezeigten makefile-Ausschnitte sind für ein Programm, das auf einem ATmega8 ausgeführt werden soll. Der Quellcode besteht aus den c-Dateien superprog.c (darin main()), uart.c, lcd.c und 1wire.c. Im Quellcodeverzeichnis befinden sich diese Dateien: superprog.c, uart.h, uart.c, lcd.h, lcd.c, 1wire.h, 1wire.c und das makefile (die angepasste Kopie des WinAVR-Beispiels).

Der Controller wird mittels [[AVRDUDE]] über ein [[STK200]]-Programmierdongle an der Schnittstelle lpt1 (bzw. /dev/lp0) programmiert. Im Quellcode sind auch Daten für die ''section .eeprom'' definiert (siehe Abschnitt Speicherzugriffe TODO: nach unten verlinken), diese sollen beim Programmieren gleich mit ins EEPROM geschrieben werden.

== Controllertyp setzen ==

Dazu wird die "make-Variable" MCU entsprechend dem Namen des verwendenten Controllers gesetzt. Ein Liste der von avr-gcc und der avr-libc untersützten Typen findet sich in der [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc].

<pre class="code">
# Kommentare in Makefiles beginnen mit einem Doppelkreuz
...

# ATmega8 at work
MCU = atmega8
# oder MCU = atmega16
# oder MCU = at90s8535
# oder ...
...
</pre>

== Quellcode-Dateien einstellen ==

Den Namen der Quellcodedatei welche die Funktion main enthält, wird hinter TARGET eingetragen. Dies jedoch ohne die Endung ''.c''.

<pre class="code">
...
TARGET = superprog
...
</pre>

Besteht das Projekt wie im Beispiel aus mehr als einer Quellcodedatei, sind die weiteren c-Dateien (nicht die Header-Dateien, vgl. [[Include-Files (C)]]) durch Leerzeichen getrennt bei SRC einzutragen. Die bei TARGET definierte Datei ist schon in der SRC-Liste enthalten. Diesen Eintrag nicht löschen!

<pre class="code">
...
SRC = $(TARGET).c uart.c lcd.c 1wire.c
...
</pre>

Alternativ kann man die Liste der Quellcodedateien auch mit dem Operator += erweitern.

<pre class="code">
SRC = $(TARGET).c uart.c 1wire.c
# lcd-Code fuer Controller xyz123 (auskommentiert)
# SRC += lcd_xyz.c
# lcd-Code fuer "Standard-Controller" (genutzt)
SRC += lcd.c
</pre>

== Programmiergerät einstellen ==

Die Vorlagen sind auf die Programmiersoftware [[AVRDUDE]] angepasst, jedoch lässt sich auch andere Programmiersoftware einbinden, sofern diese über Kommandozeile gesteuert werden kann (z.B. stk500.exe, uisp, sp12).

<pre class="code">
...
# Einstellung fuer STK500 an com1 (auskommentiert)
# AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
# AVRDUDE_PORT = com1 # programmer connected to serial device

# Einstellung fuer STK200-Dongle an lpt1
AVRDUDE_PROGRAMMER = stk200
AVRDUDE_PORT = lpt1
...
</pre>

Sollen Flash(=.hex) und EEPROM(=.eep) zusammen auf den Controller programmiert werden, ist das Kommentarzeichen vor AVRDUDE_WRITE_EEPROM zu löschen.

<pre class="code">
...
#Auskommentiert: EERPOM-Inhalt wird nicht mitgeschrieben
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

#Nich-auskommentiert EERPOM-Inhalt wird mitgeschrieben
AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
...
</pre>

== Anwendung ==

Die Eingabe von ''make all'' im Arbeitsverzeichnis mit dem makefile und den Quellcodedateien erzeugt (unter anderem) die Dateien superprog.hex und superprog.eep. Abhängigkeiten zwischen den einzelnen c-Dateien werden dabei automatisch berücksichtigt. Die ''superprog.hex'' und ''superprog.eep'' werden mit ''make program'' zum Controller übertragen. Mit ''make clean'' werden alle temporären Dateien gelöscht (="aufgeräumt").

== Sonstige Einstellungen ==

=== Optimierungsgrad ===

Der gcc-Compiler kennt verschiedene Stufen der Optimierung. Nur zu Testzwecken sollte die Optimierung ganz deaktiviert werden (''OPT = 0''). Die weiteren möglichen Optionen weisen den Compiler an, möglichst kompakten oder möglichst schnellen Code zu erzeugen. In den weitaus meisten Fällen ist ''OPT = s'' die optimale (sic) Einstellung, damit wird kompakter und oft auch der "schnellste" Maschienencode erzeugt.

=== Debug-Format ===

Unterstützt werden die Formate stabs und dwarf-2. Das Format wir hinter ''DEBUG ='' eingestellt. Siehe dazu Abschnitt ''Eingabedateien zur Simulation''.

=== Assembler-Dateien ===

Die im Projekt genutzten Assembler-Dateien werden hinter ASRC durch Leerzeichen getrennt aufgelistet. Assembler-Dateien haben immer die Endung .S (grosses S). Ist zum Beispiel der Assembler-Quellcode eines Software-UARTs in einer Datei softuart.S enthalten lautet die Zeile: ''ASRC = softuart.S''

== Eingabedateien zur Simulation in AVR-Studio ==

Mit älteren AVR-Studio-Versionen kann man nur auf Grundlage sogenannter ''coff''-Dateien simulieren. Neuere Versionen von AVR-Studio (ab 4.10.356) unterstützen zudem das modernere aber noch experimentelle dwarf-2-Format, das ab WinAVR 20040722 (avr-gcc 3.4.1/Binutils inkl. Atmel add-ons) "direkt" vom Compiler erzeugt wird.

; Vorgehensweise bei extcoff:
* im Makefile bei DEBUG: <pre class="code">DEBUG=stabs</pre>
* ''make extcoff'' (evtl. vorher ''make clean'')
* die erzeugte ''cof''-Datei (im Beispiel oben ''superprog.cof'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

; Vorgehensweise bei dwarf-2:
* im Makefile bei DEBUG: <pre class="code">DEBUG=dwarf-2</pre>
* ''make all'' (evtl. vorher ''make clean'')
* die erzeugte ''elf''-Datei (im Beispiel oben ''superprog.elf'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

Beim Simulieren scheinen oft "Variablen zu fehlen". Ursache dafür ist, dass der Compiler die "Variablen" direkt Registern zuweist. Dies kann vermieden werden, indem die Optimierung abgeschaltet wird (im makefile). Man simuliert dann jedoch ein vom optimierten Code stark abweichendes Programm. Das Abschalten der Optimierung wird nicht empfohlen.

Statt des Software-Simulators kann das AVR-Studio auch genutzt werden, um mit dem ATMEL JTAGICE, ein Nachbau davon (BootICE, Evertool o.ä.) oder dem ATMEL JTAGICE MKII "im System" zu debuggen. Dazu sind keine speziellen Einstellungen im makefile erforderlich. Debugging bzw. "In-System-Emulation" mit dem JTAGICE und JTAGICE MKII sind in der AVR-Studio Online-Hilfe beschrieben.

= Definition einiger Datentypen =

Für die Programmierung von Mikrocontrollern ist es sinnvoll, dass wir uns
vorerst einige Datentypen definieren, welche den Zugriff auf die verschiedenen
Komponenten des Controllers vereinfachen oder wenigstens das Programm lesbarer
machen können.

<pre class="code">
typedef unsigned char BYTE;
typedef unsigned short WORD;
</pre>

== BYTE ==

Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 255.

== WORD ==

Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 65535.

== DWORD ==

Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

== QWORD ==

Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

Bei allen vorgenannten Datentypen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z.B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich daher, die im folgenden Abschnitt beschriebenen standardisierten Datentypen zu nutzen und damit "Missverständnissen" vorzubeugen, die z.B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

= Standardisierte Integer(Ganzzahl)-Typen =

Standardisierte Datentypen werden in der Header-Datei inttypes.h definiert.
Will man diese Typen benutzen, bindet man die "Definitionsdatei" wie folgt ein:

<pre class="code">
#include <inttypes.h>
</pre>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<pre class="code">
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
</pre>

Ein Vierfach-Wort (64Bit) entspricht beim AVR ''uint64_t'', ein Doppel-[[Word|Wort]] (32bit) entspricht ''uint32_t'', ein Wort (16bit) entspricht ''uint16_t'' und ein [[Byte]] (8bit) entspricht ''uint8_t''.
Die Typen ohne vorangestelltes ''u'' können auch vorzeichenbehaftete Zahlen speichern. ''int8_t'' geht also von -128 bis 127, ''uint8_t'' dagegen geht von 0 bis 255.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Integer Types

== '''Bitfelder''' ==

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bit breit ist. 
Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in einer einzelnen Bytevariable zusammen fassen und (fast) wie
8 einzelne Variablen ansprechen können. 
Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente
definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<pre class="code">
struct {
unsigned char bStatus_1:1; // 1 Bit für bStatus_1
unsigned char bStatus_2:1; // 1 Bit für bStatus_2
unsigned char bNochNBit:1; // Und hier noch mal ein Bit
unsigned char b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</pre>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<pre class="code">
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</pre>

(mt Empfehlung: Bitfelder sparen zwar Platz, verschlechtern aber unter
Umständen die Les- und Wartbarkeit des Codes. Anfängern wird geraten,
ein "ganzes" ein Byte (uint8_t) zu nutzen auch wenn nur ein Bitwert gespeichert
werden soll.)

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten
Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher
Dinge erledigt werden können, welche nicht zeitkritisch sind. 
Wenn ein Interrupt ausgelöst wird so wird automatisch die zugeordnete
Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Allgemeiner Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heisst, das Programm kann die
Inhalte der Register auslesen und beschreiben. 
Einige Register haben spezielle Funktionen, andere wiederum könne für
allgemeine Zwecke (Speichern von Datenwerten) verwendet werden.

Einzelne Register sind bei allen AVR's vorhanden, andere wiederum nur bei
bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff
auf den UART notwendig sind selbstverständlich nur bei denjenigen Modellen
vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden
AVR-Typen definiert. 

Wenn im Makefile der MCU-Typ definiert ist, wird vom System automatisch die
zum Typen passende Definitionsdatei genutzt, sobald man im Code die allgemeine
"io.h" Header-Datei einbinden.

<pre class="code">
#include <avr/io.h>
</pre>

Ist im Makefile der MCU Type z.B. mit dem Inhalt atmega8 definiert,
wird beim einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit
den Register-Definitionen für den ATmega8 eingelesen.



== I/O-Register ==

Die I/O-Register haben einen besonderen Stellenwert bei den AVR Controllern.
Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. 
Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir mal
die 8-Bit Register.


=== Lesen eines I/O-Registers ===



Zum Lesen kann man auf I/O Register einfach wie auf eine
Variable zugreifen. Die spezielle Funktion inp() ist nicht mehr
notwendig und veraltet.

Beispiel:

<pre class="code">
#include <avr/io.h>
uint8_t foo;
...
int main(void)
{
foo=PINB; /* kopiert den Status der Eingabepins an PortB in die Variable foo */
...
}
</pre>

==== Lesen eines Bits ====

Die AVR-Bibliothek stellt auch Funktionen zur Abfrage eines einzelnen Bits
eines Registers zur Verfügung:

;bit_is_set (<Register>,<Bitnummer>) : Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 4 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>) : Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen bit_is_clear bzw. bit_is_set sind nicht unbedingt erfoderlich, man kann auch "einfachen" C-Syntax verwenden. Der universell verwendbar ist. ''bit_is_set'' entspricht dabei z.B. (Variable & (1<<Bitnummer)). Das Ergebnis ist <>0 wenn das Bit gesetzt und 0 wenn nicht gesetzt ist.

* siehe auch [[Bitmanipulation]]

=== Schreiben eines I/O-Registers ===



Zum Schreiben kann man I/O Register einfach wie eine
Variable setzen. Die spezielle Funktion outp() ist nicht mehr
notwendig, veraltet und sollte nicht mehr genutzt werden.

Beispiel:

<pre class="code">
#include <avr/io.h>
...
int main(void)
{
DDRA=0xff; /* Setzt das Richtungsregister des Ports A auf 0xff (alle Pins als Ausgang) */
PORTA=0x03; /* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low" */
...
}
</pre>

==== Schreiben eines Bits ====



Einzelne Bits setzt man "Standard-C-Konform" mittels logischen (bit-) Operationen.

mit dem Ausduck |=(1<<Bitnummer) wird ein Bit gesetzt, mit dem Ausdruck
&=~(1<<Bitnummer) wird ein Bit geloescht. Die Funktionen sbi und cbi sind
dazu nicht notwendig, veraltet und sollten nicht mehr genutzt werden.

Beispiel:
<pre class="code">
...
#define MEINBIT 2
...
PORTA |= (1<<MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1<<MEINBIT); /* loescht Bit 2 an PortA */
</pre>

* siehe auch:
** [[Bitmanipulation]]
** [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

=== Warten auf einen bestimmten Zustand ===

Es gibt in der Bibliothek sogar Funktionen, die Warten, bis ein bestimmter
Zustand auf einem Bit erreicht ist. 
Es ist allerdings normalerweise eine eher unschöne Programmiertechnik.

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das
definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits
gesetzt ist wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT 2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1<<WARTEBIT)) ) ;
</pre>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das
definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits
gelöscht ist wird die Funktion sofort wieder verlassen. 
Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT 4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// ungleich 0 ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
</pre>

Universeller und auch auf andere Platformen besser übertragbar ist die Verwendung von C-Standardoperationen.

siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]



= Zugriff auf Ports =

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind
jedem Port 3 Register zugeordnet:

{| border="1"
|-
| '''DDRx'''
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (anhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
| '''PORTx'''
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Wird ein Port als Eingang geschaltet, so können mit diesem Register
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|-
| '''PINx'''
| Eingangadresse für Port'''x'''.

Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der Portspins. Bit gesetzt (1) wenn Pin "high/an", Bit gelöscht (0) wenn Portpin "low/aus".
|}

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.


Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Wollen wir also beispielsweise Pin 0 bis 4 von Port B als Ausgänge
definieren so schreiben wir folgende Zeile:


<pre class="code">
#include <avr/io.h>
...
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F

DDRB=0x1F; /* direkte Zuweisung - unuebersichtlich */
/* mehr Tipparbeit aber uebersichtlicher: */
DDRB=(1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3)|(1<<DDB4);
...
</pre>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet.

=== Ganze Ports ===

Um einen ganzen Port als Ausgang zu definieren, kann der folgende Befehl
verwendet werden:

<pre class="code">
DDRB=0xff;
</pre>

Im Beispiel wird der Port B als Ganzes als Ausgang geschaltet.

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen
bzw. auszugeben.

== Ausgänge ==

Wir wollen nun einen als Ausgang definierten Pin auf Logisch 1 setzen. Dazu schreiben wir den entsprechenden Wert in das Portregister des entsprechenden Ports.

Mit dem Befehl

<pre class="code">
PORTB=0x04; /* besser PORTB=(1<<DDB2) */
</pre>

wird also der Ausgang an Pin 2 gesetzt (Beachte, dass die Bits immer ''von 0 an''
gezählt werden, das niederwertigste Bit ist also Bit 0 und nicht etwa Bit 1).

Man beachte bitte, dass bei der Zuweisung mittels '''='''  immer alle Pins gleichzeitig angegeben werden. Man sollte also zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfliessen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an PortB auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<pre class="code">
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<DDB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<DDB2)
</pre>


Die Funktionen cbi und sbi sind dazu nicht notwendig, veraltet und sollten
nicht mehr genutzt werden.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wird den Pegel über entsprechende Hardware (z.B. Optokoppler, Spannunsteiler "Levelshifter") anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unserer Controllers eine logische 1 (Vcc) oder eine logische 0 (Masse) anliegt.

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.



Wobei es hier sehr wichtig ist, zur Abfrage der Eingänge nicht etwa das Portregister '''PORTx''' zu verwenden, sondern die Porteingangsadresse '''PINx'''. Dies ist
ein oft gemachter Fehler!

Wollen wir also die aktuellen Signalzustände von Port D abfragen und in einer
Variable namens bPortD abspeichern so schreiben wir dazu folgende Befehlszeile:

<pre class="code">
#include <avr/io.h>
...
bPortD = PIND;
...
</pre>


=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen (''Active Low'' und ''Active High''):

{| border="1"
|-
| '''Active Low'''
| '''Active High'''
|-
| [[Image:Active Low.gif]]
| [[Image:Active High.gif]]
|-
| Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet.

Damit bei offenem Schalter der Controller kein undefiniertes Signal
bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein
sogenannter Pull-Up Widerstand geschaltet. Dieser dient dazu, den Pegel
bei geöffnetem Schalter auf logisch 1 zu ziehen. 
Der Widerstandswert des Pull-Up Widerstands ist an sich nicht kritisch. Es
muss jedoch beachtet werden, dass über den Widerstand ein Strom in den
Eingang fliesst, also sollte er nicht zu klein gewählt werden um den
Controller nicht zu zerstören. Wird er allerdings zu hoch gewählt ist
die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10
Kiloohm eingebürgert.

Die AVR's haben sogar an den meisten Pins softwaremässig zuschaltbare
interne Pull-Up Widerstände, welche wir natürlich auch verwenden
können.
| Hier wird der Kontakt zwischen die Versorgungsspannung und Masse geschaltet.

Damit bei offener Schalterstellung kein undefiniertes Signal am Controller
ansteht, wird zwischen den Eingangspin und die Masse ein Pull-Down
Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter
Schalterstellung auf logisch 0 zu halten.
|}

==== Pull-Up Widerstände aktivieren ====

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden
über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang'''
geschaltet ist. 

Wird der Wert des entsprechenden Portpins auf 1 gesetzt so ist
der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up
Widerstand nicht aktiv. 
Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand
verwenden, aber nicht beide zusammen.



<pre class="code">
#include <avr/io.h>
...
DDRD=0x00; /* alle Pins von Port D als Eingang */
PORTD=0xff: /* interer Pull-Up an allen Port-Pins aktivieren */
...
</pre>

Im Beispiel wird der gesamte Port D als Eingang geschaltet und alle Pull-Up
Widerstände aktiviert.

===== Tastenentprellung =====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von
Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim
Schliessen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern
mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes. 
Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein
solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen
als mehrfache Impulse gezählt wird. 
Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen
werden.

ToDo Bsp Quellcode

== Analog ==

Leider können wir mit unseren Controllern keine analogen Werte direkt
ausgeben oder einlesen. Dazu müssen wir Umwege gehen, doch dies wird in einem späteren
Kapitel behandelt.

=== 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1) ===

Einige der Portregister in den AVR-Controllern sind 16 Bit breit, Man spricht
dann von einem '''Wort'''.


Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<pre class="code">
#include <avr/io.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8

= Der UART, Teil 1 =

Wir werden in zukünftigen Übungen in die Situation kommen, dass wir
Informationen vom Controller auswerten bzw. anzeigen müssen wobei es vielleicht
dann nicht mehr reicht, ein paar Leuchtdioden anzusteuern. 
Somit brauchen wir eine Verbindung vom AVR zu unserem PC, und dies am besten
über die serielle Schnittstelle.

== Allgemeines zum UART ==

Einige AVR-Controller haben einen vollduplexfähigen UART ('''U'''niversal
'''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut.
Dies ist eine wirklich feine Sache, haben wir doch damit schon das nötige
Werkzeug, um mit anderen Geräten, welche über eine serielle Schnittstelle
verfügen (insbesondere mit unserem PC), zu kommunizieren.

Übrigens: Vollduplex heisst nichts anderes, als dass der Baustein gleichzeitig
senden und empfangen kann.

Neuere AVRs (ATmega) verfügen über einen oder zwei U'''S'''ART(s), dieser unterschiedet sich vom UART häuptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

Der UART wird über vier separate Register angesprochen. USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurations/Datenregister. Das Datenblatt gibt darüber Auskunft. Die Folgende Tabelle gibt nur die Register für die (veralteten) UARTs wieder.

{| border="1"
|-
| '''UCR   '''
| '''U'''ART '''C'''ontrol '''R'''egister. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXCIE'''
| align="center" | '''TXCIE'''
| align="center" | '''UDRIE'''
| align="center" | '''RXEN'''
| align="center" | '''TXEN'''
| align="center" | '''CHR9'''
| align="center" | '''RXB8'''
| align="center" | '''TXB8'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''CHR9''' (9 Bit Characters)
:Wenn dieses Bit gesetzt ist, können 9 Bit lange Zeichen übertragen und empfangen werden. Das 9. Bit kann bei Bedarf als zusätzliches Stopbit oder als Paritätsbit verwendet werden. Man spricht dann von einem 11-Bit Zeichenrahmen:
:1 Startbit + 8 Datenbits + 1 Stopbit + 1 Paritätsbit = 11 Bits

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.

|-
| '''USR   '''
| '''U'''ART '''S'''tatus '''R'''egister. 
Hier teilt uns der UART mit, was er gerade so macht.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXC'''
| align="center" | '''TXC'''
| align="center" | '''UDRE'''
| align="center" | '''FE'''
| align="center" | '''OR'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt bevor ein weiteres Zeichen komplett empfangen wurde wird eine Überlauf-Fehlersituation eintreffen. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, wenn die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit wird vom AVR gesetzt, wenn ein Zeichen vom Sendedatenregister in das Send-Schieberegister übernommen wurde und der UART nun wieder bereit ist, ein neues Zeichen zum Senden aufzunehmen.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''OR''' ('''O'''ver'''R'''un) 
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne
kommunizieren möchten. Der Wert, der in dieses Register geschrieben
werden muss, errechnet sich nach folgender Formel:

<math>
\begin{matrix}
UBBR = \frac{Taktfrequenz}{Baudrate * 16} - 1
\end{matrix}
</math>

Es sind Baudraten bis zu 115200 Baud und höher möglich.
|}

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (LOW) und 5V (HIGH). Die
Schnittstellenspezifikation für RS232 definiert jedoch -3V ... -12V (LOW) und
+3 ... +12V (HIGH). Zudem muss der Signalaustausch zwischen AVR und
Partnergerät invertiert werden. Für die Anpassung der Pegel und das
Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste
davon ist wohl der MAX232. Allerdings kostet der auch wieder Geld und benötigt
zusätzlich immerhin 4 externe Elkos.

Die in den PC eingebauten Schnittstellen vertragen ohne Klagen auch den
TTL-Pegel vom AVR. Allerdings müssen wir immer noch die Signale invertieren. Im
einfachtesn Fall verwenden wir dazu jeweils einen einfachen NPN-Transistor und 2
Widerstände. Näheres dazu erfahrt ihr in den folgenden Übungen.

Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z.B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfielt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Senden mit dem UART ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. 
Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach
gewünschter Funktionsweise die
benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister. 
Da wir vorerst nur senden möchten und (noch) keine Interrupts auswerten wollen,
gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das
'''Transmitter Enable''' Bit setzen müssen:


<pre class="code">
UCR |= (1<<TXEN);
</pre>

Der Atmega16 hat mehrere Konfigurationsregister für USART und erfordert eine etwas andere Konfiguration

<pre class="code">
UCSRB |= (1<<TXEN); //UART TX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1
</pre>

Nun müssen wir noch die Baudrate festlegen. Gemäß unserer Formel brauchen
wir dazu die Taktfrequenz des angeschlossenen Oszillators bzw. Quarz in die
Formel einzufügen und das Resultat der Berechnung in das Baudratenregister des
UART einzuschreiben:

<pre class="code">
/* UART-Init beim AT90S2313 */
#define F_CPU 4000000; // Zum Beispiel 4Mhz-Quarz
#define UART_BAUD_RATE 9600 // Wir versuchen mal mit 9600 Baud
UBRR = F_CPU / (UART_BAUD_RATE * 16L) - 1;
</pre>

Wieder für den Mega16 mit einem 16bit-Register eine andere Programmierung

<pre class="code">
/* USART-Init beim ATmegaXX */
#define F_OSC 3686400 /* Oszillator-Frequenz in Hz */
#define UART_BAUD_RATE 9600
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)

UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

/* alternativ bei der avr-libc "direkt 16bit" : */
UBRR=UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);
</pre>

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben.

<pre class="code">
while (USR & (1<<UDRE)); /* warten bis Senden moeglich */
UDR = 'x'; // Schreibt das Zeichen x auf die Schnittstelle
</pre>

=== Schreiben einer Zeichenkette (String) ===

Es ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

Zu diesem Zweck können wir uns für's Erste eine einfache Funktion basteln:

<pre class="code">
void SendeString (char *szBuf)
{
while (*szBuf) {
loop_until_bit_is_set (USR, UDRE); /* warten bis Senden moeglich */
UDR=*szBuf;
szBuf++;
}
}
</pre>

Warteschleifen sind insofern etwas kritisch, da während des Sendens eines
Strings nicht mehr auf andere Ereignisse reagieren werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. emfangenen Zeichen/Bytes zwischengespeichert und mittels Interruptroutinen an den U(S)ART weitergebgen bzw. ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

* siehe auch: Weiterführende Informationen inkl. Beispielen für die Nutzung von stdio-Funktionen (prinf etc.) im [[AVR-Tutorial - UART]].
* [http://homepage.sunrise.ch/mysunrise/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc

= Analoge Ein- und Ausgabe =

Leider können wir mit unseren Controllern keine analogen Werte direkt
verarbeiten. Dazu bedarf es jeweils einer Umwandlung des analogen Signals in
einen digitalen Zahlenwert. Je nachdem, ob wir Daten einlesen oder ausgeben
wollen reden wir dabei von '''ADC''' oder '''DAC'''.

== ADC (Analog Digital Converter) ==

Der '''ADC''' wandelt analoge Signale in digitale Werte um, welche vom Controller
interpretiert werden können. Einige AVR-Typen haben bereits einen oder mehrere
solcher '''ADC''''s eingebaut, bei den kleineren AVR's müssen wir uns anders aus der
Affäre ziehen. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst
werden kann, wird durch die Auflösung des '''ADC''' in Anzahl Bits angegeben, man
hört bzw. liest jeweils von 8-Bit '''ADC''' oder 10-Bit ''' ADC''' oder noch höher. 
Ein '''ADC''' mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit
von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten
eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

<div align="center"><center>

{| border="1"
|-
| align="center" | '''Eingangsspannung am ADC'''
| align="center" | '''Entsprechender Messwert'''
|-
| align="center" | 0...<0.625V
| align="center" | 0
|-
| align="center" | 0.625...<1.25V
| align="center" | 1
|-
| align="center" | 1.25...<1.875V
| align="center" | 2
|-
| align="center" | 1.875...<2.5V
| align="center" | 3
|-
| align="center" | 2.5...<3.125V
| align="center" | 4
|-
| align="center" | 3.125...<3.75V
| align="center" | 5
|-
| align="center" | 3.75...<4.375V
| align="center" | 6
|-
| align="center" | 4.375...5V
| align="center" | 7
|}

</center>
</div>

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des '''
ADC''' ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Messen eines Widerstandes ===

Wir wollen hier einmal die wohl einfachste Methode zur Erfassung eines
analogen Wertes realisieren und zwar das Messen eines veränderlichen
Widerstandes wie z.B. eines Potentiometers.

Man stelle sich vor, wir schalten einen Kondensator in Reihe zu einem
Widerstand zwischen die Versorgungsspannung und Masse und dazwischen nehmen wir
das Signal ab und führen es auf einen der Pins an unserem Controller, genau so
wie es in folgender Grafik dargestellt ist.

[[Image:Poti.gif]]

Wenn wir nun den Pin des AVR als Ausgang schalten und auf
Logisch 1 (HIGH) legen, dann liegt an beiden Platten des Kondensators ''' Vcc''' an und
dieser wird entladen (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen). 
Nachdem nun der Kondensator genügend entladen ist schalten wir einfach den Pin
als Eingang wodurch dieser hochohmig wird. Der Kondensator lädt sich jetzt
über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und
derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti
unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), dann schaltet der
Eingang von HIGH auf LOW um. Wenn wir nun messen (zählen), wie lange es dauert,
bis der Kondensator so weit geladen ist, dann haben wir einen ungefähren Wert
der Potentiometerstellung. 
Der 220 Ohm Widerstand dient dem Schutz des Controllers. Wenn nämlich sonst die
Potentiometerstellung auf Maximum steht (0 Ohm), dann würde in den Eingang des
Controllers ein viel zu hoher Strom fliessen und der AVR würde in Rauch
aufgehen.

Dies ist meines Wissens die einzige Schaltung zur Erfassung von
Analogwerten, welche mit nur einem einzigen Pin auskommt. 
Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine
Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B:
0...100 % oder so) umzurechnen.

Wer Lust hat, sich selber mal an ein solches Programm
heranzuwagen, der sollte das jetzt tun. Für diejenigen, die es gern schnell
mögen, hier das Beispielprogramm, welches den UART-Printf aus den
vorangegangenen Kapiteln benötigt, inkl. Makefile:

{| border="0"
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Poti.c Poti.c ]
| Hauptprogramm.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.c Pot.c]
| Separate Routine zur Ermittlung des Messwertes.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.h Pot.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c UartPrintF.c]
| Für die Debugausgabe auf den UART.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h UartPrintF.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile Makefile]
| Makefile.
|}

Nachdem das Programm auf den AVR geladen wurde, muss dieser
kalibriert werden. Dazu wird der Kalibrierungsschalter geschlossen und das Poti
einige Male zwischen minimaler und maximaler Stellung hin und her gedreht. Dabei
werden die jeweiligen Maximalwerte bestimmt. Wenn der Kalibrierschalter wieder
geöffnet wird werden die Kalibrierungsdaten in's EEPROM des AVR geschrieben,
damit die Prozedur nicht nach jedem Reset wiederholt werden muss.

Auf Pin 4 habe ich noch ein Triggersignal gelegt, welches auf
HIGH geht wenn die Messung beginnt und auf LOW, wenn der Messvorgang beendet
wird. Mit Hilfe dieses Signals kann der Vorgang wunderschön auf einem
Oszillographen dargestellt werden.

=== ADC über Komparator ===

Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

[[Image:ADC ueber Komparator.gif]]

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert. 
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

=== Der ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem '''ADC-Wandler''' zurückgreifen. Wir wollen hier einmal den AT90S8535 besprechen, welcher über 8 ADC-Kanäle verfügt. (TODO: nur ein Wandler, Mulitiplexbetrieb, nur eine Pin zur gleichen Zeit)

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung.

Verfügt der AVR über eine interne Referenzspannung (Datenblatt typisch 2,56 oder 1,1V je nach AVR), bleibt der ''Anschluss AREF'' unbeschaltet und man stellt die ADC-Register so ein, dass die interne Referenzspannung als "AREF" genutzt wird. Ansonsten ist eine externe Referenzspannung von maximal '''Vcc''' an den Abschluss '''AREF''' anzulegen. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden.

==== Einfache Wandlung (Single Conversion) ====

In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestossen für jeweils eine Messung.

==== Frei laufend (Free Running) ====

In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register, welche hier aufgelistet werden.

{| border="1"
|-
| '''ADCSR   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ADEN'''
| align="center" | '''ADSC'''
| align="center" | '''ADFR'''
| align="center" | '''ADIF'''
| align="center" | '''ADIE'''
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt, ist können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''Fr'''ee Running Select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Eine logische 1 aktiviert den frei laufenden Modus. Der ''' ADC''' misst nun ständig den ausgewählten Kanal und schreibt den gemessenen Wert in das '''ADC Data Register'''.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, wenn eine Umwandlung erfolgt und das '''ADC Data Register''' aktualisiert ist.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird (So steht es in der AVR-Dokumentation).

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200kHz}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50kHz}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.
<dl><dd>
{| style="" border="1"
|-
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
| align="center" | '''Teilungsfaktor'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 2
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 2
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 4
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 8
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 16
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 32
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 64
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 128
|}
</dd></dl>
|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<pre class="code">
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
C-Operatorprioritaet sichergestellt)
</pre>

oder

<pre class="code">
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</pre>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''MUX2'''
| align="center" | '''MUX1'''
| align="center" | '''MUX0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''MUX2...MUX0'''
:Mit diesem 3 Bits wird der zu messende Kanal bestimmt. Es wird einfach die entsprechende Pinnummer des Ports eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Meine Empfehlung ist deswegen klar diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Aktivieren des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register
setzen. Im gleichen Schritt legen wir auch gleich die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls mit Spannungsteiler konditionieren. Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1024 für V_ref-Volt.

<pre class="code">

#define CHANNELOFFSET 4

uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result;

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler setzen auf 8 (1)
ADCSRA |= (1<<ADEN); // ADC aktivieren (1)

ADMUX = CHANNELOFFSET+channel; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)

result = 0;

/* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
for(i=0;i<4;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)
result += ADC; // Wandlungsergebnisse aufaddieren
}

ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)

result >>= 2; // Summe durch vier teilen = arithm. Mittelwert

return result;
}
</pre>

Im Beispiel wird bei jedem Aufruf der ADC aktiviert und nach der Wandlung wieder abgeschaltet, das spart Strom. Will man dies nicht, verschiebt man die mit (1) gekenntzeichneten Zeilen in eine Funktion adc_init() o.ä. und löscht die mit (2) markierten Zeilen.



== DAC (Digital Analog Converter) ==

Mit Hilfe eines ''' DAC''' können wir nun auch Analogsignale ausgeben. Es gibt hier
mehrere Verfahren. Wenn wir beim ''' ADC''' die Möglichkeit haben, mit externen
Komponenten zu operieren, müssen wir bei der '''DAC'''-Wandlung mit dem auskommen, was
der Controller selber zu bieten hat.

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie ''' PWM''' eigentlich funktioniert.

Wie wir alle wissen ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber
wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. 
Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen
HIGH und LOW umschalten? 
Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen geometrischen Mittelwert, der je nach Pulsbreite
kleiner oder grösser ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein
RC-Glied filtern dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVR's können wir direkt '''PWM'''-Signale erzeugen. Dazu
dient der 16-Bit Zähler, welcher im sogenannten '''PWM'''-Modus betrieben werden
kann.

Hinweis:
:In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist allerdings bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt.

Um den '''PWM'''-Modus zu aktivieren müssen im Timer/Counter1 Control
Register A '''TCCR1A''' die Pulsweiten-Modulatorbits '''PWM10''' bzw. '''PWM11''' entsprechend
nachfolgender Tabelle gesetzt werden:

{| border="1"
|-
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| PWM-Modus des Timers ist nicht aktiv.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM.
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben. Die
Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| border="1"
|-
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden heisst dann:

<pre class="code">
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</pre>

Damit der Timer/Counter überhaupt läuft müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorzähler) einstellen, und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| border="1"
|-
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<pre class="code">
TCCR1B = (1<<CS12) | (1<<CS10);
</pre>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<pre class="code">
OCR1A = xxx;
</pre>

Die folgende Grafik soll den Zusammenhang zwischen dem
Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren.

= Die Timer/Counter des AVR =

Die heutigen Mikrocontroller und insbesondere die RISC-AVR's sind für viele
Steuerungsaufgaben natürlich viel zu schnell. Wenn wir beispielsweise eine LED
oder Lampe blinken lassen wollen, können wir selbstverständlich nicht die
CPU-Frequenz verwenden da ja dann nichts mehr vom Blinken zu bemerken wäre.

Wir brauchen also eine Möglichkeit, die Taktfrequenz auf vernünftige Werte
herunter zu brechen. Selbstverständlich sollte die resultierende Frequenz dann
auch noch einigermassen genau und stabil sein.

Hier kommen die im AVR vorhandenen Timer/Counter zum Einsatz.

Ein anderes Anwendungsgebiet ist die Zählung von Signalen, welche über
einen I/O-Pin zugeführt werden können.

Die folgenden Ausführungen beziehen sich auch den AT90S2313. Für andere
Modelltypen müsst ihr euch die allenfalls notwendigen Anpassungen aus den
Datenblättern der entsprechenden Controller herauslesen.

Wir unterscheiden grundsätzlich zwischen 8-Bit Timern, welche eine
Auflösung von 256 aufweisen und 16-Bit Timern mit (logischerweise) einer
Auflösung von 65536.

Als Eingangstakt für die Timer/Counter kann entweder die CPU-Taktfrequenz,
der Vorteiler-Ausgang oder ein an einen I/O-Pin angelegtes Signal verwendet
werden. Wenn ein externes Signal verwendet wird, so darf dessen Frequenz nicht
höher sein als die Hälfte des CPU-Taktes.

=== Der Vorzähler (Prescaler) ===

Beide Timer/Counter werden im Timerbetrieb über den gleichen Vorzähler
versorgt.

Der Vorzähler dient dazu, den CPU-Takt vorerst mal runter zu brechen auf eine
wählbare Teilung. Die so geteilte Frequenz wird den Eingängen der Timer
zugeführt.

Wenn wir mit einer einem CPU-Takt von 4 MHz arbeiten und den Vorteiler auf 1024
einstellen wird also der Timer mit einer Frequenz von 4 MHz / 1024, also mit ca.
4 kHz versorgt. Wenn also der Timer läuft, so wird das Daten- bzw.
Zählregister mit dieser Frequenz inkrementiert.

== 8-Bit Timer/Counter ==

Alle AVR-Modelle weisen mindestens einen, teilweise sogar zwei, 8-Bit Timer
auf.

Der 8-Bit Timer wird über folgende Register angesprochen:

{| border="1"
|-
| '''TCCR0'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
Timer '''0'''

In diesem Register stellen wir ein, wie wir den Timer/Counter verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CS02'''
| align="center" | '''CS01'''
| align="center" | '''CS00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''CS02, CS01, CS00''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS02
| align="center" | CS01
| align="center" | CS00
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin '''TO''', fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin '''TO''', steigende Flanke
|}
</dd>
</dl>
:Wenn als Quelle der externe Pin '''TO''' verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin '''TO''' als Ausgang geschaltet ist.

|-
| '''TCNT0'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer '''0''' 
Dieses ist als 8-Bit Aufwärtszähler mit Schreib- und Lesezugriff
realisiert. Wenn der Zähler den Wert 255 erreicht hat beginnt er beim
nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}
|}

Um nun also den Timer0 in Betrieb zu setzen und ihn mit einer Frequenz von 1/1024-tel des CPU-Taktes zählen zu lassen, schreiben wir die folgende Befehlszeile:

<pre class="code">
TCCR0 = (1<<CS00)|(1<<CS02);
</pre>

Der Zähler zählt nun aufwärts bis 255, um dann wieder bei 0 zu beginnen. Der aktuelle Zählerstand steht in TCNT0. Bei jedem Überlauf von 255 auf 0 wird das Timer Overflow Flag '''TOV0''' im Timer Interrupt Flag '''TIFR'''-Register gesetzt und, falls so konfiguriert, ein entsprechender Timer-Overflow-Interrupt ausgelöst.

== 16-Bit Timer/Counter ==

Viele AVR-Modelle besitzen ausser den 8-Bit Timers auch einen oder sogar zwei
(einige ATmega-Modelle) 16-Bit Timer.

Die 16-Bit Timer/Counter sind wesentlich komplexer aufgebaut als die 8-Bit
Timer/Counter, bieten dafür aber auch viel mehr Möglichkeiten, als da sind:

* Die [[PWM]]-Betriebsart Erzeugung eines pulsweitenmodulierten Ausgangssignals.
* Vergleichswert-Überprüfung mit Erzeugung eines Ausgangssignals (Output Compare Match).
* Einfangen eines Eingangssignals mit Speicherung des aktuellen Zählerwertes (Input Capturing), mit zuschaltbarer Rauschunterdrückung (Noise Filtering).

Folgende Register sind dem Timer/Counter 1 zugeordnet:

{| border="1"
|-
| '''TCCR1A'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''A''' Timer '''1''' 
In diesem und dem folgenden Register stellen wir ein, wie wir den Timer/Counter verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''COM1A1''', '''COM1A0''' ('''Co'''mpare '''M'''atch Control Bits)
:Diese 2 Bits bestimmen die Aktion, welche am Output-Pin '''OC1''' ausgeführt werden soll, wenn der Wert des Datenregisters des Timer/Counter 1 den Wert des Vergleichsregisters erreicht, also ein so genannter Compare Match auftritt.
:Der Pin '''OC1''' ('''PB3''' beim 2313) muss mit dem Datenrichtungsregister als Ausgang konfiguriert werden.

<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Das Signal am Pin '''OC1''' wird invertiert (Toggle).
|-
| align="center" | 1
| align="center" | 0
| Der Output Pin '''OC1''' wird auf 0 gesetzt.
|-
| align="center" | 1
| align="center" | 1
| Der Output Pin '''OC1''' wird auf 1 gesetzt.
|}
</dd></dl>
:In der PWM-Betriebsart haben diese Bits eine andere Funktion.
<dl><dd>
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 1
| align="center" | 0
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 0 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 1 gesetzt.

Man nennt dies ''nicht invertierende PWM''.
|-
| align="center" | 1
| align="center" | 1
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht, so wird der Pin '''OC1''' auf 1 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht, so wird der Pin auf 0 gesetzt.

Man nennt dies ''invertierende PWM''.
|}
</dd></dl>

'''PWM11''', '''PWM10''' ('''PWM''' Mode Select Bits)
:Mit diesen 2 Bits wird die PWM-Betriebsart des Timer/Counter 1 gesteuert.
<dl><dd>
{| border="1"
|-
| align="center" | PWM11
| align="center" | PWM10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Die PWM-Betriebsart ist nicht aktiviert. Timer/Counter 1 arbeitet als normaler Timer bzw. Zähler.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM Betriebsart aktivieren.
|}
</dd></dl>
|-
| '''TCCR1B'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''B''' Timer '''1'''

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ICNC1'''
| align="center" | '''ICES1'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CTC1'''
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''ICNC1''' ('''I'''nput '''C'''apture '''N'''oise '''C'''anceler (4 CKs) Timer/Counter 1
:oder auf Deutsch Rauschunterdrückung des Eingangssignals.
:Wenn dieses Bit gesetzt ist und mit dem Input Capture Signal gearbeitet wird so werden nach der Triggerung des Signals mit der entsprechenden Flanke (steigend oder fallend) am Input Capture Pin '''ICP''' jeweils 4 Messungen mit der CPU-Frequenz des Eingangssignals abgefragt. Nur dann, wenn alle 4 Messungen den gleichen Zustand aufweisen gilt das Signal als erkannt.

'''ICES1''' ('''I'''nput '''C'''apture '''E'''dge '''S'''elect Timer/Counter '''1''')
:Mit diesem Bit wird bestimmt, ob die steigende ('''ICES1'''=1) oder fallende ('''ICES1'''=0) Flanke zur Auswertung des Input Capture Signals an Pin '''ICP''' heran gezogen wird.

'''CTC1''' ('''C'''lear '''T'''imer/'''C'''ounter on Compare Match Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, so wird nach einer Übereinstimmung des Datenregisters '''TCNT1H'''/'''TCNT1L''' mit dem Vergleichswert in '''OCR1H'''/'''OCR1L''' das Datenregister '''TCNT1H'''/'''TCNT1L''' auf 0 gesetzt.
:Da die Übereinstimmung im Takt nach dem Vergleich behandelt wird, ergibt sich je nach eingestelltem Vorzähler ein etwas anderes Zählverhalten:
:Wenn der Vorteiler auf 1 gestellt ist und C der jeweilige Zählerwert ist, dann nimmt das Datenregister, im CPU-Takt betrachtet, folgende Werte an:
:... | C-2 | C-1 | C | 0 | 1 |...
:Wenn der Vorteiler z.B. auf 8 eingestellt ist, dann nimmt das Datenregister folgende Werte an:
:... | C-2, C-2, C-2, C-2, C-2, C-2, C-2, C-2 | C-1, C-1, C-1, C-1, C-1, C-1, C-1, C-1 | C, 0, 0, 0, 0, 0, 0, 0 |...
:In der PWM-Betriebsart hat dieses Bit keine Funktion.

'''CS12''', '''CS11''', '''CS10''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS12
| align="center" | CS11
| align="center" | CS10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin TO, fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin T0, steigende Flanke
|}
</dd></dl>
:Wenn als Quelle der externe Pin T0 verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin T0 als Ausgang geschaltet ist.
|-
| '''TCNT1H''' '''TCNT1L'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer/Counter '''1'''
Dieses ist als 16-Bit Aufwärtszähler mit Schreib- und Lesezugriff realisiert. Wenn der Zähler den Wert 65535 erreicht hat, beginnt er beim nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''TCNT1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''TCNT1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

In der PWM-Betriebsart wird das Register als Auf/Ab-Zähler verwendet, d.h. der Wert steigt zuerst von 0 bis er den Überlauf von 65535 auf 0 erreicht hat. Dann zählt das Register rückwärts wiederum bis 0.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.

Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''OCR1H''' '''OCR1L'''
| Timer/Counter '''O'''utput '''C'''ompare '''R'''egister Timer/Counter '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''OCR1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''OCR1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Der Wert im Output Compare Register wird ständig mit dem aktuellen Wert im Datenregister TCNT1H/TCNT1L verglichen. Stimmen die beiden Werte überein, so wird ein sogenannter Output Compare Match ausgelöst. Die entsprechenden Aktionen werden über die Timer/Counter 1 Control und Status Register eingestellt.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll, müssen ebenfalls alle Interrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''ICR1H''' '''ICR1L'''
| Timer/Counter '''I'''nput '''C'''apture '''R'''egister Timer/Counter '''1''' 
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''ICR1''''''H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''ICR1''''''L'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Das Input Capture Register ist ein 16-Bit Register mit Lesezugriff. Es kann nicht beschrieben werden.

Wenn am Input Capture Pin '''ICP''' die gemäß Einstellungen im '''TCCR1B''' definierte Flanke erkannt wird, so wird der aktuelle Inhalt des Datenregisters '''TCNT1H'''/'''TCNT1L''' sofort in dieses Register kopiert und das Input Capture Flag '''ICF1''' im Timer Interrupt Flag Register '''TIFR''' gesetzt.

Wie bereits oben erwähnt, müssen vor dem Zugriff auf dieses Register alle Interrupts gesperrt werden. Zudem müssen Low- und Highbyte des Registers in der richtigen Reihenfolge bearbeitet werden:

{| border="0"
|-
| Lesen:
| '''ICR1L''' -> '''ICR1H'''
|-
| Schreiben:
| '''ICR1H''' -> '''ICR1L'''
|}
|}

=== Die PWM-Betriebsart ===

Wenn der Timer/Counter 1 in der PWM-Betriebsart betrieben wird, so bilden das Datenregister '''TCNT1H'''/'''TCNT1L''' und das Vergleichsregister '''OCR1H'''/'''OCR1L''' einen 8-, 9- oder 10-Bit, frei laufenden PWM-Modulator, welcher als PWM-Signal am '''OC1'''-Pin ('''PB3''' beim 2313) abgegriffen werden kann. Das Datenregister '''TCNT1H'''/'''TCNT1L''' wird dabei als Auf-/Ab-Zähler betrieben, welcher von 0 an aufwärts zählt bis zur Obergrenze und danach wieder zurück auf 0.
Die Obergrenze ergibt sich daraus, ob 8-, 9- oder 10-Bit PWM verwendet wird, und zwar gemäss folgender Tabelle:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Wenn nun der Zählerwert im Datenregister den in '''OCR1H'''/'''OCR1L''' gespeicherten Wert erreicht, wird der Ausgabepin '''OC1''' gesetzt bzw. gelöscht, je nach Einstellung von '''COM1A1''' und '''COM1A0''' im '''TCCR1A'''-Register.

Ich habe versucht, die entsprechenden Signale in der folgenden Grafik zusammenzufassen

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

=== Vergleichswert-Überprüfung ===

Hier wird in ein spezielles Vergleichswertregister ('''OCR1H'''/'''OCR1L''') ein Wert eingeschrieben, welcher ständig mit dem aktuellen Zählerwert verglichen wird.
Erreicht der Zähler den in diesem Register eingetragenen Wert, so kann ein Signal (0 oder 1) am Pin '''OC1''' erzeugt und/oder ein Interrupt ausgelöst werden.

=== Einfangen eines Eingangssignals (Input Capturing) ===

Bei dieser Betriebsart wird an den Input Capturing Pin (ICP) des Controllers eine Signalquelle angeschlossen.
Nun kann je nach Konfiguration entweder ein Signalwechsel von 0 nach 1 (steigende Flanke) oder von 1 nach 0 (fallende Flanke) erkannt werden und der zu diesem Zeitpunkt aktuelle Zählerstand in ein spezielles Register abgelegt werden. Gleichzeitig kann auch ein entsprechender Interrupt ausgelöst werden.
Wenn die Signalquelle ein starkes Rauschen beinhaltet, kann die Rauschunterdrückung eingeschaltet werden. Dann wird beim Erkennen der konfigurierten Flanke über 4 Taktzyklen das Signal überwacht und nur dann, wenn alle 4 Messungen gleich sind, wird die entsprechende Aktion ausgelöst.

== Gemeinsame Register ==

Verschiedene Register beinhalten Zustände und Einstellungen, welche sowohl
für den 8-Bit, als auch für den 16-Bit Timer/Counter in ein und demselben
Register zu finden sind.

{| border="1"
|-
| '''TIMSK'''
| '''T'''imer/Counter '''I'''nterrupt '''M'''a'''sk'''
Register

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOIE1'''
| align="center" | '''OCIE1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''TICIE'''
| align="center" | '''-'''
| align="center" | '''TOIE0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOIE1''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 1 ein Timer Overflow 1 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''OCIE1A''' ('''O'''utput '''C'''ompare Match '''I'''nterrupt '''E'''nable Timer/Counter '''1''')
:Beim Timer/Counter 1 kann zusätzlich zum Überlauf ein Vergleichswert definiert werden.

:Wenn dieses Bit gesetzt ist, wird beim Erreichen des Vergleichswertes ein Compare Match Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TICIE''' ('''T'''imer/Counter '''I'''nput '''C'''apture '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein Capture Event Interrupt ausgelöst, wenn ein entsprechendes Signalereignis am Pin PD6(ICP) auftritt. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein, wenn auch ein entsprechender Interrupt ausgelöst werden soll.

'''TOIE0''' ('''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable Timer/Counter '''0''')
:Wenn dieses Bit gesetzt ist, wird bei einem Überlauf des Datenregisters des Timer/Counter 0 ein Timer Overflow 0 Interrupt ausgelöst. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

|-
| '''TIFR'''
| '''T'''imer/Counter '''I'''nterrupt '''F'''lag '''R'''egister

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOV1'''
| align="center" | '''OCF1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''ICF1'''
| align="center" | '''-'''
| align="center" | '''TOV0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''TOV1''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''1''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 1 ein Überlauf des Datenregisters stattfindet.

:In der PWM-Betriebsart wird das Bit gesetzt, wenn die Zählrichtung von auf- zu abwärts und umgekehrt geändert wird (Zählerwert = 0).

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''OCF1A''' ('''O'''utput '''C'''ompare '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn der aktuelle Wert des Datenregisters von Timer/Counter 1 mit demjenigen im Vergleichsregister '''OCR1''' übereinstimmt.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''ICF1''' ('''I'''nput '''C'''apture '''F'''lag Timer/Counter '''1''')
:Dieses Bit wird gesetzt, wenn ein Capture-Ereignis aufgetreten ist, welches anzeigt, dass der Wert des Datenregisters des Timer/Counter 1 in das Input Capture Register ICR1 übertragen wurde.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.

'''TOV0''' ('''T'''imer/Counter '''O'''verflow Flag Timer/Counter '''0''')
:Dieses Bit wird vom Controller gesetzt, wenn beim Timer 0 ein Überlauf des Datenregisters stattfindet.

:Das Flag wird automatisch gelöscht, wenn der zugehörige Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 (!) in das entsprechende Bit geschrieben wird.
|}

 

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sogen. ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comperators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrups den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

{| border=1
| set_sleep_mode(uint8_t mode)
|Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z.B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
|-
| sleep_mode()
| Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus
|-
|}

<pre class="code">
#include <avr/io.h>
#include <avr/sleep.h>
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach auftreten eines entsprechenden "Aufwach-Interrupts" verarbeitet
...
</pre>

Vorsicht: Nicht alle AVR-Controller (v.a. nicht die "Brandneuen") werden von den avr-libc sleep-Funktionen richtig angesteuert. Bei nicht-untersützten Typen erreicht man die gewollte Funktionalität durch direkte "Bitmanipulation" der ensprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler:

<pre class="code">
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep");
...
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes

= Der Watchdog =

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der Watchdog.

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln. 
Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

Betrachten wir doch einmal folgende Codesequenz:

<pre class="code">
uint8_t x;

x = 10;

while (x >= 0) {
// tu was 
x--;
}
</pre>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm würde sich also hier aufhängen und auf ewig in der Schleife drehen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde beginnt der Counter von 0 an hochzuzählen. Wenn nun die je nach Vorteiler eingestellte Anzahl
Zyklen erreicht wurde löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern müssen wir den Watchdog regelmässig wieder neu starten bzw. Rücksetzen (Watchdog Reset). Dies sollte innerehalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern muss ein spezielles Prozedere verwendet werden um den WD auszuschalten und zwar müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden. Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| border="1"
|-
| '''WDTCR'''
| '''W'''atchog '''T'''imer  '''C'''ontrol '''R'''egister 
In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''WDTOE'''
| align="center" | '''WDE'''
| align="center" | '''WDP2'''
| align="center" | '''WDP1'''
| align="center" | '''WDP0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''WDTOE'''
| '''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable 
Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
Wenn das Bit einmal gesetzt ist wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.
|-
| '''WDE'''
| '''W'''atch'''d'''og '''E'''nable 
Wenn dieses Bit gesetzt wird so wird der Watchdog aktiviert.
Das Bit kann nur gelöscht werden solange das Bit '''WDTOE''' auf 1 steht.
|-
| '''WDP2''' '''WDP1''' '''WDP0'''
| '''W'''atch'''d'''og Timer '''P'''rescaler Bits 
Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:

{| border="1"
|-
| align="center" | WDP2
| align="center" | WDP1
| align="center" | WDP0
| align="center" | Anzahl Zyklen
| align="center" | Typ. Timeoutzeit bei Vcc = 3V
| align="center" | Typ. Timeoutzeit bei Vcc = 5V
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 16K
| align="center" | 47ms
| align="center" | 15ms
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 32K
| align="center" | 94ms
| align="center" | 30ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 64K
| align="center" | 0.19s
| align="center" | 60ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 128K
| align="center" | 0.38s
| align="center" | 0.12s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 256K
| align="center" | 0.75s
| align="center" | 0.24s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 512K
| align="center" | 1.5s
| align="center" | 0.49s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 1024K
| align="center" | 3s
| align="center" | 0.97s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 2048K
| align="center" | 6s
| align="center" | 1.9s
|}
|}
|}

Um den Watchdog mit dem AVR-GCC Compiler zu verwenden muss die Headerdatei wdt.h in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

{| border=1
| wdt_enable(uint8_t timeout)
|Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert (z.B. WDTO_30MS).
|-
| wdt_disable()
| Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
|-
| wdt_reset()
| Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.
|}

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Ein paar grundsätzliche Gedanken ==

Ob nun so ein Watchdog überhaupt verwendet werden soll ist wohl eher eine
philosophische Frage und hängt vom Geschmack jedes einzelnen Entwicklers ab.

Ich persönlich habe es lieber, wenn ich auch merke, dass in meine Programm
etwas noch nicht in Ordnung ist, als dass mir ein Watchdog einfach die CPU immer
wieder zurücksetzt, denn immerhin kann es so passieren, dass ein Programm über
Jahre hinweg so einigermassen läuft, obwohl noch ein voll krasser Bock drin
liegt.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Watchdog timer handling

= Programmieren mit Interrupts =

Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

[[Image:Interrupt Programme.gif]]

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

== Anforderungen an die Interrupt-Routine ==

Um unliebsamen Überraschungen vorzubeugen sollten einige Grundregeln bei
der Gestaltung der Interruptroutinen beachtet werden.

* Die Interruptroutine soll möglichst kurz und schnell abarbeitbar sein, daraus folgt:
* Keine unfangreichen Berechnungen innerhalb der Interruptroutine.
* Keine endlos langen Programmschleifen.
* Obschon es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen rate ich dringend von solchen Spielen ab.

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf dem AVR auslösen, wobei
die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

== Register ==

Der AT90S2313 verfügt über 2 Register welche mit den
Interrupts zusammen hängen.

{| border="1"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INT1'''
| align="center" | '''INT0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''INT1'''
| External '''Int'''errupt Request '''1''' Enable
Wenn dieses Bit gesetzt ist wird ein Interrupt ausgelöst wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.
|-
| '''INT0'''
| External '''Int'''errupt Request '''0''' Enable
Wenn dieses Bit gesetzt ist wird ein Interrupt ausgelöst wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.
|}
|}

{| border="1"
|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INTF1'''
| align="center" | '''INTF0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''INTF1'''
| External '''Int'''errupt Flag '''1'''
Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist wird die
Interruptroutine angesprungen.
Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist.
Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''INTF0'''
| External '''Int'''errupt Flag '''0''' 
Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist wird die
Interruptroutine angesprungen.
Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist.
Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|}
|}

{| border="1"
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister. 
Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''SE'''
| align="center" | '''SM'''
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''SE'''
| '''S'''leep '''E'''nable
Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl
in den Schlafzustand versetzen zu können.
Um den Schlafmodus nicht irrtümlich einzuschalten wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.
|-
| '''SM'''
| '''S'''leep '''M'''ode
Dieses Bit bestimmt der Schlafmodus.
Ist das Bit gelöscht so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")
|-
| '''ISC11''' '''ISC10'''
| '''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits
Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.

{| border="1"
|-
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt. 
In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}
|-
| '''ISC01''' '''ISC00'''
| '''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits
Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

{| border="1"
|-
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.
In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}
|}
|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft wird automatisch das '''Global
Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle
weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem
Zeitpunkt bereits wieder das GIE-bit zu setzen rate ich dringend davon ab. Dieses
wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn
in der Zwischenzeit weitere Interrupts eintreffen werden die zugehörigen
Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden
Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt
ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle
anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe,
weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.

=== Das Status-Register ===

Es gilt auch zu beachten, dass das Status-Register während der Abarbeitung
einer Interruptroutine nicht automatisch gesichert wird. Falls notwendig muss dies vom
Programmierer selber vorgesehen werden.

== Interrupts mit dem AVR GCC Compiler (WinAVR) ==

Selbstverständlich können alle Interruptspezifischen Registerzugriffe wie gewohnt über I/O-Adressierung vorgenommen werden. Etwas einfacher geht es jedoch, wenn wir die vom Compiler zur Verfügung gestellten Mittel einsetzen.

Damit diese Mittel zur Verfügung stehen müssen wir die Includedatei interrupt.h und evtl. signal.h einbinden mittels:

<pre class="code">
// fuer sei(), cli() und INTERRUPT():
#include <avr/interrupt.h>

// fuer SIGNAL() auch:
#include <avr/signal.h>
</pre>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird
nichts anderes gemacht als das '''Global Interrupt Enable''' Bit im Status
Register gesetzt.

<pre class="code">
sei();
</pre>

Das Makro '''cli()''' schaltet die Interrupts aus oder anders
gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird
gelöscht.
<pre class="code">
cli();
</pre>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf.
Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen.
Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren
und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen
Zustands die Interrups aktivieren, was zu unerwünschten Seiteneffekten führen kann.
Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern */

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD); // 2 mal in Folge , vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
...

}
</pre>



Nachdem nun die Interrupts aktiviert sind braucht es selbstverständlich noch den auszuführenden Code, der ablaufen soll wenn ein Interrupt eintrifft. Dazu gibt es zwei Definitionen: '''SIGNAL''' und '''INTERRUPT''', welche allerdings AVR-GCC spezifisch sind und bei anderen Compilern womöglich anders heissen können.

=== SIGNAL ===

<pre class="code">
#include <avr/signal.h>
...
SIGNAL (siglabel)
{
/* Interrupt Code */
}
</pre>

Mit ''SIGNAL'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektoren angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Vor Nutzung von SIGNAL muss die Header-Datei signal.h eingebunden werden. Mögliche Funktionsrümpfe für solche Interruptfunktionen sind zum Beispiel:

<pre class="code">
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

SIGNAL (SIG_OVERFLOW1)
{
/* Interrupt Code */
}

SIGNAL (SIG_UART_RECV)
{
/* Interrupt Code */
}

// und so weiter und so fort...
</pre>

Während der Ausführung des Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== INTERRUPT ===

<pre class="code">
#include <avr/interrupt.h>
...
INTERRUPT (signame)
{
/* Interrupt Code */
}
</pre>

Mit INTERRUPT wird genau gleich gearbeitet wie mit SIGNAL. Der Unterschied ist derjenige, dass bei INTERRUPT beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit automatisch wieder gesetzt und somit weitere Interrupts zugelassen werden. Dies kann zu nicht unerheblichen Problemen von im einfachsten Fall einem Stack overflow bis zu sonstigen unerwarteten Effekten führen und sollte wirklich '''nur dann''' angewendet werden, wenn man sich absolut sicher ist, das Ganze auch im Griff zu haben. Vor Nutzung von INTERRUPT muss die Header-Datei interrupt.h eingebunden werden.

Interruptroutinen (ISRs) sollten möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern den Zustand aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

siehe auch: Hinweise in [[AVR-GCC]]

== Datenaustausch mit Interrupt-Routinen ==

Variablen auf die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen wird und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte die Code-Optimierung "greifen" und der Wert der Variablen nur in Prozessorregistern zwischenspeichert werden, die "nichts von der Änderung woanders mitbekommen".

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z.B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt z.B. alle 10ms
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
// hier wird gKeyCounter veraendert, die uebrigen
// Programmteile muessen diese Aenderung "sehen"
// (volatile -> aktuellen Wert immer in den Speicher schreiben)
if ( !(KEY_PIN & (1<<KEY_PINNO)) )
if (gKeyCouter < CNTREPEAT) gKeyCounter++;
else gKeyCounter = 0;
}

...

int main(void)
{
...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
...
// hier wird auf gKeyCounter zugegriffen, dazu muss der in der
// ISR geschrieben Wert bekannt sein.
// (volatile -> aktuellen Wert immer aus dem Speicher lesen)
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt"
}
else {
/* hier: Code fuer "Taste kurz gedrueckt"
}
...
}
</pre>

Bei Variablen größer ein Byte muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes ausserhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<pre class="code">
...
volatile uint16_t gMyCounter16bit
...
SIGNAL(...)
{
...
gMyCounter16Bit++;
...
}

int main(void)
{
uint16_t tmpCnt;
...
// nicht gut: mglw. hier ein Fehler wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor Kopieren des zweiten Bytes
// ein Interrupt auftritt der den Inhalt von MyCounter veraendert
tmpCnt = gMyCounter16bit;

// besser: Aenderungen "ausserhalb" verhindern, alle "Teilbytes"
// bleiben konsistent
cli(); // Interupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren
...
}
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8 (Stand: avr-libc Vers. 1.0.4)

== Was macht das Hauptprogramm ==

Im einfachsten Fall gar nichts mehr. 
Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der
main-Funktion lediglich noch die Interrupts aktiviert und dann in eine
Endlosschleife folgender Art verzweigt:

<pre class="code">
...
for (;;) {}
...
</pre>

Normalerweise wird man allerdings in den Interruptroutinen die Interrupts
erfassen und im Hauptprogramm dann gemütlich auswerten.

Wie wir im bisherigen Kursverlauf gesehen haben ist es ohnehin mit so
schnellen Controller meistens gar nicht unbedingt notwendig mit
Interruptfunktionen zu arbeiten. 
Es ist allerdings auch zu bemerken, dass mit den Interruptroutinen ein Programm
sehr schön strukturiert werden kann, wenn man es richtig macht.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (eigentlich [[SRAM]]) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als [[FLASH]]-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z.B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin wenig Sinn macht und auch nur bei einigen RAM-losen Typen nach "Bastelarbeiten" möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory). Die Standard-Laufzeitbibliothek des avr-gcc, die [[avr-libc]], stellt diese Funktionen nach einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Einige Beispiele:

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray1 };
...
</pre>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<pre class="code">
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte...
}
</pre>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel jedoch mit der Funktion pgm_read_word.

<pre class="code">
uint16_t myWord;

myWord = pgm_read_word(&pgmFooWord);
</pre>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "gross". (Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.) Pointer müssen gegebenenfalls "gecastet" werden.

<pre class="code">
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray1

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray2
// da im zweiteb Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmPointerToArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</pre>

=== Floats und Structs lesen ===

Um komplexe Datentypen (structs), nicht-integer Datentypen (floats) aus dem Flash auszulesen, sind Hilfsfunktionen erforderlich. Einige Beispiele:

<pre class="code">

/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
...

/* liest float von Flash-Addresse addr und gibt diese als return-value zurueck */
inline float pgm_read_float(const float *addr)
{
union
{
uint16_t i[2]; // 2 16-bit-Worte
float f;
} u;

u.i[0]=pgm_read_word((PGM_P)addr);
u.i[1]=pgm_read_word((PGM_P)addr+2);

return u.f;
}
...

void egal(void)
{
int i;
float f;

for (i=0;i<3;i++) {
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach' was mit f
}
}
</pre>

TODO: Beispiele fuer structs und pointer aus flash auf struct im flash (menues, state-machines etc.)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuerht, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
...
</pre>

Aber Achtung: Ersetzt man zum Beispiel
<pre class="code">
const char textImFlash[] PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
durch
<pre class="code">
const char textImFlash* PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der textImFlash zu den Konstanten ans Ende des Programmcodes gelegt wird, von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte. Da der lesende Code trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein Bug des AVR-GCC (gesehen bei 3.4.1) zu sein.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<pre class="code">
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
...
</pre>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z.B. 0x01fe), "weiss" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, das der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000) wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z.B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmässig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, das vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgeben sind ("timed sequence"). Diese Prüfung wird nicht implizit durchgeführt. Im Zweifel kann man Sicherheitshalber bei EEPROM-Zugriffen die Interrupts global deaktivieren, z.B. so:

<pre class="code">
...
uint8_t sreg;
...

sreg = SREG;
cli();

/* hier die eeprom-Zugriffe */

SREG = sreg;
...
</pre>

Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Die Nutzung einer [[C-Präprozessor]]-Ersetzung bringt etwas Bequemlichkeit. Siehe dazu folgendes Beispiel.

<pre class="code">
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h>

// alle Textstellen EEPROM im Quellcode durch __attribute__ ... ersetzen
#define EEPROM __attribute__ ((section (".eeprom")))

...

/* Byte */
uint8_t eeFooByte EEPROM = 123;

/* Wort */
uint16_t eeFooWort EEPROM = 12345;

/* float */
float eeFooFloat EEPROM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEPROM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEPROM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */

uint16_t eeFooWordArray1[4] EEPROM;
...
</pre>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heisst eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<pre class="code">
...
uint8_t myByte;
uint8_t sreg;

sreg = SREG; // (1)
cli(); // (1)

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
...
SREG = sreg; // (1)
</pre>

Die mit (1) markierten Zeilen dienen hierbei dem (möglicherweise übertriebenen) Schutz vor Unterbrechnungen durch Interrupts.

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<pre class="code">
...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
...
</pre>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprueft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und mglw. noch mehr.

<pre class="code">
...
unit8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes aber der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnuetze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray[0],3);

/* dito mit etwas Absicherung betr. der Laenge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));

/* Datenlock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));
...
</pre>

"Nicht-Integer"-Datentypen wie z.B. Fliesskommazahlen lassen sich recht praktisch ueber eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<pre class="code">
...
float myFloat = 12.34;

union {
float r;
uint8_t n[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */
...
</pre>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<pre class="code">
...
typedef struct {
uint8_t label[8];
unin8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEPROM;

...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
...
}
...
</pre>

=== EEPROM-Speicherabbild in .eep-Datei ===

Eine besondere Funktion des avr-gcc ist, dass mit einem entsprechenden makefile aus den Initialisierungswerten der Variablen im Quellcode eine Datei erzeugt werden kann, die man auf den Controller programmieren kann (.eep-Datei). Damit können sehr elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Die Vorgehensweise wird aus dem WinAVR-Beispielmakefile ersichtlich. Siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles.

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Nicht alle neuen AVR Controller werden von avr-libc/eeprom.h untersützt (Stand Version 1.0.4). Insbesondere beim ATMega169 funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register) Etwas ältere Typen, oder zu den "etablierten" Controllern kompatible, bereiten jedoch hier keine Proleme. Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Der dort gezeigt Code kann direkt auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste").

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gcc-Toolchain" bietet dazu zwei Möglichkeiten:

;Inline-Assembler:
Die Assembleranweisungen werden in direkt in den C-Code integriert. Eine Quellcode-Datei enhält somit C- und Assembleranweisungen

;Assembler-Dateien:
Der Assembler-Codecode befindet sich in eigenen Quellcodedateien. Dieser werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z.B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen eine NOP-Anweisung. NOP steht für '''NO'''-O'''P'''eration. Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=warte)-Funktionen.

<pre class="code">
...
/* Verzoegern der weiteren Programmausfuehrung um
genau 3 Taktzyklen */
asm volatile ("nop"::);
asm volatile ("nop"::);
asm volatile ("nop"::);
...
</pre>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeindlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<pre class="code">
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i=0;i<1000;i++);

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i=0;i<1000;i++) asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j=0;j<1000;j++);
</pre>

Ein weiterer nützliche "Assembler-Einzeiler" ist der Auruf von sleep (''asm volatile ("sleep"::);''), da hierzu keine eigene Funktion in der avr-libc existiert.

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil des die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<pre class="code">
static inline void delayloop16(uint16_t count)
{
asm volatile ( "cp %A0,__zero_reg__ \n\t" \
"cpc %B0,__zero_reg__ \n\t" \
"breq L_Exit_%= \n\t" \
"L_LOOP_%=: \n\t" \
"sbiw %0,1 \n\t" \
"brne L_LOOP_%= \n\t" \
"L_Exit_%=: \n\t" \
: "=w" (count)
: "0" (count)
);
}
</pre>

* Jede Zeile wird mit '''\n\t''' abgeschlossen, alle Zeilen mit '''\''' verbunden.
* Sprung-Marken (labels) werden mit einm Prozentzeichen abgeschlossen, der Präprozessor (Assembler?) setzt an dieser Stelle eine laufende Nummer ein, die Doppelbezeichnungen bei mehrmaliger Verwendung somit verhindert.

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc.

* siehe auch: Dokumentation der avr-libc/Related Pages/Inline Asm
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

...TODO: Beispiele, Parameteruebergabe, globale Variablen für Datenaustausch

= TODO =

stdio.h, malloc() ???, Code-Optimierungen ("tricks"), "naked"-Functionen ??, IO-Register als Parameter/"Variablen" (volatile uint8_t *mybusport; mybusport=&PORTB; void sendbus(uint8_t *parm)...)

= C-Code und Bibliotheken für externe Baugrupen =
(TODO: sollte in avr-gcc verschoben werden)
[[Linksammlung#Avr]]

==LCD==
=== Text (character-mode) HD44870 ===
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray

=== Grafik-LCD ===
==== Nokia3310 ====
==== Nokia 6100 LCD ====
Das Nokia ist ein 132x132x4096 Farben Display das bei eBay ziemlich preiswert ersteigert werden kann.
[http://www.apetech.de/nokia6100.php Nokia 6100 LCD Library]
==== KS0108 ====
* Procyon avrlib (GPL)
* avrfreaks UP
* apetech.de
==Schnittstellen==
===I2C===
====Master====
[http://jump.to/fleury/ P. Fleurys I2C Master library]
====Slave====

===CAN===
* [http://www.atmel.com] Codesammlung zum AT90CAN128

=== DS18S20/1-Wire ===
* avrfreaks Projekt 59
* mikrocontroller.net/codesammlung (P. Dannegger)

=== UART ===
* Procyon avrlib (GPL)
* avrfreaks UP (viele viele)
* P. Fleury

== Speicherkarten/IDE/FAT ==
* avrfreaks UP (IDE/FAT read write)
== CRC ==
* avrfreaks-forum (O'Flynn)
* avr-hal (GPL)

AVR-GCC-Tutorial

2004-11-12T12:26:17Z

Oxygene: /* Die Register des ADC */

[[Category:AVR]]

= Vorwort =

Dieses Tutorial soll Einsteigern helfen, mit der Programmiersprache '''C''' die Mikrocontroller der Atmel AVR-Reihe zu programmieren.


Die ursprüngliche Version stammt von Christian Schifferle, die meisten aktuellen Anpassungen von [[Benutzer:Mthomas]]. Viele der im Original-Dokument verwendeten Funktionen sind in
aktuellen Versionen des avr-gcc C-Compilers und der avr-libc zwar noch enthalten,
aber als überholt (''deprecated'') ausgewiesen. D.h. diese Funktionen sollten nicht mehr verwendet
werden und existieren in zukünftigen Versionen des Compilers/der Library nicht mehr
(z.B. sbi(), cbi(), outp(), inp()). Der Artikel wurde auf die neuen Funktionen/Methoden
angepasst.

In diesem Text wird häufig auf die Standardbibliothek für den avr-gcc-Compiler, die avr-libc, verwiesen. Die '''Dokumentation der avr-libc''' findet sich
[http://www.nongnu.org/avr-libc/user-manual/index.html hier]. Bei WinAVR gehört diese Dokumentation zum Lieferumfang und wird mitinstalliert.

= Benötigte Werkzeuge =

Um die Übungen in diesem Tutorial nachvollziehen zu können benötigen wir folgende Hard- und Software:

* Testboard für die Aufnahme eines AVR Controllers, der vom gcc Compiler untersützt wird (alle ATmegas und die meisten AT90). Dieses Testboard kann durchaus auch selber zusammen gelötet werden. So arbeite ich mit einem Testboard, welches ich mir auf einer Veroboard-Platine zusammen gestellt habe. Für die Versuche bzw. Übungen in diesem Tutorial habe ich jeweils einen AT90S2313 verwendet. Eine brauchbare Testplattform ist auch der [[AVR Butterfly]].
* AVRGCC-Compiler. Kostenlos erhältlich für nahezu alle Plattformen/Betriebssysteme. Für MS-Windows im Packet [[WinAVR]]; für Unix/Linx siehe auch Hinweise im Artikel [[AVR-GCC]].
* Programmiersoftware und Hardware z.B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], [[AVR-Studio]]).
* Nicht unbedingt erforderlich aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Abschnitt Exkurs: makefiles).

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder die C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.
* Die [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/Frequently Asked Questions = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.
* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.
* Das gcc-Forum auf [http://www.mikrocontroller.net www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.
* Das avr-gcc-Forum bei [http://www.avrfreaks.net avrfreaks] nach vergleichbaren Problemen absuchen.
* Das [http://www.avr1.org/pipermail/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.
* Nach Beispielcode suchen. Vor allem in der Academy von [http://www.avrfreaks.net AVRFREAKS] (anmelden).
* Google oder alltheweb befragen schadet nie.
* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal)
* einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei mgl. viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode, genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z.B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: [http://www.lugbz.org/documents/smart-questions_de.html "Wie man Fragen stellt"].

= Exkurs: makefiles =

Wenn man bisher gewohnt ist, mit integrierten Entwicklungsumgebung à la Visual-C Programme zu erstellen, wirkt das makefile-Konzept auf den ersten Blick etwas kryptisch. Nach kurzer Einarbeitung ist diese Vorgehensweise jedoch sehr praktisch. Diese Dateien (üblicher Name: 'Makefile' ohne Dateiendung) dienen der Ablaufsteuerung des Programms make, das auf allen Unix/Linux-Systemen installiert sein sollte, und in einer Fassung fuer MS-Windows auch in [[WinAVR]] (Unterverzeichnis utils/bin) enthalten ist.

Im Unterverzeichnis ''sample'' einer WinAVR-Installation findet man eine sehr brauchbare Vorlage, die sich einfach an das eigene Projekt anpassen lässt ([[Media:Makefile|lokale Kopie Stand Sept. 2004]]). Wahlweise kann man auch [http://www.sax.de/~joerg/mfile/ mfile] von Jörg Wunsch nutzen. mfile erzeugt ein makefile nach Einstellungen in einer grafischen Nutzeroberfläche, wird bei WinAVR mitinstalliert, ist aber als TCL/TK-Programm auf nahezu allen Platformen lauffähig.

''Die folgenden Ausführungen beziehen sich auf das WinAVR Beispiel-Makefile.''

Ist im Makefile alles richtig eingestellt genügt es, sich drei Parameter zu merken, die über die shell bzw. die Windows-Kommandozeile (cmd.exe/command.exe) als Parameter an "make" übergeben werden. Das Programm make sucht sich "automatisch" das makefile im aktuellen Arbeitsverzeichnis und führt die darin definierten Operationen für den entsprechenden Aufrufparameter durch.

{| border=1
| ''make all''
| Erstellt aus den in im makefile angegebenen Quellcodes eine ''hex''-Datei (und ggf. auch ''eep''-Datei).
|-
| ''make program''
| Überträgt die hex-Datei (und wahlweise auch die eep-Datei für den EEPROM) zum AVR.
|-
| ''make clean''
| löscht alle temporären Dateien, also auch die hex-Datei
|}

Diese Aufrufe können in die allermeisten Editoren in "Tool-Menüs" eingebunden werden. Dies erspart den Kontakt mit der Kommandozeile. (Bei WinAVR sind die Aufrufe bereits im Tools-Menü des mitgelieferten Editors Programmers-Notepad eingefügt.)

Üblicherweise sind folgende Daten im makefile anzupassen:
* Controllertyp
* Quellcode-Dateien (c-Dateien)
* Typ und Anschluss des Programmiergeräts

seltener sind folgende Einstellungen durchzuführen:
* Grad der Optimierung
* Methode zur Erzeugung der Debug-Symbole (Debug-Format)
* Assembler-Quellcode-Dateien (S-Dateien)

Die in den folgenden Unterabschnitten gezeigten makefile-Ausschnitte sind für ein Programm, das auf einem ATmega8 ausgeführt werden soll. Der Quellcode besteht aus den c-Dateien superprog.c (darin main()), uart.c, lcd.c und 1wire.c. Im Quellcodeverzeichnis befinden sich diese Dateien: superprog.c, uart.h, uart.c, lcd.h, lcd.c, 1wire.h, 1wire.c und das makefile (die angepasste Kopie des WinAVR-Beispiels).

Der Controller wird mittels [[AVRDUDE]] über ein [[STK200]]-Programmierdongle an der Schnittstelle lpt1 (bzw. /dev/lp0) programmiert. Im Quellcode sind auch Daten für die ''section .eeprom'' definiert (siehe Abschnitt Speicherzugriffe TODO: nach unten verlinken), diese sollen beim Programmieren gleich mit ins EEPROM geschrieben werden.

== Controllertyp setzen ==

Dazu wird die "make-Variable" MCU entsprechend dem Namen des verwendenten Controllers gesetzt. Ein Liste der von avr-gcc und der avr-libc untersützten Typen findet sich in der [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc].

<pre class="code">
# Kommentare in Makefiles beginnen mit einem Doppelkreuz
...

# ATmega8 at work
MCU = atmega8
# oder MCU = atmega16
# oder MCU = at90s8535
# oder ...
...
</pre>

== Quellcode-Dateien einstellen ==

Den Namen der Quellcodedatei welche die Funktion main enthält, wird hinter TARGET eingetragen. Dies jedoch ohne die Endung ''.c''.

<pre class="code">
...
TARGET = superprog
...
</pre>

Besteht das Projekt wie im Beispiel aus mehr als einer Quellcodedatei, sind die weiteren c-Dateien (nicht die Header-Dateien, vgl. [[Include-Files (C)]]) durch Leerzeichen getrennt bei SRC einzutragen. Die bei TARGET definierte Datei ist schon in der SRC-Liste enthalten. Diesen Eintrag nicht löschen!

<pre class="code">
...
SRC = $(TARGET).c uart.c lcd.c 1wire.c
...
</pre>

Alternativ kann man die Liste der Quellcodedateien auch mit dem Operator += erweitern.

<pre class="code">
SRC = $(TARGET).c uart.c 1wire.c
# lcd-Code fuer Controller xyz123 (auskommentiert)
# SRC += lcd_xyz.c
# lcd-Code fuer "Standard-Controller" (genutzt)
SRC += lcd.c
</pre>

== Programmiergerät einstellen ==

Die Vorlagen sind auf die Programmiersoftware [[AVRDUDE]] angepasst, jedoch lässt sich auch andere Programmiersoftware einbinden, sofern diese über Kommandozeile gesteuert werden kann (z.B. stk500.exe, uisp, sp12).

<pre class="code">
...
# Einstellung fuer STK500 an com1 (auskommentiert)
# AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
# AVRDUDE_PORT = com1 # programmer connected to serial device

# Einstellung fuer STK200-Dongle an lpt1
AVRDUDE_PROGRAMMER = stk200
AVRDUDE_PORT = lpt1
...
</pre>

Sollen Flash(=.hex) und EEPROM(=.eep) zusammen auf den Controller programmiert werden, ist das Kommentarzeichen vor AVRDUDE_WRITE_EEPROM zu löschen.

<pre class="code">
...
#Auskommentiert: EERPOM-Inhalt wird nicht mitgeschrieben
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

#Nich-auskommentiert EERPOM-Inhalt wird mitgeschrieben
AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
...
</pre>

== Anwendung ==

Die Eingabe von ''make all'' im Arbeitsverzeichnis mit dem makefile und den Quellcodedateien erzeugt (unter anderem) die Dateien superprog.hex und superprog.eep. Abhängigkeiten zwischen den einzelnen c-Dateien werden dabei automatisch berücksichtigt. Die ''superprog.hex'' und ''superprog.eep'' werden mit ''make program'' zum Controller übertragen. Mit ''make clean'' werden alle temporären Dateien gelöscht (="aufgeräumt").

== Sonstige Einstellungen ==

=== Optimierungsgrad ===

Der gcc-Compiler kennt verschiedene Stufen der Optimierung. Nur zu Testzwecken sollte die Optimierung ganz deaktiviert werden (''OPT = 0''). Die weiteren möglichen Optionen weisen den Compiler an, möglichst kompakten oder möglichst schnellen Code zu erzeugen. In den weitaus meisten Fällen ist ''OPT = s'' die optimale (sic) Einstellung, damit wird kompakter und oft auch der "schnellste" Maschienencode erzeugt.

=== Debug-Format ===

Unterstützt werden die Formate stabs und dwarf-2. Das Format wir hinter ''DEBUG ='' eingestellt. Siehe dazu Abschnitt ''Eingabedateien zur Simulation''.

=== Assembler-Dateien ===

Die im Projekt genutzten Assembler-Dateien werden hinter ASRC durch Leerzeichen getrennt aufgelistet. Assembler-Dateien haben immer die Endung .S (grosses S). Ist zum Beispiel der Assembler-Quellcode eines Software-UARTs in einer Datei softuart.S enthalten lautet die Zeile: ''ASRC = softuart.S''

== Eingabedateien zur Simulation in AVR-Studio ==

Mit älteren AVR-Studio-Versionen kann man nur auf Grundlage sogenannter ''coff''-Dateien simulieren. Neuere Versionen von AVR-Studio (ab 4.10.356) unterstützen zudem das modernere aber noch experimentelle dwarf-2-Format, das ab WinAVR 20040722 (avr-gcc 3.4.1/Binutils inkl. Atmel add-ons) "direkt" vom Compiler erzeugt wird.

; Vorgehensweise bei extcoff:
* im Makefile bei DEBUG: <pre class="code">DEBUG=stabs</pre>
* ''make extcoff'' (evtl. vorher ''make clean'')
* die erzeugte ''cof''-Datei (im Beispiel oben ''superprog.cof'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

; Vorgehensweise bei dwarf-2:
* im Makefile bei DEBUG: <pre class="code">DEBUG=dwarf-2</pre>
* ''make all'' (evtl. vorher ''make clean'')
* die erzeugte ''elf''-Datei (im Beispiel oben ''superprog.elf'') in AVR-Studio laden
* AVR-Simulator und zu simulierenden Controller wählen, "Finish"
* weiteres siehe AVR-Studio Online-Hilfe

Beim Simulieren scheinen oft "Variablen zu fehlen". Ursache dafür ist, dass der Compiler die "Variablen" direkt Registern zuweist. Dies kann vermieden werden, indem die Optimierung abgeschaltet wird (im makefile). Man simuliert dann jedoch ein vom optimierten Code stark abweichendes Programm. Das Abschalten der Optimierung wird nicht empfohlen.

Statt des Software-Simulators kann das AVR-Studio auch genutzt werden, um mit dem ATMEL JTAGICE, ein Nachbau davon (BootICE, Evertool o.ä.) oder dem ATMEL JTAGICE MKII "im System" zu debuggen. Dazu sind keine speziellen Einstellungen im makefile erforderlich. Debugging bzw. "In-System-Emulation" mit dem JTAGICE und JTAGICE MKII sind in der AVR-Studio Online-Hilfe beschrieben.

= Definition einiger Datentypen =

Für die Programmierung von Mikrocontrollern ist es sinnvoll, dass wir uns
vorerst einige Datentypen definieren, welche den Zugriff auf die verschiedenen
Komponenten des Controllers vereinfachen oder wenigstens das Programm lesbarer
machen können.

<pre class="code">
typedef unsigned char BYTE;
typedef unsigned short WORD;
</pre>

== BYTE ==

Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 255.

== WORD ==

Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 65535.

== DWORD ==

Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

== QWORD ==

Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung
von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

Bei allen vorgenannten Datentypen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z.B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich daher, die im folgenden Abschnitt beschriebenen standardisierten Datentypen zu nutzen und damit "Missverständnissen" vorzubeugen, die z.B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

= Standardisierte Integer(Ganzzahl)-Typen =

Standardisierte Datentypen werden in der Header-Datei inttypes.h definiert.
Will man diese Typen benutzen, bindet man die "Definitionsdatei" wie folgt ein:

<pre class="code">
#include <inttypes.h>
</pre>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<pre class="code">
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef long int32_t;
typedef unsigned long uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
</pre>

Ein Vierfach-Wort (64Bit) entspricht beim AVR ''uint64_t'', ein Doppel-[[Word|Wort]] (32bit) entspricht ''uint32_t'', ein Wort (16bit) entspricht ''uint16_t'' und ein [[Byte]] (8bit) entspricht ''uint8_t''.
Die Typen ohne vorangestelltes ''u'' können auch vorzeichenbehaftete Zahlen speichern. ''int8_t'' geht also von -128 bis 127, ''uint8_t'' dagegen geht von 0 bis 255.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Integer Types

== '''Bitfelder''' ==

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bit breit ist. 
Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in einer einzelnen Bytevariable zusammen fassen und (fast) wie
8 einzelne Variablen ansprechen können. 
Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente
definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<pre class="code">
struct {
unsigned char bStatus_1:1; // 1 Bit für bStatus_1
unsigned char bStatus_2:1; // 1 Bit für bStatus_2
unsigned char bNochNBit:1; // Und hier noch mal ein Bit
unsigned char b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</pre>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<pre class="code">
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</pre>

(mt Empfehlung: Bitfelder sparen zwar Platz, verschlechtern aber unter
Umständen die Les- und Wartbarkeit des Codes. Anfängern wird geraten,
ein "ganzes" ein Byte (uint8_t) zu nutzen auch wenn nur ein Bitwert gespeichert
werden soll.)

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten
Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher
Dinge erledigt werden können, welche nicht zeitkritisch sind. 
Wenn ein Interrupt ausgelöst wird so wird automatisch die zugeordnete
Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Allgemeiner Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heisst, das Programm kann die
Inhalte der Register auslesen und beschreiben. 
Einige Register haben spezielle Funktionen, andere wiederum könne für
allgemeine Zwecke (Speichern von Datenwerten) verwendet werden.

Einzelne Register sind bei allen AVR's vorhanden, andere wiederum nur bei
bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff
auf den UART notwendig sind selbstverständlich nur bei denjenigen Modellen
vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden
AVR-Typen definiert. 

Wenn im Makefile der MCU-Typ definiert ist, wird vom System automatisch die
zum Typen passende Definitionsdatei genutzt, sobald man im Code die allgemeine
"io.h" Header-Datei einbinden.

<pre class="code">
#include <avr/io.h>
</pre>

Ist im Makefile der MCU Type z.B. mit dem Inhalt atmega8 definiert,
wird beim einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit
den Register-Definitionen für den ATmega8 eingelesen.



== I/O-Register ==

Die I/O-Register haben einen besonderen Stellenwert bei den AVR Controllern.
Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. 
Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir mal
die 8-Bit Register.


=== Lesen eines I/O-Registers ===



Zum Lesen kann man auf I/O Register einfach wie auf eine
Variable zugreifen. Die spezielle Funktion inp() ist nicht mehr
notwendig und veraltet.

Beispiel:

<pre class="code">
#include <avr/io.h>
uint8_t foo;
...
int main(void)
{
foo=PINB; /* kopiert den Status der Eingabepins an PortB in die Variable foo */
...
}
</pre>

==== Lesen eines Bits ====

Die AVR-Bibliothek stellt auch Funktionen zur Abfrage eines einzelnen Bits
eines Registers zur Verfügung:

;bit_is_set (<Register>,<Bitnummer>) : Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 4 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>) : Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen bit_is_clear bzw. bit_is_set sind nicht unbedingt erfoderlich, man kann auch "einfachen" C-Syntax verwenden. Der universell verwendbar ist. ''bit_is_set'' entspricht dabei z.B. (Variable & (1<<Bitnummer)). Das Ergebnis ist <>0 wenn das Bit gesetzt und 0 wenn nicht gesetzt ist.

* siehe auch [[Bitmanipulation]]

=== Schreiben eines I/O-Registers ===



Zum Schreiben kann man I/O Register einfach wie eine
Variable setzen. Die spezielle Funktion outp() ist nicht mehr
notwendig, veraltet und sollte nicht mehr genutzt werden.

Beispiel:

<pre class="code">
#include <avr/io.h>
...
int main(void)
{
DDRA=0xff; /* Setzt das Richtungsregister des Ports A auf 0xff (alle Pins als Ausgang) */
PORTA=0x03; /* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low" */
...
}
</pre>

==== Schreiben eines Bits ====



Einzelne Bits setzt man "Standard-C-Konform" mittels logischen (bit-) Operationen.

mit dem Ausduck |=(1<<Bitnummer) wird ein Bit gesetzt, mit dem Ausdruck
&=~(1<<Bitnummer) wird ein Bit geloescht. Die Funktionen sbi und cbi sind
dazu nicht notwendig, veraltet und sollten nicht mehr genutzt werden.

Beispiel:
<pre class="code">
...
#define MEINBIT 2
...
PORTA |= (1<<MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1<<MEINBIT); /* loescht Bit 2 an PortA */
</pre>

* siehe auch:
** [[Bitmanipulation]]
** [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

=== Warten auf einen bestimmten Zustand ===

Es gibt in der Bibliothek sogar Funktionen, die Warten, bis ein bestimmter
Zustand auf einem Bit erreicht ist. 
Es ist allerdings normalerweise eine eher unschöne Programmiertechnik.

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das
definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits
gesetzt ist wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT 2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1<<WARTEBIT)) ) ;
</pre>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das
definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits
gelöscht ist wird die Funktion sofort wieder verlassen. 
Das niederwertigste Bit hat die Bitnummer 0.

<pre class="code">
/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT 4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe (die leere) Schleife solange das WARTEBIT in Register WARTEPIN
// ungleich 0 ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
</pre>

Universeller und auch auf andere Platformen besser übertragbar ist die Verwendung von C-Standardoperationen.

siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]



= Zugriff auf Ports =

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind
jedem Port 3 Register zugeordnet:

{| border="1"
|-
| '''DDRx'''
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (anhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
| '''PORTx'''
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Wird ein Port als Eingang geschaltet, so können mit diesem Register
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|-
| '''PINx'''
| Eingangadresse für Port'''x'''.

Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der Portspins. Bit gesetzt (1) wenn Pin "high/an", Bit gelöscht (0) wenn Portpin "low/aus".
|}

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.


Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Wollen wir also beispielsweise Pin 0 bis 4 von Port B als Ausgänge
definieren so schreiben wir folgende Zeile:


<pre class="code">
#include <avr/io.h>
...
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F

DDRB=0x1F; /* direkte Zuweisung - unuebersichtlich */
/* mehr Tipparbeit aber uebersichtlicher: */
DDRB=(1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3)|(1<<DDB4);
...
</pre>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet.

=== Ganze Ports ===

Um einen ganzen Port als Ausgang zu definieren, kann der folgende Befehl
verwendet werden:

<pre class="code">
DDRB=0xff;
</pre>

Im Beispiel wird der Port B als Ganzes als Ausgang geschaltet.

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen
bzw. auszugeben.

== Ausgänge ==

Wir wollen nun einen als Ausgang definierten Pin auf Logisch 1 setzen. Dazu schreiben wir den entsprechenden Wert in das Portregister des entsprechenden Ports.

Mit dem Befehl

<pre class="code">
PORTB=0x04; /* besser PORTB=(1<<DDB2) */
</pre>

wird also der Ausgang an Pin 2 gesetzt (Beachte, dass die Bits immer ''von 0 an''
gezählt werden, das niederwertigste Bit ist also Bit 0 und nicht etwa Bit 1).

Man beachte bitte, dass bei der Zuweisung mittels '''='''  immer alle Pins gleichzeitig angegeben werden. Man sollte also zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfliessen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an PortB auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<pre class="code">
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<DDB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<DDB2)
</pre>


Die Funktionen cbi und sbi sind dazu nicht notwendig, veraltet und sollten
nicht mehr genutzt werden.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wird den Pegel über entsprechende Hardware (z.B. Optokoppler, Spannunsteiler "Levelshifter") anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unserer Controllers eine logische 1 (Vcc) oder eine logische 0 (Masse) anliegt.

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.



Wobei es hier sehr wichtig ist, zur Abfrage der Eingänge nicht etwa das Portregister '''PORTx''' zu verwenden, sondern die Porteingangsadresse '''PINx'''. Dies ist
ein oft gemachter Fehler!

Wollen wir also die aktuellen Signalzustände von Port D abfragen und in einer
Variable namens bPortD abspeichern so schreiben wir dazu folgende Befehlszeile:

<pre class="code">
#include <avr/io.h>
...
bPortD = PIND;
...
</pre>


=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen (''Active Low'' und ''Active High''):

{| border="1"
|-
| '''Active Low'''
| '''Active High'''
|-
| [[Image:Active Low.gif]]
| [[Image:Active High.gif]]
|-
| Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet.

Damit bei offenem Schalter der Controller kein undefiniertes Signal
bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein
sogenannter Pull-Up Widerstand geschaltet. Dieser dient dazu, den Pegel
bei geöffnetem Schalter auf logisch 1 zu ziehen. 
Der Widerstandswert des Pull-Up Widerstands ist an sich nicht kritisch. Es
muss jedoch beachtet werden, dass über den Widerstand ein Strom in den
Eingang fliesst, also sollte er nicht zu klein gewählt werden um den
Controller nicht zu zerstören. Wird er allerdings zu hoch gewählt ist
die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10
Kiloohm eingebürgert.

Die AVR's haben sogar an den meisten Pins softwaremässig zuschaltbare
interne Pull-Up Widerstände, welche wir natürlich auch verwenden
können.
| Hier wird der Kontakt zwischen die Versorgungsspannung und Masse geschaltet.

Damit bei offener Schalterstellung kein undefiniertes Signal am Controller
ansteht, wird zwischen den Eingangspin und die Masse ein Pull-Down
Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter
Schalterstellung auf logisch 0 zu halten.
|}

==== Pull-Up Widerstände aktivieren ====

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden
über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang'''
geschaltet ist. 

Wird der Wert des entsprechenden Portpins auf 1 gesetzt so ist
der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up
Widerstand nicht aktiv. 
Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand
verwenden, aber nicht beide zusammen.



<pre class="code">
#include <avr/io.h>
...
DDRD=0x00; /* alle Pins von Port D als Eingang */
PORTD=0xff: /* interer Pull-Up an allen Port-Pins aktivieren */
...
</pre>

Im Beispiel wird der gesamte Port D als Eingang geschaltet und alle Pull-Up
Widerstände aktiviert.

===== Tastenentprellung =====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von
Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim
Schliessen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern
mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes. 
Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein
solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen
als mehrfache Impulse gezählt wird. 
Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen
werden.

ToDo Bsp Quellcode

== Analog ==

Leider können wir mit unseren Controllern keine analogen Werte direkt
ausgeben oder einlesen. Dazu müssen wir Umwege gehen, doch dies wird in einem späteren
Kapitel behandelt.

=== 16-Bit Portregister (ADC, ICR1, OCR1, TCNT1) ===

Einige der Portregister in den AVR-Controllern sind 16 Bit breit, Man spricht
dann von einem '''Wort'''.


Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<pre class="code">
#include <avr/io.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8

= Der UART, Teil 1 =

Wir werden in zukünftigen Übungen in die Situation kommen, dass wir
Informationen vom Controller auswerten bzw. anzeigen müssen wobei es vielleicht
dann nicht mehr reicht, ein paar Leuchtdioden anzusteuern. 
Somit brauchen wir eine Verbindung vom AVR zu unserem PC, und dies am besten
über die serielle Schnittstelle.

== Allgemeines zum UART ==

Einige AVR-Controller haben einen vollduplexfähigen UART ('''U'''niversal
'''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut.
Dies ist eine wirklich feine Sache, haben wir doch damit schon das nötige
Werkzeug, um mit anderen Geräten, welche über eine serielle Schnittstelle
verfügen (insbesondere mit unserem PC), zu kommunizieren.

Übrigens: Vollduplex heisst nichts anderes, als dass der Baustein gleichzeitig
senden und empfangen kann.

Neuere AVRs (ATmega) verfügen über einen oder zwei U'''S'''ART(s), dieser unterschiedet sich vom UART häuptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

Der UART wird über vier separate Register angesprochen. USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurations/Datenregister. Das Datenblatt gibt darüber Auskunft. Die Folgende Tabelle gibt nur die Register für die (veralteten) UARTs wieder.

{| border="1"
|-
| '''UCR   '''
| '''U'''ART '''C'''ontrol '''R'''egister. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXCIE'''
| align="center" | '''TXCIE'''
| align="center" | '''UDRIE'''
| align="center" | '''RXEN'''
| align="center" | '''TXEN'''
| align="center" | '''CHR9'''
| align="center" | '''RXB8'''
| align="center" | '''TXB8'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''CHR9''' (9 Bit Characters)
:Wenn dieses Bit gesetzt ist, können 9 Bit lange Zeichen übertragen und empfangen werden. Das 9. Bit kann bei Bedarf als zusätzliches Stopbit oder als Paritätsbit verwendet werden. Man spricht dann von einem 11-Bit Zeichenrahmen:
:1 Startbit + 8 Datenbits + 1 Stopbit + 1 Paritätsbit = 11 Bits

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.

|-
| '''USR   '''
| '''U'''ART '''S'''tatus '''R'''egister. 
Hier teilt uns der UART mit, was er gerade so macht.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''RXC'''
| align="center" | '''TXC'''
| align="center" | '''UDRE'''
| align="center" | '''FE'''
| align="center" | '''OR'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt bevor ein weiteres Zeichen komplett empfangen wurde wird eine Überlauf-Fehlersituation eintreffen. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, wenn die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit wird vom AVR gesetzt, wenn ein Zeichen vom Sendedatenregister in das Send-Schieberegister übernommen wurde und der UART nun wieder bereit ist, ein neues Zeichen zum Senden aufzunehmen.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''OR''' ('''O'''ver'''R'''un) 
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne
kommunizieren möchten. Der Wert, der in dieses Register geschrieben
werden muss, errechnet sich nach folgender Formel:

<math>
\begin{matrix}
UBBR = \frac{Taktfrequenz}{Baudrate * 16} - 1
\end{matrix}
</math>

Es sind Baudraten bis zu 115200 Baud und höher möglich.
|}

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (LOW) und 5V (HIGH). Die
Schnittstellenspezifikation für RS232 definiert jedoch -3V ... -12V (LOW) und
+3 ... +12V (HIGH). Zudem muss der Signalaustausch zwischen AVR und
Partnergerät invertiert werden. Für die Anpassung der Pegel und das
Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste
davon ist wohl der MAX232. Allerdings kostet der auch wieder Geld und benötigt
zusätzlich immerhin 4 externe Elkos.

Die in den PC eingebauten Schnittstellen vertragen ohne Klagen auch den
TTL-Pegel vom AVR. Allerdings müssen wir immer noch die Signale invertieren. Im
einfachtesn Fall verwenden wir dazu jeweils einen einfachen NPN-Transistor und 2
Widerstände. Näheres dazu erfahrt ihr in den folgenden Übungen.

Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z.B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfielt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Senden mit dem UART ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. 
Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach
gewünschter Funktionsweise die
benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister. 
Da wir vorerst nur senden möchten und (noch) keine Interrupts auswerten wollen,
gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das
'''Transmitter Enable''' Bit setzen müssen:


<pre class="code">
UCR |= (1<<TXEN);
</pre>

Der Atmega16 hat mehrere Konfigurationsregister für USART und erfordert eine etwas andere Konfiguration

<pre class="code">
UCSRB |= (1<<TXEN); //UART TX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1
</pre>

Nun müssen wir noch die Baudrate festlegen. Gemäß unserer Formel brauchen
wir dazu die Taktfrequenz des angeschlossenen Oszillators bzw. Quarz in die
Formel einzufügen und das Resultat der Berechnung in das Baudratenregister des
UART einzuschreiben:

<pre class="code">
/* UART-Init beim AT90S2313 */
#define F_CPU 4000000; // Zum Beispiel 4Mhz-Quarz
#define UART_BAUD_RATE 9600 // Wir versuchen mal mit 9600 Baud
UBRR = F_CPU / (UART_BAUD_RATE * 16L) - 1;
</pre>

Wieder für den Mega16 mit einem 16bit-Register eine andere Programmierung

<pre class="code">
/* USART-Init beim ATmegaXX */
#define F_OSC 3686400 /* Oszillator-Frequenz in Hz */
#define UART_BAUD_RATE 9600
#define UART_BAUD_CALC(UART_BAUD_RATE,F_OSC) ((F_OSC)/((UART_BAUD_RATE)*16l)-1)

UBRRH=(uint8_t)(UART_BAUD_CALC(UART_BAUD_RATE,F_OSC)>>8);
UBRRL=(uint8_t)UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);

/* alternativ bei der avr-libc "direkt 16bit" : */
UBRR=UART_BAUD_CALC(UART_BAUD_RATE,F_OSC);
</pre>

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben.

<pre class="code">
while (USR & (1<<UDRE)); /* warten bis Senden moeglich */
UDR = 'x'; // Schreibt das Zeichen x auf die Schnittstelle
</pre>

=== Schreiben einer Zeichenkette (String) ===

Es ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

Zu diesem Zweck können wir uns für's Erste eine einfache Funktion basteln:

<pre class="code">
void SendeString (char *szBuf)
{
while (*szBuf) {
loop_until_bit_is_set (USR, UDRE); /* warten bis Senden moeglich */
UDR=*szBuf;
szBuf++;
}
}
</pre>

Warteschleifen sind insofern etwas kritisch, da während des Sendens eines
Strings nicht mehr auf andere Ereignisse reagieren werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. emfangenen Zeichen/Bytes zwischengespeichert und mittels Interruptroutinen an den U(S)ART weitergebgen bzw. ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

* siehe auch: Weiterführende Informationen inkl. Beispielen für die Nutzung von stdio-Funktionen (prinf etc.) im [[AVR-Tutorial - UART]].
* [http://homepage.sunrise.ch/mysunrise/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc

= Analoge Ein- und Ausgabe =

Leider können wir mit unseren Controllern keine analogen Werte direkt
verarbeiten. Dazu bedarf es jeweils einer Umwandlung des analogen Signals in
einen digitalen Zahlenwert. Je nachdem, ob wir Daten einlesen oder ausgeben
wollen reden wir dabei von '''ADC''' oder '''DAC'''.

== ADC (Analog Digital Converter) ==

Der '''ADC''' wandelt analoge Signale in digitale Werte um, welche vom Controller
interpretiert werden können. Einige AVR-Typen haben bereits einen oder mehrere
solcher '''ADC''''s eingebaut, bei den kleineren AVR's müssen wir uns anders aus der
Affäre ziehen. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst
werden kann, wird durch die Auflösung des '''ADC''' in Anzahl Bits angegeben, man
hört bzw. liest jeweils von 8-Bit '''ADC''' oder 10-Bit ''' ADC''' oder noch höher. 
Ein '''ADC''' mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit
von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten
eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

<div align="center"><center>

{| border="1"
|-
| align="center" | '''Eingangsspannung am ADC'''
| align="center" | '''Entsprechender Messwert'''
|-
| align="center" | 0...<0.625V
| align="center" | 0
|-
| align="center" | 0.625...<1.25V
| align="center" | 1
|-
| align="center" | 1.25...<1.875V
| align="center" | 2
|-
| align="center" | 1.875...<2.5V
| align="center" | 3
|-
| align="center" | 2.5...<3.125V
| align="center" | 4
|-
| align="center" | 3.125...<3.75V
| align="center" | 5
|-
| align="center" | 3.75...<4.375V
| align="center" | 6
|-
| align="center" | 4.375...5V
| align="center" | 7
|}

</center>
</div>

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des '''
ADC''' ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Messen eines Widerstandes ===

Wir wollen hier einmal die wohl einfachste Methode zur Erfassung eines
analogen Wertes realisieren und zwar das Messen eines veränderlichen
Widerstandes wie z.B. eines Potentiometers.

Man stelle sich vor, wir schalten einen Kondensator in Reihe zu einem
Widerstand zwischen die Versorgungsspannung und Masse und dazwischen nehmen wir
das Signal ab und führen es auf einen der Pins an unserem Controller, genau so
wie es in folgender Grafik dargestellt ist.

[[Image:Poti.gif]]

Wenn wir nun den Pin des AVR als Ausgang schalten und auf
Logisch 1 (HIGH) legen, dann liegt an beiden Platten des Kondensators ''' Vcc''' an und
dieser wird entladen (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen). 
Nachdem nun der Kondensator genügend entladen ist schalten wir einfach den Pin
als Eingang wodurch dieser hochohmig wird. Der Kondensator lädt sich jetzt
über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und
derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti
unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), dann schaltet der
Eingang von HIGH auf LOW um. Wenn wir nun messen (zählen), wie lange es dauert,
bis der Kondensator so weit geladen ist, dann haben wir einen ungefähren Wert
der Potentiometerstellung. 
Der 220 Ohm Widerstand dient dem Schutz des Controllers. Wenn nämlich sonst die
Potentiometerstellung auf Maximum steht (0 Ohm), dann würde in den Eingang des
Controllers ein viel zu hoher Strom fliessen und der AVR würde in Rauch
aufgehen.

Dies ist meines Wissens die einzige Schaltung zur Erfassung von
Analogwerten, welche mit nur einem einzigen Pin auskommt. 
Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine
Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B:
0...100 % oder so) umzurechnen.

Wer Lust hat, sich selber mal an ein solches Programm
heranzuwagen, der sollte das jetzt tun. Für diejenigen, die es gern schnell
mögen, hier das Beispielprogramm, welches den UART-Printf aus den
vorangegangenen Kapiteln benötigt, inkl. Makefile:

{| border="0"
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Poti.c Poti.c ]
| Hauptprogramm.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.c Pot.c]
| Separate Routine zur Ermittlung des Messwertes.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/Pot.h Pot.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.c UartPrintF.c]
| Für die Debugausgabe auf den UART.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Allgemein/UartPrintF.h UartPrintF.h]
| Zugehörige Headerdatei.
|-
| [http://www.mypage.bluewin.ch/ch_schifferle/AtmelC/Uebungen/Poti/makefile Makefile]
| Makefile.
|}

Nachdem das Programm auf den AVR geladen wurde, muss dieser
kalibriert werden. Dazu wird der Kalibrierungsschalter geschlossen und das Poti
einige Male zwischen minimaler und maximaler Stellung hin und her gedreht. Dabei
werden die jeweiligen Maximalwerte bestimmt. Wenn der Kalibrierschalter wieder
geöffnet wird werden die Kalibrierungsdaten in's EEPROM des AVR geschrieben,
damit die Prozedur nicht nach jedem Reset wiederholt werden muss.

Auf Pin 4 habe ich noch ein Triggersignal gelegt, welches auf
HIGH geht wenn die Messung beginnt und auf LOW, wenn der Messvorgang beendet
wird. Mit Hilfe dieses Signals kann der Vorgang wunderschön auf einem
Oszillographen dargestellt werden.

=== ADC über Komparator ===

Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

[[Image:ADC ueber Komparator.gif]]

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert. 
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

=== Der ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem '''ADC-Wandler''' zurückgreifen. Wir wollen hier einmal den AT90S8535 besprechen, welcher über 8 ADC-Kanäle verfügt. (TODO: nur ein Wandler, Mulitiplexbetrieb, nur eine Pin zur gleichen Zeit)

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung.

Verfügt der AVR über eine interne Referenzspannung (Datenblatt typisch 2,56 oder 1,1V je nach AVR), bleibt der ''Anschluss AREF'' unbeschaltet und man stellt die ADC-Register so ein, dass die interne Referenzspannung als "AREF" genutzt wird. Ansonsten ist eine externe Referenzspannung von maximal '''Vcc''' an den Abschluss '''AREF''' anzulegen. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden.

==== Einfache Wandlung (Single Conversion) ====

In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestossen für jeweils eine Messung.

==== Frei laufend (Free Running) ====

In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register, welche hier aufgelistet werden.

{| border="1"
|-
| '''ADCSR   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ADEN'''
| align="center" | '''ADSC'''
| align="center" | '''ADFR'''
| align="center" | '''ADIF'''
| align="center" | '''ADIE'''
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt, ist können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''Fr'''ee Running Select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Eine logische 1 aktiviert den frei laufenden Modus. Der ''' ADC''' misst nun ständig den ausgewählten Kanal und schreibt den gemessenen Wert in das '''ADC Data Register'''.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, wenn eine Umwandlung erfolgt und das '''ADC Data Register''' aktualisiert ist.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird (So steht es in der AVR-Dokumentation).

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200kHz}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50kHz}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.
<dl><dd>
{| style="" border="1"
|-
| align="center" | '''ADPS2'''
| align="center" | '''ADPS1'''
| align="center" | '''ADPS0'''
| align="center" | '''Teilungsfaktor'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 2
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 2
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 4
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 8
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 16
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 32
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 64
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 128
|}
</dd></dl>
|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<pre class="code">
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
C-Operatorprioritaet sichergestellt)
</pre>

oder

<pre class="code">
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</pre>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''MUX2'''
| align="center" | '''MUX1'''
| align="center" | '''MUX0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''MUX2...MUX0'''
:Mit diesem 3 Bits wird der zu messende Kanal bestimmt. Es wird einfach die entsprechende Pinnummer des Ports eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Meine Empfehlung ist deswegen klar diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Aktivieren des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register
setzen. Im gleichen Schritt legen wir auch gleich die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls mit Spannungsteiler konditionieren. Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1024 für V_ref-Volt.

<pre class="code">

#define CHANNELOFFSET 4

uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result;

ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler setzen auf 8 (1)
ADCSRA |= (1<<ADEN); // ADC aktivieren (1)

ADMUX = CHANNELOFFSET+channel; // Kanal waehlen
ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)

result = 0;

/* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */
for(i=0;i<4;i++)
{
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while(!(ADCSRA & (1<<ADIF))); // auf Abschluss der Konvertierung warten (ADIF-bit)
result += ADC; // Wandlungsergebnisse aufaddieren
}

ADCSRA &= ~(1<<ADEN); // ADC deaktivieren (2)

result >>= 2; // Summe durch vier teilen = arithm. Mittelwert

return result;
}
</pre>

Im Beispiel wird bei jedem Aufruf der ADC aktiviert und nach der Wandlung wieder abgeschaltet, das spart Strom. Will man dies nicht, verschiebt man die mit (1) gekenntzeichneten Zeilen in eine Funktion adc_init() o.ä. und löscht die mit (2) markierten Zeilen.



== DAC (Digital Analog Converter) ==

Mit Hilfe eines ''' DAC''' können wir nun auch Analogsignale ausgeben. Es gibt hier
mehrere Verfahren. Wenn wir beim ''' ADC''' die Möglichkeit haben, mit externen
Komponenten zu operieren, müssen wir bei der '''DAC'''-Wandlung mit dem auskommen, was
der Controller selber zu bieten hat.

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie ''' PWM''' eigentlich funktioniert.

Wie wir alle wissen ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber
wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. 
Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen
HIGH und LOW umschalten? 
Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen geometrischen Mittelwert, der je nach Pulsbreite
kleiner oder grösser ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein
RC-Glied filtern dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVR's können wir direkt '''PWM'''-Signale erzeugen. Dazu
dient der 16-Bit Zähler, welcher im sogenannten '''PWM'''-Modus betrieben werden
kann.

Hinweis:
:In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist allerdings bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt.

Um den '''PWM'''-Modus zu aktivieren müssen im Timer/Counter1 Control
Register A '''TCCR1A''' die Pulsweiten-Modulatorbits '''PWM10''' bzw. '''PWM11''' entsprechend
nachfolgender Tabelle gesetzt werden:

{| border="1"
|-
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| PWM-Modus des Timers ist nicht aktiv.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM.
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben. Die
Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| border="1"
|-
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden heisst dann:

<pre class="code">
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</pre>

Damit der Timer/Counter überhaupt läuft müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorzähler) einstellen, und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| border="1"
|-
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<pre class="code">
TCCR1B = (1<<CS12) | (1<<CS10);
</pre>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<pre class="code">
OCR1A = xxx;
</pre>

Die folgende Grafik soll den Zusammenhang zwischen dem
Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren.

= Die Timer/Counter des AVR =

Die heutigen Mikrocontroller und insbesondere die RISC-AVR's sind für viele
Steuerungsaufgaben natürlich viel zu schnell. Wenn wir beispielsweise eine LED
oder Lampe blinken lassen wollen, können wir selbstverständlich nicht die
CPU-Frequenz verwenden da ja dann nichts mehr vom Blinken zu bemerken wäre.

Wir brauchen also eine Möglichkeit, die Taktfrequenz auf vernünftige Werte
herunter zu brechen. Selbstverständlich sollte die resultierende Frequenz dann
auch noch einigermassen genau und stabil sein.

Hier kommen die im AVR vorhandenen Timer/Counter zum Einsatz.

Ein anderes Anwendungsgebiet ist die Zählung von Signalen, welche über
einen I/O-Pin zugeführt werden können.

Die folgenden Ausführungen beziehen sich auch den AT90S2313. Für andere
Modelltypen müsst ihr euch die allenfalls notwendigen Anpassungen aus den
Datenblättern der entsprechenden Controller herauslesen.

Wir unterscheiden grundsätzlich zwischen 8-Bit Timern, welche eine
Auflösung von 256 aufweisen und 16-Bit Timern mit (logischerweise) einer
Auflösung von 65536.

Als Eingangstakt für die Timer/Counter kann entweder die CPU-Taktfrequenz,
der Vorteiler-Ausgang oder ein an einen I/O-Pin angelegtes Signal verwendet
werden. Wenn ein externes Signal verwendet wird, so darf dessen Frequenz nicht
höher sein als die Hälfte des CPU-Taktes.

=== Der Vorzähler (Prescaler) ===

Beide Timer/Counter werden im Timerbetrieb über den gleichen Vorzähler
versorgt.

Der Vorzähler dient dazu, den CPU-Takt vorerst mal runter zu brechen auf eine
wählbare Teilung. Die so geteilte Frequenz wird den Eingängen der Timer
zugeführt.

Wenn wir mit einer einem CPU-Takt von 4 MHz arbeiten und den Vorteiler auf 1024
einstellen wird also der Timer mit einer Frequenz von 4 MHz / 1024, also mit ca.
4 kHz versorgt. Wenn also der Timer läuft, so wird das Daten- bzw.
Zählregister mit dieser Frequenz inkrementiert.

== 8-Bit Timer/Counter ==

Alle AVR-Modelle weisen mindestens einen, teilweise sogar zwei, 8-Bit Timer
auf.

Der 8-Bit Timer wird über folgende Register angesprochen:

{| border="1"
|-
| '''TCCR0'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
Timer '''0'''

In diesem Register stellen wir ein, wie wir den Timer/Counter verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CS02'''
| align="center" | '''CS01'''
| align="center" | '''CS00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

'''CS02, CS01, CS00''' ('''C'''lock '''S'''elect Bits)
:Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
<dl><dd>
{| border="1"
|-
| align="center" | CS02
| align="center" | CS01
| align="center" | CS00
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin '''TO''', fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin '''TO''', steigende Flanke
|}
</dd>
</dl>
:Wenn als Quelle der externe Pin '''TO''' verwendet wird, so wird ein Flankenwechsel auch erkannt, wenn der Pin '''TO''' als Ausgang geschaltet ist.

|-
| '''TCNT0'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer '''0''' 
Dieses ist als 8-Bit Aufwärtszähler mit Schreib- und Lesezugriff
realisiert. Wenn der Zähler den Wert 255 erreicht hat beginnt er beim
nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}
|}

Um nun also den Timer0 in Betrieb zu setzen und ihn mit einer Frequenz von 1/1024-tel des CPU-Taktes zählen zu lassen, schreiben wir die folgende Befehlszeile:

<pre class="code">
TCCR0 = (1<<CS00)|(1<<CS02);
</pre>

Der Zähler zählt nun aufwärts bis 255, um dann wieder bei 0 zu beginnen. Der aktuelle Zählerstand steht in TCNT0. Bei jedem Überlauf von 255 auf 0 wird das Timer Overflow Flag '''TOV0''' im Timer Interrupt Flag '''TIFR'''-Register gesetzt und, falls so konfiguriert, ein entsprechender Timer-Overflow-Interrupt ausgelöst.

== 16-Bit Timer/Counter ==

Viele AVR-Modelle besitzen ausser den 8-Bit Timers auch einen oder sogar zwei
(einige ATMega-Modelle) 16-Bit Timer.

Die 16-Bit Timer/Counter sind wesentlich komplexer aufgebaut als die 8-Bit
Timer/Counter, bieten dafür aber auch viel mehr Möglichkeiten, als da sind:

* Die [[PWM]]-Betriebsart Erzeugung eines pulsweitenmodulierten Ausgangssignals.
* Vergleichswert-Überprüfung mit Erzeugung eines Ausgangssignals (Output Compare Match).
* Einfangen eines Eingangssignals mit Speicherung des aktuellen Zählerwertes (Input Capturing), mit zuschaltbarer Rauschunterdrückung (Noise Filtering).

Folgende Register sind dem Timer/Counter 1 zugeordnet:

{| border="1"
|-
| '''TCCR1A'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister
'''A''' Timer '''1''' 
In diesem und dem folgenden Register stellen wir ein, wie wir den Timer/Counter verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''COM1A1'''
| align="center" | '''COM1A0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''PWM11'''
| align="center" | '''PWM10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''COM1A1''' '''COM1A0'''
| '''Co'''mpare '''M'''atch Control Bits
Diese 2 Bits bestimmen die Aktion, welche am Output-Pin '''OC1''' ausgeführt werden soll, wenn der Wert des Datenregisters des Timer/Counter 1 den Wert des Vergleichsregisters erreicht, also ein so genannter Compare Match auftritt.
Der Pin '''OC1''' ('''PB3''' beim 2313) muss mit dem Datenrichtungsregister als Ausgang konfiguriert werden.

{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Das Signal am Pin '''OC1''' wird invertiert
(Toggle).
|-
| align="center" | 1
| align="center" | 0
| Der Output Pin '''OC1''' wird auf 0 gesetzt.
|-
| align="center" | 1
| align="center" | 1
| Der Output Pin '''OC1''' wird auf 1 gesetzt.
|}
|-
|
| In der PWM-Betriebsart haben diese Bits eine andere Funktion.
{| border="1"
|-
| align="center" | COM1A1
| align="center" | COM1A0
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 0
| align="center" | 1
| Output-Pin '''OC1''' wird nicht angesteuert.
|-
| align="center" | 1
| align="center" | 0
| Wird beim Hochzählen der Wert im Vergleichsregister erreicht so wird der Pin '''OC1''' auf 0 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht so wird der Pin auf 1 gesetzt.
Man nennt dies nicht invertierende PWM.
|-
| align="center" | 1
| align="center" | 1
| Wird beim Hochzählen der Wert im
Vergleichsregister erreicht so wird der Pin '''OC1''' auf 1 gesetzt.
Wird beim Herunterzählen der Wert im Vergleichsregister erreicht so wird der Pin auf 0 gesetzt.
Man nennt dies invertierende PWM.
|}
|-
| '''PWM11''' '''PWM10'''
| '''PWM''' Mode Select Bits 
Mit diesen 2 Bits wird die PWM-Betriebsart des Timer/Counter 1 gesteuert.
{| border="1"
|-
| align="center" | PWM11
| align="center" | PWM10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| Die PWM-Betriebsart ist nicht aktiviert. Timer/Counter 1 arbeitet als normaler Timer bzw. Zähler.
|-
| align="center" | 0
| align="center" | 1
| 8-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 0
| 9-Bit PWM Betriebsart aktivieren.
|-
| align="center" | 1
| align="center" | 1
| 10-Bit PWM Betriebsart aktivieren.
|}
|}
|-
| '''TCCR1B'''
| '''T'''imer/'''C'''ounter '''C'''ontrol '''R'''egister '''B''' Timer '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''ICNC1'''
| align="center" | '''ICES1'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''CTC1'''
| align="center" | '''CS12'''
| align="center" | '''CS11'''
| align="center" | '''CS10'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''ICNC1'''
| '''I'''nput '''C'''apture '''N'''oise '''C'''anceler
(4 CKs) Timer/Counter 1 
oder auf Deutsch Rauschunterdrückung des Eingangssignals.
Wenn dieses Bit gesetzt ist und mit dem Input Capture Signal gearbeitet wird so werden nach der Triggerung des Signals mit der entsprechenden Flanke (steigend oder fallend) am Input Capture Pin '''ICP''' jeweils 4 Messungen mit der CPU-Frequenz des Eingangssignals abgefragt. Nur dann, wenn alle 4 Messungen den gleichen Zustand aufweisen gilt das Signal als erkannt.
|-
| '''ICES1'''
| '''I'''nput '''C'''apture '''E'''dge '''S'''elect Timer/Counter '''1'''
Mit diesem Bit wird bestimmt, ob die steigende ('''ICES1'''=1)
oder fallende ('''ICES1'''=0) Flanke zur Auswertung des Input
Capture Signals an Pin '''ICP''' heran gezogen wird.
|-
| '''CTC1'''
| '''C'''lear '''T'''imer/'''C'''ounter on Compare Match Timer/Counter '''1'''
Wenn dieses Bit gesetzt ist so wird nach einer Übereinstimmung des Datenregisters '''TCNT1H'''/'''TCNT1L''' mit dem Vergleichswert in '''OCR1H'''/'''OCR1L''' das Datenregister '''TCNT1H'''/'''TCNT1L''' auf 0 gesetzt.
Da die Übereinstimmung im Takt nach dem Vergleich behandelt wird ergibt sich je nach eingestelltem Vorzähler ein etwas anderes Zählverhalten:
Wenn der Vorteiler auf 1 gestellt ist und C der jeweilige Zählerwert ist, dann nimmt das Datenregister, im CPU-Takt betrachtet, folgende Werte an: 
... | C-2 | C-1 | C | 0 | 1 |... 
Wenn der Vorteiler z.B. auf 8 eingestellt ist, dann nimmt das Datenregister folgende Werte an: 
... | C-2, C-2, C-2, C-2, C-2, C-2, C-2, C-2 | C-1, C-1, C-1, C-1,
C-1, C-1, C-1, C-1 | C, 0, 0, 0, 0, 0, 0, 0 |... 
In der PWM-Betriebsart hat dieses Bit keine Funktion.
|-
| '''CS12''' '''CS11''' '''CS10'''
| '''C'''lock '''S'''elect Bits
Diese 3 Bits bestimmen die Quelle für den Timer/Counter:
{| border="1"
|-
| align="center" | CS12
| align="center" | CS11
| align="center" | CS10
| Resultat
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stopp, Der Timer/Counter wird angehalten.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CPU-Takt
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CPU-Takt / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CPU-Takt / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CPU-Takt / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CPU-Takt / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin TO, fallende Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin T0, steigende Flanke
|}

Wenn als Quelle der externe Pin T0 verwendet wird, so wird ein
Flankenwechsel auch erkannt, wenn der Pin T0 als Ausgang geschaltet
ist.
|}
|-
| '''TCNT1H''' '''TCNT1L'''
| '''T'''imer/'''C'''ou'''nt'''er Daten Register Timer/Counter '''1'''
Dieses ist als 16-Bit Aufwärtszähler mit Schreib- und Lesezugriff realisiert. Wenn der Zähler den Wert 65535 erreicht hat beginnt er beim nächsten Zyklus wieder bei 0.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''TCNT1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''TCNT1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

In der PWM-Betriebsart wird das Register als Auf/Ab-Zähler verwendet, d.h. der Wert steigt zuerst von 0 bis er den Überlauf von 65535 auf 0 erreicht hat. Dann zählt das Register rückwärts wiederum bis 0.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird.
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''OCR1H''' '''OCR1L'''
| Timer/Counter '''O'''utput '''C'''ompare '''R'''egister Timer/Counter '''1'''
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''OCR1H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''OCR1L'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Der Wert im Output Compare Register wird ständig mit dem aktuellen Wert im Datenregister TCNT1H/TCNT1L verglichen. Stimmen die beiden Werte überein so wird ein sogenannter Output Compare Match ausgelöst. Die entsprechenden Aktionen werden über die Timer/Counter 1 Control und Status Register eingestellt.

Zum Auslesen des Registers wird von der CPU ein internes TEMP-Register verwendet. Das gleiche Register wird auch verwendet, wenn auf '''OCR1''' oder '''ICR1''' zugegriffen wird
Deshalb müssen vor dem Zugriff auf eines dieser Register alle Interrupts gesperrt werden, weil sonst die Möglichkeit des gleichzeitigen Zugriffs auf das Temporärregister gegeben ist, was natürlich zu fehlerhaftem Verhalten des Programms führt.. Zudem muss zuerst '''TCNT1L''' und erst danach '''TCNT1H''' ausgelesen werden.

Wenn in das Register geschrieben werden soll müssen ebenfalls alle Interrrupts gesperrt werden. Dann muss zuerst das '''TCNT1H'''-Register und erst danach das '''TCNT1L'''-Register geschrieben werden, also genau die umgekehrte Reihenfolge wie beim Lesen des Registers.
|-
| '''ICR1H''' '''ICR1L'''
| Timer/Counter '''I'''nput '''C'''apture '''R'''egister
Timer/Counter '''1''' 
{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
| align="center" |  
|-
| '''Name'''
| align="center" | '''MSB'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''ICR1''''''H'''
|-
| '''Name'''
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" |  
| align="center" | '''LSB'''
| align="center" | '''ICR1''''''L'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" |  
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" |  
|}

Das Input Capture Register ist ein 16-Bit Register mit Lesezugriff. Es kann nicht beschrieben werden.

Wenn am Input Capture Pin '''ICP''' die gemäss Einstellungen im '''TCCR1B''' definierte Flanke erkannt wird so wird der aktuelle Inhalt des Datenregisters '''TCNT1H'''/'''TCNT1L''' sofort in dieses Register kopiert und das Input Capture Flag '''ICF1''' im Timer Interrupt Flag Register '''TIFR''' gesetzt.

Wie bereits oben erwähnt müssen vor dem Zugriff auf dieses Register alle Interrupts gesperrt werden. Zudem müssen Low- und Highbyte des Registers in der richtigen Reihenfolge bearbeitet werden:

{| border="0"
|-
| Lesen:
| '''ICR1L''' -> '''ICR1H'''
|-
| Schreiben:
| '''ICR1H''' -> '''ICR1L'''
|}
|}

=== Die PWM-Betriebsart ===

Wenn der Timer/Counter 1 in der PWM-Betriebsart betrieben wird so bilden das Datenregister '''TCNT1H'''/'''TCNT1L''' und das Vergleichsregister '''OCR1H'''/'''OCR1L''' einen 8-, 9- oder 10-Bit, frei laufenden PWM-Modulator, welcher als PWM-Signal am '''OC1'''-Pin ('''PB3''' beim 2313) abgegriffen werden kann. Das Datenregister '''TCNT1H'''/'''TCNT1L''' wird dabei als Auf-/Ab-Zähler
betrieben, welcher von 0 an aufwärts zählt bis zur Obergrenze und danach wieder zurück auf 0.
Die Obergrenze ergibt sich daraus, ob 8- 9- oder 10-Bit PWM verwendet wird und zwar gemäss folgender Tabelle:

{| border="1"
|-
| align="center" | '''Auflösung'''
| align="center" | '''Obergrenze'''
| '''Frequenz'''
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Wenn nun der Zählerwert im Datenregister den in '''OCR1H'''/'''OCR1L'''
gespeicherten Wert erreicht wird der Ausgabepin '''OC1''' gesetzt bzw.
gelöscht, je nach Einstellung von '''COM1A1''' und '''COM1A0''' im '''TCCR1A'''-Register.

Ich habe versucht, die entsprechenden Signale in der folgenden Grafik
zusammenzufassen

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

=== Vergleichswert-Überprüfung ===

Hier wird in ein spezielles Vergleichswertregister ('''OCR1H'''/'''OCR1L''') ein Wert eingeschrieben, welcher ständig mit dem aktuellen Zählerwert verglichen wird.
Erreicht der Zähler den in diesem Register eingetragenen Wert so kann ein Signal (0 oder 1) am Pin '''OC1''' erzeugt und/oder ein Interrupt ausgelöst werden.

=== Einfangen eines Eingangssignals (Input Capturing) ===

Bei dieser Betriebsart wird an den Input Capturing Pin (ICP) des Controllers eine Signalquelle angeschlossen.
Nun kann je nach Konfiguration entweder ein Signalwechsel von 0 nach 1 (steigende Flanke) oder von 1 nach 0 (fallende Flanke) erkannt werden und der zu diesem Zeitpunkt aktuelle Zählerstand in ein spezielles Register abgelegt werden. Gleichzeitig kann auch ein entsprechender Interrupt ausgelöst werden.
Wenn die Signalquelle ein starkes Rauschen beinhaltet kann die Rauschunterdrückung eingeschaltet werden. Dann wird beim Erkennen der konfigurierten Flanke über 4 Taktzyklen das Signal überwacht und nur dann, wenn alle 4 Messungen gleich sind wird die entsprechende Aktion ausgelöst.

== Gemeinsame Register ==

Verschiedene Register beinhalten Zustände und Einstellungen, welche sowohl
für den 8-Bit, als auch für den 16-Bit Timer/Counter in ein und demselben
Register zu finden sind.

{| border="1"
|-
| '''TIMSK'''
| '''T'''imer/Counter '''I'''nterrupt '''M'''a'''sk'''
Register

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOIE1'''
| align="center" | '''OCIE1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''TICIE'''
| align="center" | '''-'''
| align="center" | '''TOIE0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''TOIE1'''
| '''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable
Timer/Counter '''1''' 
Wenn dieses Bit gesetzt ist wird bei einem Überlauf des
Datenregisters des Timer/Counter 1 ein Timer Overflow 1 Interrupt
ausgelöst. Das Global
Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
|-
| '''OCIE1A'''
| '''O'''utput '''C'''ompare Match '''I'''nterrupt '''E'''nable
Timer/Counter '''1''' 
Beim Timer/Counter 1 kann zusätzlich zum Überlauf ein
Vergleichswert definiert werden. 
Wenn dieses Bit gesetzt ist wird beim Erreichen des Vergleichswertes
ein Compare Match Interrupt ausgelöst. Das Global
Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
|-
| '''TICIE'''
| '''T'''imer/Counter '''I'''nput '''C'''apture '''I'''nterrupt
'''E'''nable 
Wenn dieses Bit gesetzt ist wird ein Capture Event Interrupt
ausgelöst, wenn ein entsprechendes Signalereignis am Pin PD6(ICP)
auftritt. Das Global
Enable Interrupt Flag muss selbstverständlich auch gesetzt sein,
wenn auch ein entsprechender Interrupt ausgelöst werden soll.
|-
| '''TOIE0'''
| '''T'''imer/Counter '''O'''verflow '''I'''nterrupt '''E'''nable
Timer/Counter '''0''' 
Wenn dieses Bit gesetzt ist wird bei einem Überlauf des
Datenregisters des Timer/Counter 0 ein Timer Overflow 0 Interrupt
ausgelöst. Das Global
Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
|-
|
|
|}
|-
| '''TIFR'''
| '''T'''imer/Counter '''I'''nterrupt '''F'''lag '''R'''egister

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''TOV1'''
| align="center" | '''OCF1A'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''ICF1'''
| align="center" | '''-'''
| align="center" | '''TOV0'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''TOV1'''
| '''T'''imer/Counter '''O'''verflow Flag Timer/Counter
'''1''' 
Dieses Bit wird vom Controller gesetzt, wenn beim Timer 1 ein
Überlauf des Datenregisters stattfindet. 
In der PWM-Betriebsart wird das Bit gesetzt, wenn die Zählrichtung
von auf- zu abwärts und umgekehrt geändert wird (Zählerwert = 0). 
Das Flag wird automatisch gelöscht, wenn der zugehörige
Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht
werden, indem eine logische 1 (!) in das entsprechende Bit
geschrieben wird.
|-
| '''OCF1A'''
| '''O'''utput '''C'''ompare '''F'''lag
Timer/Counter '''1''' 
Dieses Bit wird gesetzt, wenn der aktuelle Wert des Datenregisters
von Timer/Counter 1 mit demjenigen im Vergleichsregister '''OCR1'''
übereinstimmt. 
Das Flag wird automatisch gelöscht, wenn der zugehörige
Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht
werden, indem eine logische 1 (!) in das entsprechende Bit
geschrieben wird.
|-
| '''ICF1'''
| '''I'''nput '''C'''apture '''F'''lag Timer/Counter '''1''' 
Dieses Bit wird gesetzt, wenn ein Capture-Ereignis aufgetreten ist,
welches anzeigt, dass der Wert des Datenregisters des Timer/Counter
1 in das Input Capture Register ICR1 übertragen wurde. 
Das Flag wird automatisch gelöscht, wenn der zugehörige
Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht
werden, indem eine logische 1 (!) in das entsprechende Bit
geschrieben wird.
|-
| '''TOV0'''
| '''T'''imer/Counter '''O'''verflow Flag Timer/Counter
'''0''' 
Dieses Bit wird vom Controller gesetzt, wenn beim Timer 0 ein
Überlauf des Datenregisters stattfindet. 
Das Flag wird automatisch gelöscht, wenn der zugehörige
Interrupt-Vektor aufgerufen wird. Es kann jedoch auch gelöscht
werden, indem eine logische 1 (!) in das entsprechende Bit
geschrieben wird.
|}
|}

 

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sogen. ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comperators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrups den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

{| border=1
| set_sleep_mode(uint8_t mode)
|Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z.B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
|-
| sleep_mode()
| Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus
|-
|}

<pre class="code">
#include <avr/io.h>
#include <avr/sleep.h>
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach auftreten eines entsprechenden "Aufwach-Interrupts" verarbeitet
...
</pre>

Vorsicht: Nicht alle AVR-Controller (v.a. nicht die "Brandneuen") werden von den avr-libc sleep-Funktionen richtig angesteuert. Bei nicht-untersützten Typen erreicht man die gewollte Funktionalität durch direkte "Bitmanipulation" der ensprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler:

<pre class="code">
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep");
...
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes

= Der Watchdog =

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der Watchdog.

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln. 
Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

Betrachten wir doch einmal folgende Codesequenz:

<pre class="code">
uint8_t x;

x = 10;

while (x >= 0) {
// tu was 
x--;
}
</pre>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm würde sich also hier aufhängen und auf ewig in der Schleife drehen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde beginnt der Counter von 0 an hochzuzählen. Wenn nun die je nach Vorteiler eingestellte Anzahl
Zyklen erreicht wurde löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern müssen wir den Watchdog regelmässig wieder neu starten bzw. Rücksetzen (Watchdog Reset). Dies sollte innerehalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern muss ein spezielles Prozedere verwendet werden um den WD auszuschalten und zwar müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden. Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| border="1"
|-
| '''WDTCR'''
| '''W'''atchog '''T'''imer  '''C'''ontrol '''R'''egister 
In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.
Das Register ist wie folgt aufgebaut:

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''WDTOE'''
| align="center" | '''WDE'''
| align="center" | '''WDP2'''
| align="center" | '''WDP1'''
| align="center" | '''WDP0'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''WDTOE'''
| '''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable 
Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
Wenn das Bit einmal gesetzt ist wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.
|-
| '''WDE'''
| '''W'''atch'''d'''og '''E'''nable 
Wenn dieses Bit gesetzt wird so wird der Watchdog aktiviert.
Das Bit kann nur gelöscht werden solange das Bit '''WDTOE''' auf 1 steht.
|-
| '''WDP2''' '''WDP1''' '''WDP0'''
| '''W'''atch'''d'''og Timer '''P'''rescaler Bits 
Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:

{| border="1"
|-
| align="center" | WDP2
| align="center" | WDP1
| align="center" | WDP0
| align="center" | Anzahl Zyklen
| align="center" | Typ. Timeoutzeit bei Vcc = 3V
| align="center" | Typ. Timeoutzeit bei Vcc = 5V
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 16K
| align="center" | 47ms
| align="center" | 15ms
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| align="center" | 32K
| align="center" | 94ms
| align="center" | 30ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 64K
| align="center" | 0.19s
| align="center" | 60ms
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 128K
| align="center" | 0.38s
| align="center" | 0.12s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | 256K
| align="center" | 0.75s
| align="center" | 0.24s
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| align="center" | 512K
| align="center" | 1.5s
| align="center" | 0.49s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| align="center" | 1024K
| align="center" | 3s
| align="center" | 0.97s
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | 2048K
| align="center" | 6s
| align="center" | 1.9s
|}
|}
|}

Um den Watchdog mit dem AVR-GCC Compiler zu verwenden muss die Headerdatei wdt.h in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

{| border=1
| wdt_enable(uint8_t timeout)
|Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert (z.B. WDTO_30MS).
|-
| wdt_disable()
| Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
|-
| wdt_reset()
| Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.
|}

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Ein paar grundsätzliche Gedanken ==

Ob nun so ein Watchdog überhaupt verwendet werden soll ist wohl eher eine
philosophische Frage und hängt vom Geschmack jedes einzelnen Entwicklers ab.

Ich persönlich habe es lieber, wenn ich auch merke, dass in meine Programm
etwas noch nicht in Ordnung ist, als dass mir ein Watchdog einfach die CPU immer
wieder zurücksetzt, denn immerhin kann es so passieren, dass ein Programm über
Jahre hinweg so einigermassen läuft, obwohl noch ein voll krasser Bock drin
liegt.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Watchdog timer handling

= Programmieren mit Interrupts =

Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

[[Image:Interrupt Programme.gif]]

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

== Anforderungen an die Interrupt-Routine ==

Um unliebsamen Überraschungen vorzubeugen sollten einige Grundregeln bei
der Gestaltung der Interruptroutinen beachtet werden.

* Die Interruptroutine soll möglichst kurz und schnell abarbeitbar sein, daraus folgt:
* Keine unfangreichen Berechnungen innerhalb der Interruptroutine.
* Keine endlos langen Programmschleifen.
* Obschon es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen rate ich dringend von solchen Spielen ab.

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf dem AVR auslösen, wobei
die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

== Register ==

Der AT90S2313 verfügt über 2 Register welche mit den
Interrupts zusammen hängen.

{| border="1"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INT1'''
| align="center" | '''INT0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''INT1'''
| External '''Int'''errupt Request '''1''' Enable
Wenn dieses Bit gesetzt ist wird ein Interrupt ausgelöst wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.
|-
| '''INT0'''
| External '''Int'''errupt Request '''0''' Enable
Wenn dieses Bit gesetzt ist wird ein Interrupt ausgelöst wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.
|}
|}

{| border="1"
|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister. 

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''INTF1'''
| align="center" | '''INTF0'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''-'''
|-
| '''R/W'''
| align="center" | R/W
| align="center" | R/W
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''INTF1'''
| External '''Int'''errupt Flag '''1'''
Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist wird die
Interruptroutine angesprungen.
Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist.
Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''INTF0'''
| External '''Int'''errupt Flag '''0''' 
Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist wird die
Interruptroutine angesprungen.
Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist.
Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|}
|}

{| border="1"
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister. 
Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| border="1"
|-
| '''Bit'''
| align="center" | 7
| align="center" | 6
| align="center" | 5
| align="center" | 4
| align="center" | 3
| align="center" | 2
| align="center" | 1
| align="center" | 0
|-
| '''Name'''
| align="center" | '''-'''
| align="center" | '''-'''
| align="center" | '''SE'''
| align="center" | '''SM'''
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
|-
| '''R/W'''
| align="center" | R
| align="center" | R
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R/W
| align="center" | R
|-
| '''Initialwert'''
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
| align="center" | 0
|}

{| border="0"
|-
| '''SE'''
| '''S'''leep '''E'''nable
Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl
in den Schlafzustand versetzen zu können.
Um den Schlafmodus nicht irrtümlich einzuschalten wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.
|-
| '''SM'''
| '''S'''leep '''M'''ode
Dieses Bit bestimmt der Schlafmodus.
Ist das Bit gelöscht so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")
|-
| '''ISC11''' '''ISC10'''
| '''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits
Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.

{| border="1"
|-
| align="center" | '''ISC11'''
| align="center" | '''ISC10'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt. 
In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}
|-
| '''ISC01''' '''ISC00'''
| '''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits
Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

{| border="1"
|-
| align="center" | '''ISC01'''
| align="center" | '''ISC00'''
| '''Bedeutung'''
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.
In der Beschreibung heisst es, der Interrupt wird getriggert, solange der Pin auf 0 bleibt, also eigentlich unbrauchbar.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flank an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}
|}
|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft wird automatisch das '''Global
Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle
weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem
Zeitpunkt bereits wieder das GIE-bit zu setzen rate ich dringend davon ab. Dieses
wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn
in der Zwischenzeit weitere Interrupts eintreffen werden die zugehörigen
Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden
Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt
ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle
anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe,
weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.

=== Das Status-Register ===

Es gilt auch zu beachten, dass das Status-Register während der Abarbeitung
einer Interruptroutine nicht automatisch gesichert wird. Falls notwendig muss dies vom
Programmierer selber vorgesehen werden.

== Interrupts mit dem AVR GCC Compiler (WinAVR) ==

Selbstverständlich können alle Interruptspezifischen Registerzugriffe wie gewohnt über I/O-Adressierung vorgenommen werden. Etwas einfacher geht es jedoch, wenn wir die vom Compiler zur Verfügung gestellten Mittel einsetzen.

Damit diese Mittel zur Verfügung stehen müssen wir die Includedatei interrupt.h und evtl. signal.h einbinden mittels:

<pre class="code">
// fuer sei(), cli() und INTERRUPT():
#include <avr/interrupt.h>

// fuer SIGNAL() auch:
#include <avr/signal.h>
</pre>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird
nichts anderes gemacht als das '''Global Interrupt Enable''' Bit im Status
Register gesetzt.

<pre class="code">
sei();
</pre>

Das Makro '''cli()''' schaltet die Interrupts aus oder anders
gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird
gelöscht.
<pre class="code">
cli();
</pre>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf.
Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen.
Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren
und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen
Zustands die Interrups aktivieren, was zu unerwünschten Seiteneffekten führen kann.
Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern */

MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD); // 2 mal in Folge , vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
...

}
</pre>



Nachdem nun die Interrupts aktiviert sind braucht es selbstverständlich noch den auszuführenden Code, der ablaufen soll wenn ein Interrupt eintrifft. Dazu gibt es zwei Definitionen: '''SIGNAL''' und '''INTERRUPT''', welche allerdings AVR-GCC spezifisch sind und bei anderen Compilern womöglich anders heissen können.

=== SIGNAL ===

<pre class="code">
#include <avr/signal.h>
...
SIGNAL (siglabel)
{
/* Interrupt Code */
}
</pre>

Mit ''SIGNAL'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektoren angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Vor Nutzung von SIGNAL muss die Header-Datei signal.h eingebunden werden. Mögliche Funktionsrümpfe für solche Interruptfunktionen sind zum Beispiel:

<pre class="code">
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

SIGNAL (SIG_OVERFLOW1)
{
/* Interrupt Code */
}

SIGNAL (SIG_UART_RECV)
{
/* Interrupt Code */
}

// und so weiter und so fort...
</pre>

Während der Ausführung des Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== INTERRUPT ===

<pre class="code">
#include <avr/interrupt.h>
...
INTERRUPT (signame)
{
/* Interrupt Code */
}
</pre>

Mit INTERRUPT wird genau gleich gearbeitet wie mit SIGNAL. Der Unterschied ist derjenige, dass bei INTERRUPT beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit automatisch wieder gesetzt und somit weitere Interrupts zugelassen werden. Dies kann zu nicht unerheblichen Problemen von im einfachsten Fall einem Stack overflow bis zu sonstigen unerwarteten Effekten führen und sollte wirklich '''nur dann''' angewendet werden, wenn man sich absolut sicher ist, das Ganze auch im Griff zu haben. Vor Nutzung von INTERRUPT muss die Header-Datei interrupt.h eingebunden werden.

Interruptroutinen (ISRs) sollten möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern den Zustand aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

siehe auch: Hinweise in [[AVR-GCC]]

== Datenaustausch mit Interrupt-Routinen ==

Variablen auf die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen wird und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte die Code-Optimierung "greifen" und der Wert der Variablen nur in Prozessorregistern zwischenspeichert werden, die "nichts von der Änderung woanders mitbekommen".

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<pre class="code">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z.B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt z.B. alle 10ms
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
// hier wird gKeyCounter veraendert, die uebrigen
// Programmteile muessen diese Aenderung "sehen"
// (volatile -> aktuellen Wert immer in den Speicher schreiben)
if ( !(KEY_PIN & (1<<KEY_PINNO)) )
if (gKeyCouter < CNTREPEAT) gKeyCounter++;
else gKeyCounter = 0;
}

...

int main(void)
{
...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
...
// hier wird auf gKeyCounter zugegriffen, dazu muss der in der
// ISR geschrieben Wert bekannt sein.
// (volatile -> aktuellen Wert immer aus dem Speicher lesen)
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt"
}
else {
/* hier: Code fuer "Taste kurz gedrueckt"
}
...
}
</pre>

Bei Variablen größer ein Byte muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes ausserhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<pre class="code">
...
volatile uint16_t gMyCounter16bit
...
SIGNAL(...)
{
...
gMyCounter16Bit++;
...
}

int main(void)
{
uint16_t tmpCnt;
...
// nicht gut: mglw. hier ein Fehler wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor Kopieren des zweiten Bytes
// ein Interrupt auftritt der den Inhalt von MyCounter veraendert
tmpCnt = gMyCounter16bit;

// besser: Aenderungen "ausserhalb" verhindern, alle "Teilbytes"
// bleiben konsistent
cli(); // Interupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren
...
}
</pre>

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8 (Stand: avr-libc Vers. 1.0.4)

== Was macht das Hauptprogramm ==

Im einfachsten Fall gar nichts mehr. 
Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der
main-Funktion lediglich noch die Interrupts aktiviert und dann in eine
Endlosschleife folgender Art verzweigt:

<pre class="code">
...
for (;;) {}
...
</pre>

Normalerweise wird man allerdings in den Interruptroutinen die Interrupts
erfassen und im Hauptprogramm dann gemütlich auswerten.

Wie wir im bisherigen Kursverlauf gesehen haben ist es ohnehin mit so
schnellen Controller meistens gar nicht unbedingt notwendig mit
Interruptfunktionen zu arbeiten. 
Es ist allerdings auch zu bemerken, dass mit den Interruptroutinen ein Programm
sehr schön strukturiert werden kann, wenn man es richtig macht.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (eigentlich [[SRAM]]) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als [[FLASH]]-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z.B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin wenig Sinn macht und auch nur bei einigen RAM-losen Typen nach "Bastelarbeiten" möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory). Die Standard-Laufzeitbibliothek des avr-gcc, die [[avr-libc]], stellt diese Funktionen nach einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Einige Beispiele:

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray1 };
...
</pre>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<pre class="code">
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte...
}
</pre>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel jedoch mit der Funktion pgm_read_word.

<pre class="code">
uint16_t myWord;

myWord = pgm_read_word(&pgmFooWord);
</pre>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "gross". (Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.) Pointer müssen gegebenenfalls "gecastet" werden.

<pre class="code">
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray1

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray zeigt nun auf das erste Element des Byte-Arrays pgmPointerToArray2
// da im zweiteb Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmPointerToArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</pre>

=== Floats und Structs lesen ===

Um komplexe Datentypen (structs), nicht-integer Datentypen (floats) aus dem Flash auszulesen, sind Hilfsfunktionen erforderlich. Einige Beispiele:

<pre class="code">

/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
...

/* liest float von Flash-Addresse addr und gibt diese als return-value zurueck */
inline float pgm_read_float(const float *addr)
{
union
{
uint16_t i[2]; // 2 16-bit-Worte
float f;
} u;

u.i[0]=pgm_read_word((PGM_P)addr);
u.i[1]=pgm_read_word((PGM_P)addr+2);

return u.f;
}
...

void egal(void)
{
int i;
float f;

for (i=0;i<3;i++) {
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach' was mit f
}
}
</pre>

TODO: Beispiele fuer structs und pointer aus flash auf struct im flash (menues, state-machines etc.)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<pre class="code">
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuerht, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
...
</pre>

Aber Achtung: Ersetzt man zum Beispiel
<pre class="code">
const char textImFlash[] PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
durch
<pre class="code">
const char textImFlash* PROGMEM = "Pusemuckel"; // im "Flash"
</pre>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der textImFlash zu den Konstanten ans Ende des Programmcodes gelegt wird, von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte. Da der lesende Code trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein Bug des AVR-GCC (gesehen bei 3.4.1) zu sein.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<pre class="code">
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
...
</pre>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z.B. 0x01fe), "weiss" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, das der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000) wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z.B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmässig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, das vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgeben sind ("timed sequence"). Diese Prüfung wird nicht implizit durchgeführt. Im Zweifel kann man Sicherheitshalber bei EEPROM-Zugriffen die Interrupts global deaktivieren, z.B. so:

<pre class="code">
...
uint8_t sreg;
...

sreg = SREG;
cli();

/* hier die eeprom-Zugriffe */

SREG = sreg;
...
</pre>

Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Die Nutzung einer [[C-Präprozessor]]-Ersetzung bringt etwas Bequemlichkeit. Siehe dazu folgendes Beispiel.

<pre class="code">
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h>

// alle Textstellen EEPROM im Quellcode durch __attribute__ ... ersetzen
#define EEPROM __attribute__ ((section (".eeprom")))

...

/* Byte */
uint8_t eeFooByte EEPROM = 123;

/* Wort */
uint16_t eeFooWort EEPROM = 12345;

/* float */
float eeFooFloat EEPROM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEPROM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEPROM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */

uint16_t eeFooWordArray1[4] EEPROM;
...
</pre>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heisst eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<pre class="code">
...
uint8_t myByte;
uint8_t sreg;

sreg = SREG; // (1)
cli(); // (1)

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
...
SREG = sreg; // (1)
</pre>

Die mit (1) markierten Zeilen dienen hierbei dem (möglicherweise übertriebenen) Schutz vor Unterbrechnungen durch Interrupts.

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<pre class="code">
...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
...
</pre>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprueft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und mglw. noch mehr.

<pre class="code">
...
unit8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes aber der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnuetze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray[0],3);

/* dito mit etwas Absicherung betr. der Laenge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));

/* Datenlock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray,sizeof(myWordBuffer));
...
</pre>

"Nicht-Integer"-Datentypen wie z.B. Fliesskommazahlen lassen sich recht praktisch ueber eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<pre class="code">
...
float myFloat = 12.34;

union {
float r;
uint8_t n[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */
...
</pre>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<pre class="code">
...
typedef struct {
uint8_t label[8];
unin8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEPROM;

...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
...
}
...
</pre>

=== EEPROM-Speicherabbild in .eep-Datei ===

Eine besondere Funktion des avr-gcc ist, dass mit einem entsprechenden makefile aus den Initialisierungswerten der Variablen im Quellcode eine Datei erzeugt werden kann, die man auf den Controller programmieren kann (.eep-Datei). Damit können sehr elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Die Vorgehensweise wird aus dem WinAVR-Beispielmakefile ersichtlich. Siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles.

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Nicht alle neuen AVR Controller werden von avr-libc/eeprom.h untersützt (Stand Version 1.0.4). Insbesondere beim ATMega169 funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register) Etwas ältere Typen, oder zu den "etablierten" Controllern kompatible, bereiten jedoch hier keine Proleme. Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Der dort gezeigt Code kann direkt auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste").

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gcc-Toolchain" bietet dazu zwei Möglichkeiten:

;Inline-Assembler:
Die Assembleranweisungen werden in direkt in den C-Code integriert. Eine Quellcode-Datei enhält somit C- und Assembleranweisungen

;Assembler-Dateien:
Der Assembler-Codecode befindet sich in eigenen Quellcodedateien. Dieser werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z.B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen eine NOP-Anweisung. NOP steht für '''NO'''-O'''P'''eration. Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=warte)-Funktionen.

<pre class="code">
...
/* Verzoegern der weiteren Programmausfuehrung um
genau 3 Taktzyklen */
asm volatile ("nop"::);
asm volatile ("nop"::);
asm volatile ("nop"::);
...
</pre>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeindlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<pre class="code">
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i=0;i<1000;i++);

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i=0;i<1000;i++) asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j=0;j<1000;j++);
</pre>

Ein weiterer nützliche "Assembler-Einzeiler" ist der Auruf von sleep (''asm volatile ("sleep"::);''), da hierzu keine eigene Funktion in der avr-libc existiert.

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil des die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<pre class="code">
static inline void delayloop16(uint16_t count)
{
asm volatile ( "cp %A0,__zero_reg__ \n\t" \
"cpc %B0,__zero_reg__ \n\t" \
"breq L_Exit_%= \n\t" \
"L_LOOP_%=: \n\t" \
"sbiw %0,1 \n\t" \
"brne L_LOOP_%= \n\t" \
"L_Exit_%=: \n\t" \
: "=w" (count)
: "0" (count)
);
}
</pre>

* Jede Zeile wird mit '''\n\t''' abgeschlossen, alle Zeilen mit '''\''' verbunden.
* Sprung-Marken (labels) werden mit einm Prozentzeichen abgeschlossen, der Präprozessor (Assembler?) setzt an dieser Stelle eine laufende Nummer ein, die Doppelbezeichnungen bei mehrmaliger Verwendung somit verhindert.

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc.

* siehe auch: Dokumentation der avr-libc/Related Pages/Inline Asm
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

...TODO: Beispiele, Parameteruebergabe, globale Variablen für Datenaustausch

= TODO =

stdio.h, malloc() ???, Code-Optimierungen ("tricks"), "naked"-Functionen ??, IO-Register als Parameter/"Variablen" (volatile uint8_t *mybusport; mybusport=&PORTB; void sendbus(uint8_t *parm)...)

= C-Code und Bibliotheken für externe Baugrupen =
(TODO: sollte in avr-gcc verschoben werden)
[[Linksammlung#Avr]]

==LCD==
=== Text (character-mode) HD44870 ===
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray

=== Grafik-LCD ===
==== Nokia3310 ====
==== Nokia 6100 LCD ====
Das Nokia ist ein 132x132x4096 Farben Display das bei eBay ziemlich preiswert ersteigert werden kann.
[http://www.apetech.de/nokia6100.php Nokia 6100 LCD Library]
==== KS0108 ====
* Procyon avrlib (GPL)
* avrfreaks UP
* apetech.de
==Schnittstellen==
===I2C===
====Master====
[http://jump.to/fleury/ P. Fleurys I2C Master library]
====Slave====

===CAN===
* [http://www.atmel.com] Codesammlung zum AT90CAN128

=== DS18S20/1-Wire ===
* avrfreaks Projekt 59
* mikrocontroller.net/codesammlung (P. Dannegger)

=== UART ===
* Procyon avrlib (GPL)
* avrfreaks UP (viele viele)
* P. Fleury

== Speicherkarten/IDE/FAT ==
* avrfreaks UP (IDE/FAT read write)
== CRC ==
* avrfreaks-forum (O'Flynn)
* avr-hal (GPL)