Mikrocontroller.net - Benutzerbeiträge [de]

DDS

2008-01-11T23:44:04Z

FalkB: /* Lesestoff */

===Direkte Digitale Synthese===
Erzeugung einer Wechselspannung / eines Wechselstromes mittels Frequenzgenerator, FixedPoint-Addierer, LookUpTable und Digital-Analog-Wandler [[DAC]].

==Funktionsweise==
Erzeugung der Basisfrequenz durch Quarzoszillator (evtl. mit Phase-Locked-Loop PLL Synthesizer). Ausgangsfrequenz ist immer geringer als die Basisfrequenz.

Sehr gute Beschreibung der Theorie und der Nachteile (PhasenRauschen, Oberwellen): 
http://www.analog.com/UploadedFiles/Tutorials/450968421DDS_Tutorial_rev12-2-99.pdf

Die LookUpTable kann fest (meist Sinus) oder programmierbar (RAM, Arbitrary Waveform) oder ein Algorithmus sein.

Verwendung im NF / Audio- und HF / Funk-Bereich (bis 1 GHz).

Hersteller: Analog Devices http://www.analog.com

Bekannte ICs: Fairchild ML2037, AD9833 (25MHz), AD9835, AD9851, AD9854 (300MHz), AD9951 (400MHz)

Die modernener Chips beinhalten weitere Funktionen wie digitale Amplitudenmodulation (AM), Phasenmodulation (PM), Frequency Shift Keying (FSK).

==Projekte:==
*[[Digitaler Funktionsgenerator]]
*HF-Meßplatz: http://www.mikrocontroller.net/forum/read-1-350237.html
* Einfache Schaltung: 6 Drehschalter - PIC16F84 - AD9833: http://www.mikrocontroller.net/forum/read-1-403708.html
* Ganz ähnlich, mit ML2037: http://www.seattlerobotics.org/encoder/200205/ddsfgen.htm
* DDS-Signalgenerator bis 500 MHz (1200MHz Takt): http://www.dg4rbf.de/ -> SYN500, SYN500/2

=Lesestoff=
* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=dds* Suche nach dds*]
* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=synthe* Suche nach synthe*]
* [http://www.mikrocontroller.net/topic/84498#new Lange, ausführliche Diskussion zur Berechung des Frequency Tuning Words]
* [http://www.mikrocontroller.net/topic/84498#710690 Praktische Umsetzung]

Implementierung im NF-Bereich auch durch µC möglich, z.B. für DialTone (DTFM):
* [http://www.myplace.nu/avr/minidds/index.htm Jesper's AVR pages, DDS using an AVR]
* [http://www.atmel.com/dyn/resources/prod_documents/doc1982.pdf Atmel Application Note]
* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=sinus* Suche nach *sinus* im Forum]
* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=tonerzeug* Suche nach tonerzeug* im Forum]

Midi Rekorder mit MMC/SD-Karte

2008-01-11T23:24:51Z

FalkB: /* Einrichtung ATmega168 mit MMC/SD-Bootloader */

''von [[Benutzer:Dersimon]]''

[[Bild:Foto.jpg]]

== Features ==
* Aufnahme, Wiedergabe, Vor- und Rückspulen
* LCD, Zeit- und Sektoranzeige
* Speichert bis zu 65536 "Files" auf MMC/SD-Karte (optimale Kartengröße 16 MB)
* Maximale unterstützte Kapazität der Karte 8GB (!)
* Beliebige MMC/SD-Karten verwendbar, allerdings muss sie mit Windows formatiert werden und dann muss ein leeres File mit etwa der Kapazität der Karte (unter Eigenschaften im Windows-Explorer wird der freie Speicher in Bytes angegeben) drauf kopiert werden. (Das kann irgendeine Datei sein, die halt gerade noch draufpasst.) Erst dann sollte man sie in Mr.MIDI stecken :-) Sollte die Karte größer als 16 MB sein, kann man die Dateigröße so berechnen: 512 * 256 * Anzahl "Files", dann allerdings nicht in Mr.MIDI zu große Filenummern verwenden! Sonst geht es auf der Karte so durcheinander, dass Windows sie neu formatieren muss...
* PC-Tool zum Umwandeln von/in PC-MIDI-Dateien (nur FORMAT 0)

== Hardware ==
* [[AVR|ATmega8]] mit internem RC-Takt 1 MHz
* [[MIDI]] Interface mit Optokoppler 6N138
* [[LCD]] Display 24*2 (Standardcontroller)
* 7 Tasten und 1 Anschalter
* Spannungsregler 5V und 3,3V
* MMC/SD-Slot

== Kompilieren ==
* In AVR Studio 4 Projekt laden, alle *.asm Dateien hinzufügen
* Build (F7) drücken
* Hex-Code in Controller laden
* Fertig!

== Bekannte Probleme ==
* Medion-SD-Karten gehen nicht.
* PC-Tool hat eine Macke beim Parsen von Mididateien (Wurde behoben, neue Version hier im Artikel zum Download)

== Foto ==
Auf dem Foto sieht man mein Endgerät im hübschen Acrylgehäuse.
Rechts sind die 2 MIDI-Kabel zum Keyboard.

== Schaltplan ==
[[Bild:Eagle-schematic.gif|thumb|400px|left|Schaltplan des MIDI-Rekorders]]
 
MIDI-Out falsch beschaltet: Pin 4 und 5 tauschen!

== Download des Projekts (inkl. Code, Schaltplan) ==

[[Media:Zip.zip|Zip.zip]]

Neuer Konverter (Bugfix):
[[Media:MrMIDIConverter.zip|MrMIDIConverter.zip]]

== Mr.MIDI 2 ist da ! ==
Endlich ist es soweit: Der neue Mr.Midi arbeitet mit dem echten Mididatei-Format (Format 0).
Aufnahme und Wiedergabe sind so einfach wie bei einem MP3-Player.
Und dennoch bleibt die Hardware gleich! Das heißt, alle Nachbauer brauchen nur den neuen Code flashen und haben den neuen Mr.Midi 2!
Für alle, die es noch besser wollen: Echte FAT16-Unterstützung (kann mit defragmentierten Dateien umgehen und selber in ein fragmentiertes Dateisystem schreiben! Dabei wird die Karte so gut es geht geschont!) Für solchen Luxus muss man dann doch den ATmega168 einsetzen :-)

English translation on my homepage http://www.lehmayr.de available!

[[Bild:Foto_MrMidi2.jpg]]

=== Features ===
* Echte Mididateien auf MMC/SD-Karte (Format 0) können abgespielt werden
* Bis zu 255 Dateien werden unterstützt
* Aufzeichnung erfolgt ebenfalls im Midi-Format 0 (jetzt auch mit FAT-Eintrag)
* Löschen von Dateien ist möglich (jetzt auch mit FAT-Aktualisierung)
* 256 Byte Sende/Empfangspuffer und 8MHz-Takt für hohe Performance und präzises MIDI-Timing
* Lyrics werden im Display angezeigt (Coole Sache!)
* Tempo in +/-15 Schritten einstellbar (vorbereitet auf stufenlose Analogknopf-Einstellung, Hardwareänderung erforderlich)
* Bootloader lädt neue Firmware von MMC/SD-Karte (frisch formatiert und nur Datei MM.BIN drauf)
* Transponierfunktion
* Muting ausgewählter Midi-Channels
* Menü für Einstellung Schlagzeugkanal, Lyrikanzeige und Such-Startsektor
* Nichtflüchtige Parameter werden im EEPROM gespeichert
* Verschiedene Repeatmodi
* LED-Beleuchtung im Menü schaltbar (auf PORTB 6+7)

=== Download Mr.MIDI 2 ===
* ATmega8 (ohne Bootloader): [[Media:MrMidi2.zip|MrMidi2.zip]]
* ATmega168 (mit Bootloader): [[Media:MrMidi2m168.zip|MrMidi2m168.zip]]
* ATmega168 (mit Bootloader) für IR-Fernbedienung: [[Media:MrMidi2m168IR.zip|MrMidi2m168IR.zip]]
* ATmega168 (mit Bootloader) für IR-Fernbedienung und mit FAT16-Unterstützung, sowie dem neuen MMC/SD-Karten-Bootloader: [[Media:MrMidi2m168IRFAT16.zip|MrMidi2m168IRFAT16.zip]]
* Neue Version mit 32-Bit-Sektoradressierung: [[Media:MrMidi2m168IRFAT16_32.zip|MrMidi2m168IRFAT16_32.zip]]
* Neue "Ultimate"-Version (massiv optimiert, auf Laufzeit und Größe, neuer 512-Word-Bootloader): [[Media:MrMidi2Ultimate.zip|MrMidi2Ultimate.zip]]
* HEX2BIN-Tool (benötigt um die binären Dateien für den MMC/SD-Karten-Bootloader zu erzeugen): http://www.keil.com/download/docs/7.asp?bhjs=0

Achtung: Leider hat sich der WinAVR Compiler irgendwann so geändert, so dass die gleichen Sources neu kompiliert nicht mehr den Bootloader starten können!!!
Daher BL defekt bei allen alten 32-Bit-Versionen (haben auf "_2.zip" und "_3.zip" geendet)!

==== Einrichtung ATmega168 mit MMC/SD-Bootloader ====
* ATmega168 Fuses auf "1024 Word Bootsize" und KEIN "Bootvector enabled" setzen (optional BOD 4,3V auf enabled)
* Internen RC-Oszillator 8MHz und KEINEN Clockdivider/8 verwenden - alternativ und empfohlen: 8MHz Quarz verwenden! Neuere ATmegas haben offenbar einen Sch***-internen Oszillator. (Kommentar: Nöö, einen UART bertreibt man IMMER mit einem Quarz. Aus gutem Grund! Siehe [[AVR-Tutorial: UART]])
* Leere MCU: Firmwaredatei mrmidi2_bl.hex flashen (wie du das machst, ist egal)
* Bootloader ist bereits installiert:
** Karte formatieren (FAT16) und die Datei MM.BIN draufkopieren
** Karte einlegen, Mr.MIDI 2 anschalten
** Warten bis fertig
** Karte entnehmen, Mr. MIDI 2 ausschalten, original Karte einstecken und wieder anschalten

==== Änderungen seit Initialrevision ====
* Parameter im EEPROM
* Menü
* Transponierfunktion
* Schnelleres MMC Interface (2MHz)
* MMC_init angepasst, um noch mehr Karten zu unterstützen
* Lyric-Anzeige
* Bootloader über MIDI
* Channel-Muting
* Card-Scan ist jetzt intelligenter (FAT16/FAT32-Karten werden unterstützt)
* verschiedene Bugfixes
* Fernbedienungsfunktion RC5
* Display 16x2-Zeichen wird auch unterstützt (alternative Firmware, per Defineschalter im Code wählbar, im Download natürlich auch als extra kompiliertes HEX-File enthalten)
* Verschiedene Wiederholungsmodi für die Songs
* Sendepuffer (präzises MIDI-Timing einhalten, auch wenn FAT-Lesezugriffe auf die Karte erfolgen)
* LED-Hintergrundbeleuchtung im Menü schaltbar (PORTB 6+7)
* FAT16-Unterstützung (vollwertig)
** Lange Dateinamen
** Anzeige Dateigröße
** Dateien aufzeichnen und am PC kopieren
** Dateien löschen
* 32-Bit-Sektoradressierung
* mehr Bugfixes
* MMC/SD-Bootloader integriert
* Gerät jetzt seit mehreren Monaten bei einigen Leuten im Einsatz und noch keine Probleme (Kompatibilität von MMC/SD-Karten gemeldet.
* Noch mehr Bugfixes (Bootloaderfehler-mit-WinAVR20070525-Bug, 32-Bit-Sektornummern-Bug, Abbruch von Aufnahme-Bug, Random-Play-Bug, 16-Dateien-Bug, etc.)
* Anzeige Dateiname während Wiedergabe
* Pause wird über die Zeitanzeige geschrieben
* Lyrics werden nicht mehr von Transpose- oder Geschwindigkeitsanzeige gestört

=== Schaltplan ===
ohne Fernbedienung:
[[Bild:MrMidi-Circuit.gif|thumb|400px|left|Schaltplan des MIDI-Rekorders 2]]

 

mit Fernbedienung:
[[Bild:MrMidi-Circuit_m168_IR.gif|thumb|400px|left|Schaltplan des MIDI-Rekorders 2 mit Fernbedienung]]

 

Achtung: mega168 Pin TX muss an Midi-Buchse OUT Pin 5, und der Pullup muss an Midi-Buchse OUT Pin 4!

Für die Hintergrundbeleuchtung:
* Port B6+7 parallel an einen Widerstand (hängt von deiner LED-Beleuchtung ab) und diesen dann an LED- deines Displays
* LED+ vom Display auf VCC 5V
* Falls das LCD mehr als 40mA zieht, brauchst du einen Transistor!
* Für Serienproduktion: Verwende einen 8MHz-Quarz an Pin PB6&PB7, siehe Datenblatt. Die Genauigkeit des internen Oszillators ist über die Lebenszeit des Geräts nicht ausreichend - nur für Hobbybastler. Dafür kann dann keine Hintergrundbeleuchtung - falls verwendet - angesteuert werden.

=== Erweiterung um ein echtes MIDI-Wavetable ===
Besorge dir bei ebay ein Wavetable-Upgrade-Modul (ca.5-10 Euro) mit 26-poligem Anschluss und baue einen Adapter wie hier gezeigt: http://www.heise.de/ct/97/01/328/
Dazu nimm als +12V-Spannung den 9V-Anschluss der Batterie. Die genannten -12V braucht zumindest mein Creative Pseudo-AWE32-Wavetableplatinchen (nur 53x50mm groß) nicht. Abrunden kannst du das Ganze mit einem Schalter, der als Wavetablequelle den Mr.Midi-Ausgang oder Instrumenten-Eingang wählt. Ein hochwertiger Audioverstärker optimiert das Ergebnis noch.
Leider sind solche Module recht stromhungrig und nicht immer sehr kompakt (das Yamaha DB-50XG ist ein riesen Teil). Wird Zeit, dass die Handy-Midichips massentauglich werden!

=== Kurzanleitung ===
* Karte formatieren (FAT16)
* eventuell Mididateien in Format 0 konvertieren und auf die Karte kopieren
* Karte einsetzen
* MrMidi2 anschalten (Scannt die Karte und zeigt erstes File an)
* Wiedergabe
** Datei mit UP/DOWN auswählen
** PLAY zum Abspielen und Pause machen
** STOP zum Beenden
** <</>> um Tempo zu ändern
** UP/DOWN zum Transponieren
* Aufnahme
** REC drücken (Aufnahmebereit)
** Spielen (Aufnahme beginnt automatisch)
** erneuter Druck auf REC verwirft die Aufnahme
** STOP speichert die Aufnahme
* Letzte Datei löschen
** << und >> gleichzeitig drücken (nur im STOP-Mode)
* Menü
** UP und DOWN gleichzeitig drücken (nur im STOP-Mode; geht auch, wenn keine Karte eingelegt ist)
** UP/DOWN zur Auswahl eines Parameters
** <</>> zum Ändern
** Menüpunkte:
*** 1. Schlagzeugkanal: Default 10 (Das Schlagzeug wird nicht transponiert)
*** 2. Lyrics anzeigen: Default 1 (1 = Lyrics werden angezeigt)
*** 3. Startsektor der MMC-Karte: Default 0x0210 (Falls du nur FAT32 auf MMC/SD-Karten hernimmst, kannst du diesen Wert erhöhen)
*** 4. Mute: Mit ">>" Channel auswählen (Großes Zeichen), mit "<<" Mute toggeln
*** 5. Repeat: Default 1 - alle Lieder werden der Reihe nach abgespielt, 0 = Stop nach jedem Lied
*** 6. Backlight
* Aufnahmen am PC bearbeiten auf FAT16-Dateisystem
** Karte in PC stecken und Datei öffnen
* Aufnahmen am PC bearbeiten auf FAT32-Dateisystem (nicht besonders bequem)
** Karte mit HexEditor laden :-)
** Ab Sektor Startsektor und aufwärts nach "MThd" suchen lassen
** Kopiere den ersten Sektor mit "MThd" (10 Bytes) "MTrk" (4 weitere Bytes = Länge Big Endian) und die folgenden Länge/512 Sektoren in eine Datei (mit Endung .mid), löscht die letzten Bytes nach (Länge + 18) Bytes. Diese Datei sollte nun abspielbar und editierbar sein
* Alte Firmware-Update-Methode
** PC mit Mr. Midi 2 verbinden (seriell<->Midi-Konverter)
** An Mr. Midi 2 beliebige Taste (aber nicht << oder >>) gedrückt halten und einschalten (Bootloader)
** flash.bat aufrufen

Erweiterung für IR-Ferbedienung:
[[Bild:Aldiremote.jpg|thumb|400px|left|ALDI-Universal-Fernbedienung]]
* RC5-Code, Geräteklasse Videorecorder (wegen der Play/Stop/Rec/Spul-Tasten) :-)
* Probiert mit Aldi-Fernbedienung aus dem 4. Quartal 2006 mit Gerätecode 257
* Änderung im Schaltplan: PB2 wird mit einem TSOP1836 verbunden, PB7 mit der Playtaste
* Tastenbelegung: Play/Rec/Stop/<</>> wie gewohnt, Menu=Menü, ENT=Löschen, Ziffern für Direktwahl eines Songs. Dabei gilt: Anzahl Songs unter 10 -> Ziffer startet direkt das Lied (0 = Song #10), ansonsten zweistellige Eingabe.

Erweiterung FAT16:
* Dateinamen werden angezeigt, sogar lange Dateinamen werden erkannt
* Datei löschen jeder beliebigen Datei, nicht nur die letzte
* Aufnahmen erzeugen Dateien mit Namen "MM001.MID", Nummer wird hochgezählt
* Aufnahmen können im Explorer kopiert und am PC geöffnet werden
* FAT32-Karten werden im "alten" Modus behandelt (Kein FAT-Eintrag erfolgt, nur immer die letzte Datei wird gelöscht, wenn man Löschen drückt)

Repeatmodi beim Abspielen:
* 0=Einzeln abspielen und Stopp am Ende des Songs
* 1=Einzelnen Song wiederholen
* 2=Alle Songs der Reihe nach abspielen, Stopp nach dem letzten Lied
* 3=Alle Songs der Reihe nach abspielen, dann von vorne anfangen
* 4=Zufälliges Lied

=== Build ===
Projekt kompilieren mit WinAVR 20070525 [http://winavr.sourceforge.net/download.html] + AVR Studio 4.13 [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725].
Debuggen mit dem ATAVRDragon über DebugWire.

=== Ausblick ===
* Vielleicht kommt ja noch irgendwann eine echte FAT16 oder 32 rein (mit ATmega168, da pin-kompatibel). ERLEDIGT für FAT16
* Volle FAT16-Unterstützung mit fragmentierten Dateien mit Unterordner. ERLEDIGT
* Sendepuffer, um FAT-Zugriffe während MIDI-Wiedergabe zeitlich unkritisch zu machen. ERLEDIGT
* Bootloader von MMC/SD-Karte. ERLEDIGT
* FAT32 vielleicht auch mal. Platz im ATmega168 reicht wohl eher nicht aus, hab gerade noch 3kByte im Flash frei (ohne Bootloader).
* 32-Bit-Sektoradressierung für große Karten. ERLEDIGT

=== Hinweise ===
Es handelt sich hier um ein vollständiges privates Bastelprojekt. Es werden keinerlei Funktionsgarantien oder Haftung für Fehler und deren Folgen übernommen. Nachbau und Benutzung erfolgen auf eigene Gefahr.

Zur Kompatibilität von MMC/SD-Karten:
Meine Versuche haben ergeben, dass die Spannungsteiler mit Widerständen für die Ansteuerung der Karte zu unterschiedlichen Ergebnissen führen: Die eine Karte geht nicht im einen Gerät, dafür im anderen, dafür ist es bei einer anderen Karte genau umgekehrt!
Die Spannungsversorgung der Karte ist jedoch mittels Spannungsregler auf 3,3V eingestellt.
Die 16MB-Karte von Canon (Kamera-Beipack) wird vom PC in den FATs anders geschrieben. Warum, weiß ich nicht! Daher sind Aufzeichnungen von MrMidi2 auf diese Karte für den PC nicht lesbar.

Die 128MB-Medion-Karte ist eine SanDisk-Karte (wenn man den Deckel runterbricht, steht das auf den Chips drauf)!

=== Vorschläge ===
Hier darf jeder Besucher der Seite selber Vorschläge im Rahmen dieses Projektes einbringen (durch Bearbeiten dieses Abschnitts im Wiki):
* Um Pins für weitere Funktionen zur Verfügung zu haben, wäre es möglich einen 8-Line To 3-Line Priority Encoder (z.B.SN74LS348) für die Taster einzusetzen.
* Von den freigewordenenen 4 Pins könnte dann einer verwendet werden, um die Beleuchtung der LCD-Anzeige mittels Transistor ein/auszuschalten.
* Dazu sollten für das LCD-Display die Pins 15 (Vcc Beleuchtung) und Pin 15 (GND Beleuchtung) hinzugefügt werden.
* Der Quarz könnte somit parallel zur Beleuchtung betrieben werden :-)

=== Quellen (OpenSource) ===
* [http://www.roboternetz.de/wissen/index.php/RC5-Decoder_f%C3%BCr_ATMega] RC5-Code
* [http://alpmp3.sourceforge.net/main.php?id=license] Low-Level-Card-Treiber (von mir modifiziert und erweitert)
* [http://www.mikrocontroller.net/articles/AVR-Tutorial:_LCD] AVR-LCD-Ansteuerung in Assembler (von mir nach C portiert und erweitert)
* Der große Rest (FAT-Unterstützung, Midi-Protokoll-Implementierung, Bedienfunktionen) ich (Simon Lehmayr)

=Links=
* [http://www.lehmayr.de/e_mrmidi.htm] Englischsprachige Beschreibung des Projekts auf meiner Homepage
* [http://www.sdmidicontroller.com/] Offizieller Hardware-Nachbau als Fertiggerät oder Bausatz (aus England, basiert auf der neuesten MrMidi2-Version mit IR-Remote und MMC/SD-Card-Bootloader). Dieses Gerät wird von mir offiziell unterstützt und es enthält die aktuelle (und bug-bereinigte, feature-strotzende) Firmware. Mein Dank gilt Robert Rushton, der mein kleines Hobby-Projekt professionell vertreibt, für alle, die nicht über die nötigen Fertigkeiten verfügen, so etwas selber zu basteln!
* [http://www.borg.com/~jglatt/progs/software.htm] Gratis Mididatei-Konverter zwischen Format 0, 1 und 2. Kann auch ganze Ordner konvertieren!

==Forum==
* [http://www.mikrocontroller.net/forum/read-4-90091.html Midirekorder auf Static-RAM]
* [http://www.mikrocontroller.net/forum/read-4-102185.html Forumsbeiträge von Mr.Midi 1]
* [http://www.mikrocontroller.net/forum/read-4-349932.html Reverse-Piano (sorgt für eine spiegelverkehrte Tastatur)]
* [http://www.mikrocontroller.net/forum/read-4-354083.html Mr.MidiPlayer (spielt echte Mididateien von SD/MMC-Karten ab)]

[[Category:Projekte]][[Category:Audio]]

Diskussion:Soft-PWM

2008-01-10T15:43:41Z

FalkB:

Vielleicht wärs nicht schlecht auch noch drauf hinzuweise, dass man duch ein einfaches bit-reverse die Schaltfrequenz auf die Timer-Zykluszeit hochbringen kann... Damit ist dann das obligatorische Filtern viel einfacher...

Ich hab leider keinen passenden Link gefunden der das illustriert aber mann man ja recht einfach nachprüfen...

Den Zählerwert mit dieser Tabelle
<c>
static const unsigned char BitReverseTable256[] =
{
0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
};
</c>

und dann vergleicht man eigentlich BitReverseTable256[ZÄHLERWERT] mit dem eingestellten PWM-Wert...

Wenn man jetzt z.b 50% dutycycle betrachtet erkennt man schon ganz deutlich die Verbesserung:
bei jedem Vergleich wird getoggelt!

Warum kein einziger Controller den ich kenne sowas macht versteh ich nicht...

Derzeit bastle ich an einer einfachen Motorsteuerung und da wird eben ein DC-Motor per PWM vergewaltigt.
Software-PWM deshalb weil ich den Timer sowieso zur Zeitmessung verwende..
Mit dieser Methode hab' ich jetzt eine Schaltfrequenz am Motor von 14kHz :)

73

----

>Vielleicht wärs nicht schlecht auch noch drauf hinzuweise, dass man duch ein >einfaches bit-reverse die Schaltfrequenz auf die Timer-Zykluszeit hochbringen >kann... Damit ist dann das obligatorische Filtern viel einfacher...

Das nennt sich Puls-DICHTE-Modulation

>Wenn man jetzt z.b 50% dutycycle betrachtet erkennt man schon ganz deutlich die >Verbesserung:
>bei jedem Vergleich wird getoggelt!

Fast.

>Warum kein einziger Controller den ich kenne sowas macht versteh ich nicht...

Für PWM/PDM zur Erzeugung von Referenzspannungen für ADC, whatever ist das ganz nützlich. Aber . . .

>Derzeit bastle ich an einer einfachen Motorsteuerung und da wird eben ein >DC-Motor per PWM vergewaltigt.
>Software-PWM deshalb weil ich den Timer sowieso zur Zeitmessung verwende..
>Mit dieser Methode hab' ich jetzt eine Schaltfrequenz am Motor von 14kHz :)

Eben für Leistungsendstufen ist das quasi unbrauchbar, weil dann die Schaltverluste zu hoch werden, weil zu oft geschaltet wird.

MFG
Falk

Sleep Mode

2008-01-09T12:08:45Z

FalkB: /* Überlick über alle Sleep Modes der AVRs */ Tabelle erweitert

== Einleitung ==

Auf deutsch Schlafmodus. Damit bezeichnet man den Zustand eines [[Mikrocontroller]]s, in dem verschiedene Funktionsblöcke ausgeschaltet sind ([[Timer]], [[UART]], [[AD-Wandler]] etc.) um Strom zu sparen. Das ist vor allem in [[Versorgung aus einer Zelle | batteriebetriebenen]] Geräten wichtig. Denn schließlich will man ja ein möglichst lange Laufzeit mit einer möglichst kleinen Batterie erreichen.

Mit dem Sleep Mode eng verknüpft ist [[Ultra low power]] Design. Man muß viele Dinge beachten, um nicht unnötig Strom zu verbrauchen. Z. B. werden in vielen Geräten über lange Zeiträume Daten erfaßt (Datenschreiber). Dabei werden meist relativ wenig Daten in sehr langen Zeitabständen aufgezeichnet und gespeichert. Zwischendurch gibt es für den Mikrocontroller meist nichts zu tun. Dann ist es nicht sinnvoll mit Warteschleifen Zeit zu vertrödeln. Das geht wesentlich stromsparender.

Die Ausführungen dieses Wikiartikels beziehen sich auf den [[AVR]] ATmega32. Prinzipiell gilt das Gesagte auch für viele andere Mikrocontroller ([[MSP430]], [[8051]] etc.), die Details muß man jedoch in den jeweiligen Datenblättern nachlesen. Bei den verschiedenen AVR Modellen findet man diese Informationen im Datenblatt unter der Überschrift "Power Management and Sleep Modes".

== Anwendung ==

[[Bild:Sleep_mode_ablauf.png|framed|Flussdiagramm]] Das Prinzip ist immer gleich. Nach Initialisierung des Mikrocontrollers und eventuell angeschlossener ICs ([[LCD]], [[I2C]]-EEPROM etc.) geht der Prozessor in eine Endlosschleife, in welcher die verschiedenen Aufgaben zyklisch bearbeitet werden. Wenn jedoch gerade nichts zu tun ist geht der Prozessor schlafen. Ein Interrupt weckt ihn, der Interrupt wird ausgeführt und er setzt seine Arbeit in der Hauptschleife fort. Das heißt aber auch, daß vor dem Eintritt in den Sleep-Mode die jeweiligen Interrupts freigegeben werden müssen und auch die entsprechenden Interruptroutinen bereitgestellt werden müssen. Sonst gibt es im wahrsten Sinne des Wortes ein böses Erwachen oder einen endlosen Dornröschenschlaf, der nur durch ein Reset beendet werden kann. Kurz bevor der Mikrocontroller schlafen geht, sollte man möglichst alle Module abschalten, welche nicht gebraucht werden, um wertvollen Strom zu sparen. Dazu zählen

* der Brown Out Detector (per [[AVR Fuses]] einschaltbar)
* der Analogcomparator
* interne AD-Referenz
* Watchdog
* [[UART]]
* [[Timer]]

Weitere Hinweise zum Stromsparen gibt es im Artikel [[Ultra low power]].

 

== Überlick über alle Sleep Modes der AVRs ==

{| border="1"
! Sleep Mode || Verfügbare Module || Stromaufnahme 3,3V/1 MHz || Weckruf || Aufwachzeit [Takte] || Bemerkung
|-
| Active || alle
|align ="center"| 1,2mA || alle
|align ="center"| 0
| -
|-
| Idle || alle
|align ="center"| 0,3mA || alle
|align ="center"| 6
| -
|-
| ADC Noise Reduction || ADC Timer 2 ext. Interrupts TWI Watchdog
|align ="center"| ca. 0,3mA || ADC Timer 2 ext. '''level''' Interrupt TWI Address match Brown Out Detector Reset External Reset Watchdog Reset
|align ="center"| 6
| -
|-
| Power Save || Timer 2 ext. Interrupts TWI Watchdog
|align ="center"| 10μA || Timer 2 ext. '''level''' Interrupt TWI Address match Brown Out Detector Reset External Reset Watchdog Reset
|align ="center"| siehe [[#Morgenmuffel | hier]]
| Timer2 mit 32,768 kHz Uhrenquarz aktiv
|-
| Stand By || ext. Interrupts TWI Watchdog
|align ="center"| 35μA || ext. '''level''' Interrupt TWI Address match Brown Out Detector Reset External Reset Watchdog Reset
|align ="center"| 6
| Hauptoszillator aktiv
|-
| Power Down || ext. Interrupts TWI Watchdog
|align ="center"| 0,3μA ||ext. '''level''' Interrupt TWI Address match Brown Out Detector Reset External Reset Watchdog Reset
|align ="center"| siehe [[#Morgenmuffel | hier]]
| -
|}

== Die verschiedenen Sleep Modes im Detail ==

=== Active Mode ===

Eigentlich ist das kein Sleep Mode, er soll der Vollständigkeit halber aber genannt werden. In diesem Modus sind alle Takte und alle Module aktiv, zumindest die, die man per Programm aktiviert hat. In diesem Modus ist die CPU ständig am arbeiten, auch wenn es nur eine lange Warteschleife ist. Warten kostet genauso viel Strom wie sinnvolle Dinge berechnen! Dadurch werden auch ständig Daten aus dem [[Speicher#Flash-ROM | Flash]] geladen, nämlich das Programm, welches gerade ausgeführt wird. Das kostet natürlich Strom, wenn gleich auch die Mikrocontroller von heute sehr wenig brauchen. Bei 1 MHz und 3.3V braucht der ATmega ca. 1,2mA, zu finden im Datenblatt unter "ATmega8 Typical Characteristics".

=== Idle Mode ===

Hier kann zum ersten mal gespart werden. Wenn nichts berechnet werden soll, der Timer, UART, ADC etc. aber arbeiten sollen, dann ist dieser Modus das Mittel der Wahl. Die CPU bleibt stehen, ebenso der Flash, weil ja kein Programm ausgeführt wird. Das spart schon mal einiges, der Stromverbrauch sinkt auf ca. 0,35mA, eine Einsparung von 70%! Aus diesem Modus kann jeder Interrupt die CPU wieder wecken. Sie ist dann bereits nach sechs Takten wieder voll einsatzfähig.

=== ADC Noise Reduction Mode ===

Dieser Modus geht einen kleinen Schritt weiter als der Idle Mode. Hier wird zusätzlich der Takt für die IO-Module abgeschaltet. Nur noch der [[AD-Wandler]], die exteren Interrupts, das [[TWI]] und der Watchdog sind funktionsfähig (wenn man sie nutzen will). Der [[UART]] und Timer0 bzw. Timer1 sind nicht mehr nutzbar. Wie der Name des Sleep Mode vermuten lässt wird das alles getan, um möglichst wenig Störungen mit den internen Modulen zu erzeugen, um die Messung des ADC geringfügig zu verbessern.

=== Power Save Mode ===

Hier werden fast alle Oszillatoren gestoppt. Die einzige Ausnahme ist der Timer 2, welcher asynchron mit einem 32,768 kHz Uhrenquarz betrieben werden kann. Ist er entsprechend konfiguriert, dann bleibt er beim Einschalten des Power Save Mode aktiv. Dieser Modus ist einer der wichtigsten! Da alle Oszillatoren gestoppt sind, funktionieren nur noch die asynchronen Module.

=== Stand By ===

Hier werden alle Takte auf dem IC angehalten. '''ABER!''' Der ausgewählte Hauptoszillator läuft weiter. Das kostet zwar etwas Strom, hat aber den Riesenvorteil, daß die CPU nach dem Aufwachen nach nur sechs Takten wieder zur Verfügung seht. Das klingt selbstverständlich, ist es aber nicht! Gerade Quarzoszillatoren haben auf Grund ihrer sehr hohen Güte (sehr schmalbandiger Schwingkreis) eine Einschwingzeit von 10..100ms! Eine kleine Ewigkeit. Dieser Modus ist ideal, wenn ein Quarz verwendet wird und kürzeste Reaktionszeiten nach dem Aufwecken nötig sind. Da alle Takte gestoppt sind, funktionieren nur noch die asynchronen Module.

=== Power Down Mode ===

Das ist der "tiefste" Sleep Mode. Dabei werden '''ALLE''' Oszillatoren gestoppt (intern wie extern). Nur noch asynchrone Module funktionieren jetzt noch und können den schlafenden AVR wecken. Die Stromaufnahme wird nur noch von den Leckströmen bestimmt und liegt typisch bei 300nA.

== Morgenmuffel ==

Im Power Save und Power Down Mode ist der Oszillator für die CPU gestoppt. Wird der AVR nun geweckt kann er leider nicht sofort loslegen. Warum? Weil der Oszillator erst anlaufen und sich stabil einschwingen muß. Während dieser Zeit darf die CPU noch nicht loslaufen, sonst kann es passieren, daß sie abstürzt! (Weil ein noch instabiler Oszillator ultrakurze Taktpulse erzeugen kann, an denen sich die CPU "verschluckt".) Wie bereits oben gesagt kann das Anschwingen eines Quarzoszillators sehr lange dauern. Je niedriger die Frequenz um so länger. Keramikresonatoren sind ca. zehn mal so schnell. Auch das ist ganz einfach physikalisch durch die Güte bestimmt. Sie sind breitbandiger, dadurch zwar ungenauer aber schwingen schneller an. Am schnellsten sind RC-Oszillatoren, leider sind sie aber auch die ungenauesten. Um nun die entsprechende Zeit zu warten wird der Watchdog-Oszillator verwendet. Darum muß man sich nicht direkt kümmern das macht der AVR allein. Aber man muß mittels der [[AVR Fuses]] festlegen, wieviel Takte gewartet werden soll. Die Frequenz des Watchdogoszillators beträgt ca. 1,15 MHz bei 3,3V Versorgungsspannung.

{| border ="1"
! Taktquelle || Wartezeit [Takte] || Wartezeit || typische Einschwingzeit
|-
| externer Quarz (1) || 16384 32768 || 14,2ms 28,4ms || 10ms, Uhrenquarze 100ms
|-
| externer Resonator (1) || 1024 16384 || 890μs 14,2ms || 1ms
|-
| externer Quarzoszillator || 6 || 5μs || Takt liegt konstant an
|-
| externer RC-Oszillator || 6 18 || 5μs 15μs || 1..3 Takte
|-
| interner RC-Oszillator || 6 || 5μs || 1..3 Takte
|}

(1) Es können für den Quarz bzw. Resonator auch niedigere Wartezeiten verwendet werden. Das ist jedoch nicht empfehlenswert. Näheres siehe Datenblatt.

== Ermittlung des Stromverbrauchs ==

Bei der Messung des Stromverbrauchs haben wir jedoch ein kleines Problem. Die Stromaufnahme eines Mikrocontrollers schwankt bei der Verwendung des Sleep Mode gewaltig. Denn oft wartet der Mikrocontroller im Schlafmodus auf ein Ereignis, z.B. einen Tastendruck. Wird eine Taste gedrückt arbeitet der Mikrocontroller beispielsweise für 100ms und geht dann wieder für Sekunden bis Tage schlafen. Die stoßartige Arbeitsweise (Burst) gleicht einer [[PWM]]. Das Problem ist dabei, daß man theoretisch mit einem Tiefpaß diese PWM filtern (glätten) muß um sie anschließend mit einem Multimeter zu messen. Aber wer will schon einen Tiefpaß mit einer Zeitkonstante von mehreren Minuten bis Tagen bauen und damit messen? Das Problem muß anders gelöst werden. Und das ist recht leicht.

* Mit einem Multimeter mißt man die Stromaufnahme im Sleep Mode (Mikroampere)
* Mit einem Reihenwiderstand von 10..100 Ohm in der Vcc Leitung des Mikrocontrollers und einem Oszilloskop kann die Stromaufnahme des Mikrocontrollers während der kurzen aktiven Arbeitsphase gemessen werden. Dazu braucht man nur das ohmsche Gesetz, I = U / R. Dabei nutzt man einen 1:1 Tastkopf, um eine maximale Spannungsauflösung zu ereichen. Ausserdem schaltet man den Eingang auf AC-Kopplung, da ja nur Pulse gemessen werden, keine Gleichspannungen. Damit kann man vor allem den Spannungsmessbereich sehr weit runter drehen.
* Der mittlere Stromverbrauch wird wie folgt berechnet

:<math>I_m = \frac {I_{sleep} \cdot t_{sleep} + I_{aktiv} \cdot t_{aktiv}}{t_{sleep} + t_{aktiv}} </math>

== Batterielebensdauer ==

Wie übersetzen sich nun diese Zahlen in eine Batterielebensdauer? Versorgt man den AVR über drei in Reihe geschaltete AAA [[Versorgung aus einer Zelle | Batterien]], kann man etwa folgende Abschätzung machen. Eine AAA Batterie (Mignom) hat eine Kapazität von ca. 1200mAh. D.H. Sie kann für 1200 Stunden (50 Tage) 1mA liefern. Oder für 12000 Stunden 0,1mA, das sind immerhin schon 500 Tage, also über sechzehn Monate! Nutzt man den Power Save Mode (10uA), dann reichen die Batterien bereits 120.000 Stunden, das sind theoretisch 13,7 Jahre! Natürlich sinkt während der Entladung die Batteriespannung, aber der Mega32 kann ja mit 2,7V betrieben werden, einige [[AVR]]-Typen sogar mit nur 1,8V. Ebenso wird es in 13 Jahren zu einer merklichen Selbstentladung der Batterien kommen, so daß die hier berechnete Zeit nicht erreicht wird. Real kann eher mit drei bis sieben Jahren gerechnet werden. Um eine hohe Lebensdauer zu erreichen müssen dann Lithiumbatterien verwendet werden, welche eine extrem geringe Selbstentladung haben und eine Lebensdauer von 10 Jahren erreichen.

Wenn man wirklich das allerletzte Mikroampere einsparen will und dennoch quarzgenau eine Zeitbasis benötigt, dann verwendet man eine '''R'''eal '''T'''ime '''C'''lock (RTC, Echtzeituhr), wie z.B. [http://datasheets.maxim-ic.com/en/ds/DS1371.pdf DS1371]. Dieser Baustein arbeitet auch mit einem 32,768 kHz Uhrenquarz, ist aber extrem auf Stromsparen optimiert (Stromverbrauch 800..1100nA). Gleichzeitig ist eine Uhr und Weckfunktion eingebaut. Ausgelesen werden kann sie über den [[I2C]]-[[Bus]]. Diese RTC kann den Mikrocontroller periodisch nach einer bestimmten Zeit (Sekunden bis Tage) über einen externen Interrupt wecken. Damit kann der Mikrocontroller in den Power Down Mode gehen und maximal Strom sparen. So eine Kombination aus AVR und RTC verbraucht dann nur noch ca. 1400nA! Eine kleine 3V Lithiumzelle mit 100mAh reicht dann unglaubliche 71.400 Stunden = 8 Jahre!

'''Allgemein gilt:'''

:<math>Lebensdauer [h] = \frac {Kapazitaet [Ah] }{Strom [A]}</math>

Zu beachten ist, daß diese Formel nur für relativ geringe Entladeströme gilt, typisch bei einer Entladung über 20 Stunden oder länger. Will man hohe Ströme in einer kurzen Zeit entnehmen, sinkt die verfügbare Kapazität. Genaueres findet man dazu [http://www.amplepower.com/pwrnews/beer/ hier] und im Datenblatt der Batterien.

== Beispiele ==

Die Beispiele sind mit WINAVR 20060421 compiliert und getestet worden. Zur Nutzung des Sleep Mode werden zwei C-Funktionen zur Verfügung gestellt, set_sleep_mode() und sleep_mode(). Genaueres hierzu findet man in der Dokumentation der libc im WINAVR. Alle Programme wurden mit Optimierungsstufe -Os compiliert.

=== UART Terminal ===

Soll der UART verwendet werden kommt nur der Idle Mode in Frage. In diesem Beispiel wird der AVR genutzt um Zeichen von der [[RS232]] Schnittstelle zu empfangen und per Morsezeichen auszugeben. Als Hauptoszillator wird ein 3,6864 MHz Quarz eingesetzt, wie für eine zuverlässige UART-Kommunikation notwendig ist. Siehe auch [[AVR-Tutorial: UART | AVR-Tutorial]], [[AVR Checkliste#UART.2FUSART | AVR Checkliste]] und [[AVR-GCC-Tutorial#Der_UART | AVR-GCC-Tutorial]]. Im Sleepmode verbraucht der AVR ca. 1,9mA, im aktiven Zustand mit eingeschalteter LED ca. 7,3mA.

<c>
/*
************************************************************************
*
* Sleep Mode Demo, Idle Mode
*
* ATmega32 mit externem 3,6864 MHz Quarz an XTAL1/XTAL2
*
* LOW Fuse Byte = 0xFF
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
* An PD0 ist ein MAX232 angeschlosssen, um Daten vom PC zu empfangen
*
************************************************************************
*/

#define F_CPU 3686400 // Taktfrequenz des Quarzes

#define BAUD 9600L // Baudrate, das L am Ende ist wichtig, NICHT UL verwenden!

// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1))) // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000) // Fehler in Promille

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// globale Variablen

volatile uint8_t uart_flag;
volatile uint8_t uart_data;

// lange, variable Wartezeit, Einheit in Millisekunden

void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

// Ein Byte als "Morsezeichen" auf eine LED ausgeben

void morse(uint8_t data) {
uint8_t i,j;

for(i=0; i<8; i++) {
if (data & 0x01) // Prüfe Bit #0
j=250; // Bit ist 1
else
j=100; // Bit ist 0

PORTD |= (1 << PD5); // LED an
long_delay(j);
PORTD &= ~(1 << PD5); // LED aus
long_delay(1000-j);
data >>= 1; // nächstes Bit auf Bit #0 schieben
}
}

int main (void) {

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFF;

// UART konfigurieren

UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
UCSRB = (1<<RXCIE) | (1<<RXEN);

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_mode(); // in den Schlafmodus wechseln

// hier wachen wir wieder auf
if (uart_flag==1) {
uart_flag =0;
morse(uart_data);
}
}
}

// UART RX complete interrupt

ISR(USART_RXC_vect) {
uart_flag = 1; // signalisiere neue Daten
uart_data = UDR; // Daten auslesen, dadurch wird auch der Interrupt gelöscht
}
</c>

=== Quarzgenaue Zeitbasis ===

Hier kommt der Power Save Mode zum Einsatz. Als Zeitbasis dient ein externer 32,768 kHz Uhrenquarz, welcher asynchron den Timer 2 taktet. Das ist zwar nur ein 8 Bit Zähler, der schon nach 256 Takten überläuft, aber es gibt ja zum Glück noch den Vorteiler (Prescaler). Dieser kann die Teilerverhältnisse 1/8/32/256/1024 annehmen, daraus ergeben sich Überlaufzeiten von 7,8125ms/62,5ms/500ms/2s/8s. Werden längere Zeiten benötigt muß man diese in Software nachbilden. Z. B. kann man mit einem zwei Sekunden Intervall in einer Variable bis 30 zählen um exakt eine Minute zu erhalten. Die 30 mal aufwachen, Variable hochzählen und wieder in den Sleep Mode schalten fallen praktisch nicht ins Gewicht, das dauert nur einige Dutzend Mikrosekunden.

Das hier gezeigte Beispiel ist sehr einfach gehalten, zeigt aber deutlich die Vorgehensweise. Im quarzgenauen Zeitraster von einer Minute wird eine LED für zwei Sekunden eingeschaltet. In den realen Anwendungen wird natürliche eine Messung etc. gemacht.

<c>
/*
************************************************************************
*
* Sleep Mode Demo, Power Save Mode
*
* ATmega32 mit internem 1 MHz Oszillator + 32 kHz Quarz
*
* LOW Fuse Byte = 0xE1
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
* An TOSC1/TOSC2 muss ein 32,768 kHz Quarz angeschlossen sein
*
************************************************************************
*/

#define F_CPU 1000000

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// globale Variablen

volatile uint8_t flag;

// lange, variable Wartezeit, Einheit in Millisekunden

void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

int main (void) {

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFF;

// Analogcomparator ausschalten

ACSR = 0x80;

// Timer2 konfigurieren

ASSR = (1<< AS2); // Timer2 asynchron takten
long_delay(1000); // Einschwingzeit des 32kHz Quarzes
TCCR2 = 6; // Vorteiler 256 -> 2s Überlaufperiode
while((ASSR & (1<< TCR2UB))); // Warte auf das Ende des Zugriffs
TIFR &= ~(1<<TOV2); // Interrupts löschen
TIMSK |= (1<<TOIE2); // Timer overflow Interrupt freischalten

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {

// WICHTIG!
// Wenn der Timer2 im asynchronen Modus periodisch zum Wecken aus dem Sleep Mode
// genutzt wird, dann muss vor dem Wiedereintritt mindestens
// 1 Oszillatortakt des Timers abgewartet werden (~30us), um die Interruptlogik
// wieder zu aktivieren, anderenfalls wacht der AVR nicht mehr auf.
// Die folgenden zwei Zeilen tun dies.
// Nur wenn sichergestellt ist, dass der Interrupt + Hauptschleife länger als 30us dauern,
// kann man den Test weglassen

OCR2 = 0; // Dummyzugriff
while((ASSR & (1<< OCR2UB))); // Warte auf das Ende des Zugriffs

set_sleep_mode(SLEEP_MODE_PWR_SAVE);
sleep_mode(); // in den Schlafmodus wechseln

// hier wachen wir wieder auf, nach Ausführung des Interupts

if (flag==1) { // Neues Messintervall ?
flag =0;
PORTD |= (1 << PD5); // LED für eine Sekunde anschalten
}
}
}

// Timer2 overflow Interrupt

ISR(TIMER2_OVF_vect) {
static uint8_t ticks; // Hilfsvariable für Messintervall

ticks++;
if (ticks==30) { // neues Messintervall ?
ticks=0;
flag=1;
}
PORTD &= ~(1 << PD5); // LED ausschalten
}
</c>

Im Sleep Mode beträgt die Stromaufnahme des AVR ca. 10μA, während der zwei Sekunden LED Leuchtdauer 2,3mA. Dadurch ergibt sich ein mittlerer Stromverbrauch von

:<math>I_m = \frac {10 \mu A \cdot 58s + 2,3mA \cdot 2s}{60s} = 86,3 \mu A</math>

Korrekterweise müßte man jedoch noch den Stromverbrauch berücksichtigen, welcher bei jedem Timerüberlauf alle zwei Sekunden entsteht. Dabei wird einmal der Timerinterrupt durchlaufen sowie einmal die Hauptschleife. Das dauert hier ca. 50 Takte, bei 1 MHz somit 50μs. Zusätzlich wird noch bis zu 30us gewartet, um garantiert einen Takt im Timer 2 vergehen zu lassen. Das passiert pro Minute 30 mal, somit erhöht sich der mittlere Stromverbrauch um

:<math>\frac {30 \cdot 80 \mu s \cdot 1,2mA}{60s}= 48nA</math> , was somit praktisch vollkommen vernachlässigbar ist.

=== Aufwachen per Tastendruck ===

Maximale Einsparung an Energie bringt der Power Down Modus. Das Aufwecken muß dann aber durch eine levelsensitiven externen Interrupt erfolgen. Ein flankensensitiver Interrupt ist nicht möglich! Auch hier blinkt eine LED.

<c>
/*
************************************************************************
*
* Sleep Mode Demo, Power Down Mode
*
* ATmega32 mit internem 1 MHz Oszillator
*
* LOW Fuse Byte = 0xE1
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
* An PD2 muss ein Taster gegen GND angeschlossen sein
*
************************************************************************
*/

#define F_CPU 1000000

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// lange, variable Wartezeit, Einheit in Millisekunden

void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

int main (void) {

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFB; // PD2 = INT0 = Eingang
PORTD = 0x04; // Pull Up aktivieren

// Analogcomparator ausschalten

ACSR = 0x80;

// Interrupt konfigurieren

MCUCR &= ~0x3; // levelgesteuerter Interrupt an INT0

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {

GICR |= (1 << INT0); // externen Interrupt freigeben

set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode(); // in den Schlafmodus wechseln

// hier wachen wir wieder auf
GICR &= ~(1 << INT0); // externen Interrupt sperren
// WICHTIG! falls der externe LOW Puls an INT0
// sehr lange dauert

PORTD |= (1 << PD5); // LED für eine Sekunde anschalten
long_delay(1000);
PORTD &= ~(1 << PD5);
}
}

// externer Interrupt INT0

// Die Interruptroutine kann leer sein, ABER sie muss existieren!
// Sonst springt der AVR nach dem Aufwachen zum Reset, weil kein sinnvoller
// Interruptvektor eingetragen ist!

ISR(INT0_vect) {
}
</c>

Im Power Down Mode beträgt die Stromaufnahme des AVR weniger als 1μA (weniger konnte mit dem verfügbaren Messgerät nicht gemessen werden), laut Datenblatt ca. 0,3μA. Während der einen Sekunde LED Leuchtdauer werden 3,8mA verbraucht. Wird einmal pro Minute die Taste gedrückt, ergibt sich ein mittlerer Stromverbrauch von

:<math>I_m = \frac {0,3 \mu A \cdot 59s + 3,8mA \cdot 1s}{60s} = 63,6 \mu A</math>

Wird nur einmal pro Stunde die Taste gedrückt, ergibt sich ein mittlerer Stromverbrauch von

:<math>I_m = \frac {0,3 \mu A \cdot 3559s + 3,8mA \cdot 1s}{3660s} = 1,3 \mu A</math>

== Bauteile ==

* [http://datasheets.maxim-ic.com/en/ds/DS1371.pdf DS1371], Echtzeituhr mit 1μA Stromverbrauch

== Links ==

* TODO

[[Category:AVR]]

Sleep Mode

2008-01-09T11:37:06Z

FalkB:

== Einleitung ==

Auf deutsch Schlafmodus. Damit bezeichnet man den Zustand eines [[Mikrocontroller]]s, in dem verschiedene Funktionsblöcke ausgeschaltet sind ([[Timer]], [[UART]], [[AD-Wandler]] etc.) um Strom zu sparen. Das ist vor allem in [[Versorgung aus einer Zelle | batteriebetriebenen]] Geräten wichtig. Denn schließlich will man ja ein möglichst lange Laufzeit mit einer möglichst kleinen Batterie erreichen.

Mit dem Sleep Mode eng verknüpft ist [[Ultra low power]] Design. Man muß viele Dinge beachten, um nicht unnötig Strom zu verbrauchen. Z. B. werden in vielen Geräten über lange Zeiträume Daten erfaßt (Datenschreiber). Dabei werden meist relativ wenig Daten in sehr langen Zeitabständen aufgezeichnet und gespeichert. Zwischendurch gibt es für den Mikrocontroller meist nichts zu tun. Dann ist es nicht sinnvoll mit Warteschleifen Zeit zu vertrödeln. Das geht wesentlich stromsparender.

Die Ausführungen dieses Wikiartikels beziehen sich auf den [[AVR]] ATmega32. Prinzipiell gilt das Gesagte auch für viele andere Mikrocontroller ([[MSP430]], [[8051]] etc.), die Details muß man jedoch in den jeweiligen Datenblättern nachlesen. Bei den verschiedenen AVR Modellen findet man diese Informationen im Datenblatt unter der Überschrift "Power Management and Sleep Modes".

== Anwendung ==

[[Bild:Sleep_mode_ablauf.png|framed|Flussdiagramm]] Das Prinzip ist immer gleich. Nach Initialisierung des Mikrocontrollers und eventuell angeschlossener ICs ([[LCD]], [[I2C]]-EEPROM etc.) geht der Prozessor in eine Endlosschleife, in welcher die verschiedenen Aufgaben zyklisch bearbeitet werden. Wenn jedoch gerade nichts zu tun ist geht der Prozessor schlafen. Ein Interrupt weckt ihn, der Interrupt wird ausgeführt und er setzt seine Arbeit in der Hauptschleife fort. Das heißt aber auch, daß vor dem Eintritt in den Sleep-Mode die jeweiligen Interrupts freigegeben werden müssen und auch die entsprechenden Interruptroutinen bereitgestellt werden müssen. Sonst gibt es im wahrsten Sinne des Wortes ein böses Erwachen oder einen endlosen Dornröschenschlaf, der nur durch ein Reset beendet werden kann. Kurz bevor der Mikrocontroller schlafen geht, sollte man möglichst alle Module abschalten, welche nicht gebraucht werden, um wertvollen Strom zu sparen. Dazu zählen

* der Brown Out Detector (per [[AVR Fuses]] einschaltbar)
* der Analogcomparator
* interne AD-Referenz
* Watchdog
* [[UART]]
* [[Timer]]

Weitere Hinweise zum Stromsparen gibt es im Artikel [[Ultra low power]].

 

== Überlick über alle Sleep Modes der AVRs ==

{| border="1"
! Sleep Mode || Verfügbare Module || Stromaufnahme 3,3V/1 MHz || Weckruf || Aufwachzeit [Takte]
|-
| Active || alle
|align ="center"| 1,2mA || alle
|align ="center"| 0
|-
| Idle || alle
|align ="center"| 0,3mA || alle
|align ="center"| 6
|-
| ADC Noise Reduction || ADC Timer 2 ext. Interrupts TWI Watchdog
|align ="center"| ca. 0,3mA || ADC Timer 2 ext. '''level''' Interrupt TWI Address match Brown Out Detector Reset External Reset Watchdog Reset
|align ="center"| 6
|-
| Power Save || Timer 2 ext. Interrupts TWI Watchdog
|align ="center"| 10μA || Timer 2 ext. '''level''' Interrupt TWI Address match Brown Out Detector Reset External Reset Watchdog Reset
|align ="center"| siehe [[#Morgenmuffel | hier]]
|-
| Stand By || ext. Interrupts TWI Watchdog
|align ="center"| 35μA || ext. '''level''' Interrupt TWI Address match Brown Out Detector Reset External Reset Watchdog Reset
|align ="center"| 6
|-
| Power Down || ext. Interrupts TWI Watchdog
|align ="center"| 0,3μA ||ext. '''level''' Interrupt TWI Address match Brown Out Detector Reset External Reset Watchdog Reset
|align ="center"| siehe [[#Morgenmuffel | hier]]
|}

== Die verschiedenen Sleep Modes im Detail ==

=== Active Mode ===

Eigentlich ist das kein Sleep Mode, er soll der Vollständigkeit halber aber genannt werden. In diesem Modus sind alle Takte und alle Module aktiv, zumindest die, die man per Programm aktiviert hat. In diesem Modus ist die CPU ständig am arbeiten, auch wenn es nur eine lange Warteschleife ist. Warten kostet genauso viel Strom wie sinnvolle Dinge berechnen! Dadurch werden auch ständig Daten aus dem [[Speicher#Flash-ROM | Flash]] geladen, nämlich das Programm, welches gerade ausgeführt wird. Das kostet natürlich Strom, wenn gleich auch die Mikrocontroller von heute sehr wenig brauchen. Bei 1 MHz und 3.3V braucht der ATmega ca. 1,2mA, zu finden im Datenblatt unter "ATmega8 Typical Characteristics".

=== Idle Mode ===

Hier kann zum ersten mal gespart werden. Wenn nichts berechnet werden soll, der Timer, UART, ADC etc. aber arbeiten sollen, dann ist dieser Modus das Mittel der Wahl. Die CPU bleibt stehen, ebenso der Flash, weil ja kein Programm ausgeführt wird. Das spart schon mal einiges, der Stromverbrauch sinkt auf ca. 0,35mA, eine Einsparung von 70%! Aus diesem Modus kann jeder Interrupt die CPU wieder wecken. Sie ist dann bereits nach sechs Takten wieder voll einsatzfähig.

=== ADC Noise Reduction Mode ===

Dieser Modus geht einen kleinen Schritt weiter als der Idle Mode. Hier wird zusätzlich der Takt für die IO-Module abgeschaltet. Nur noch der [[AD-Wandler]], die exteren Interrupts, das [[TWI]] und der Watchdog sind funktionsfähig (wenn man sie nutzen will). Der [[UART]] und Timer0 bzw. Timer1 sind nicht mehr nutzbar. Wie der Name des Sleep Mode vermuten lässt wird das alles getan, um möglichst wenig Störungen mit den internen Modulen zu erzeugen, um die Messung des ADC geringfügig zu verbessern.

=== Power Save Mode ===

Hier werden fast alle Oszillatoren gestoppt. Die einzige Ausnahme ist der Timer 2, welcher asynchron mit einem 32,768 kHz Uhrenquarz betrieben werden kann. Ist er entsprechend konfiguriert, dann bleibt er beim Einschalten des Power Save Mode aktiv. Dieser Modus ist einer der wichtigsten! Da alle Oszillatoren gestoppt sind, funktionieren nur noch die asynchronen Module.

=== Stand By ===

Hier werden alle Takte auf dem IC angehalten. '''ABER!''' Der ausgewählte Hauptoszillator läuft weiter. Das kostet zwar etwas Strom, hat aber den Riesenvorteil, daß die CPU nach dem Aufwachen nach nur sechs Takten wieder zur Verfügung seht. Das klingt selbstverständlich, ist es aber nicht! Gerade Quarzoszillatoren haben auf Grund ihrer sehr hohen Güte (sehr schmalbandiger Schwingkreis) eine Einschwingzeit von 10..100ms! Eine kleine Ewigkeit. Dieser Modus ist ideal, wenn ein Quarz verwendet wird und kürzeste Reaktionszeiten nach dem Aufwecken nötig sind. Da alle Takte gestoppt sind, funktionieren nur noch die asynchronen Module.

=== Power Down Mode ===

Das ist der "tiefste" Sleep Mode. Dabei werden '''ALLE''' Oszillatoren gestoppt (intern wie extern). Nur noch asynchrone Module funktionieren jetzt noch und können den schlafenden AVR wecken. Die Stromaufnahme wird nur noch von den Leckströmen bestimmt und liegt typisch bei 300nA.

== Morgenmuffel ==

Im Power Save und Power Down Mode ist der Oszillator für die CPU gestoppt. Wird der AVR nun geweckt kann er leider nicht sofort loslegen. Warum? Weil der Oszillator erst anlaufen und sich stabil einschwingen muß. Während dieser Zeit darf die CPU noch nicht loslaufen, sonst kann es passieren, daß sie abstürzt! (Weil ein noch instabiler Oszillator ultrakurze Taktpulse erzeugen kann, an denen sich die CPU "verschluckt".) Wie bereits oben gesagt kann das Anschwingen eines Quarzoszillators sehr lange dauern. Je niedriger die Frequenz um so länger. Keramikresonatoren sind ca. zehn mal so schnell. Auch das ist ganz einfach physikalisch durch die Güte bestimmt. Sie sind breitbandiger, dadurch zwar ungenauer aber schwingen schneller an. Am schnellsten sind RC-Oszillatoren, leider sind sie aber auch die ungenauesten. Um nun die entsprechende Zeit zu warten wird der Watchdog-Oszillator verwendet. Darum muß man sich nicht direkt kümmern das macht der AVR allein. Aber man muß mittels der [[AVR Fuses]] festlegen, wieviel Takte gewartet werden soll. Die Frequenz des Watchdogoszillators beträgt ca. 1,15 MHz bei 3,3V Versorgungsspannung.

{| border ="1"
! Taktquelle || Wartezeit [Takte] || Wartezeit || typische Einschwingzeit
|-
| externer Quarz (1) || 16384 32768 || 14,2ms 28,4ms || 10ms, Uhrenquarze 100ms
|-
| externer Resonator (1) || 1024 16384 || 890μs 14,2ms || 1ms
|-
| externer Quarzoszillator || 6 || 5μs || Takt liegt konstant an
|-
| externer RC-Oszillator || 6 18 || 5μs 15μs || 1..3 Takte
|-
| interner RC-Oszillator || 6 || 5μs || 1..3 Takte
|}

(1) Es können für den Quarz bzw. Resonator auch niedigere Wartezeiten verwendet werden. Das ist jedoch nicht empfehlenswert. Näheres siehe Datenblatt.

== Ermittlung des Stromverbrauchs ==

Bei der Messung des Stromverbrauchs haben wir jedoch ein kleines Problem. Die Stromaufnahme eines Mikrocontrollers schwankt bei der Verwendung des Sleep Mode gewaltig. Denn oft wartet der Mikrocontroller im Schlafmodus auf ein Ereignis, z.B. einen Tastendruck. Wird eine Taste gedrückt arbeitet der Mikrocontroller beispielsweise für 100ms und geht dann wieder für Sekunden bis Tage schlafen. Die stoßartige Arbeitsweise (Burst) gleicht einer [[PWM]]. Das Problem ist dabei, daß man theoretisch mit einem Tiefpaß diese PWM filtern (glätten) muß um sie anschließend mit einem Multimeter zu messen. Aber wer will schon einen Tiefpaß mit einer Zeitkonstante von mehreren Minuten bis Tagen bauen und damit messen? Das Problem muß anders gelöst werden. Und das ist recht leicht.

* Mit einem Multimeter mißt man die Stromaufnahme im Sleep Mode (Mikroampere)
* Mit einem Reihenwiderstand von 10..100 Ohm in der Vcc Leitung des Mikrocontrollers und einem Oszilloskop kann die Stromaufnahme des Mikrocontrollers während der kurzen aktiven Arbeitsphase gemessen werden. Dazu braucht man nur das ohmsche Gesetz, I = U / R. Dabei nutzt man einen 1:1 Tastkopf, um eine maximale Spannungsauflösung zu ereichen. Ausserdem schaltet man den Eingang auf AC-Kopplung, da ja nur Pulse gemessen werden, keine Gleichspannungen. Damit kann man vor allem den Spannungsmessbereich sehr weit runter drehen.
* Der mittlere Stromverbrauch wird wie folgt berechnet

:<math>I_m = \frac {I_{sleep} \cdot t_{sleep} + I_{aktiv} \cdot t_{aktiv}}{t_{sleep} + t_{aktiv}} </math>

== Batterielebensdauer ==

Wie übersetzen sich nun diese Zahlen in eine Batterielebensdauer? Versorgt man den AVR über drei in Reihe geschaltete AAA [[Versorgung aus einer Zelle | Batterien]], kann man etwa folgende Abschätzung machen. Eine AAA Batterie (Mignom) hat eine Kapazität von ca. 1200mAh. D.H. Sie kann für 1200 Stunden (50 Tage) 1mA liefern. Oder für 12000 Stunden 0,1mA, das sind immerhin schon 500 Tage, also über sechzehn Monate! Nutzt man den Power Save Mode (10uA), dann reichen die Batterien bereits 120.000 Stunden, das sind theoretisch 13,7 Jahre! Natürlich sinkt während der Entladung die Batteriespannung, aber der Mega32 kann ja mit 2,7V betrieben werden, einige [[AVR]]-Typen sogar mit nur 1,8V. Ebenso wird es in 13 Jahren zu einer merklichen Selbstentladung der Batterien kommen, so daß die hier berechnete Zeit nicht erreicht wird. Real kann eher mit drei bis sieben Jahren gerechnet werden. Um eine hohe Lebensdauer zu erreichen müssen dann Lithiumbatterien verwendet werden, welche eine extrem geringe Selbstentladung haben und eine Lebensdauer von 10 Jahren erreichen.

Wenn man wirklich das allerletzte Mikroampere einsparen will und dennoch quarzgenau eine Zeitbasis benötigt, dann verwendet man eine '''R'''eal '''T'''ime '''C'''lock (RTC, Echtzeituhr), wie z.B. [http://datasheets.maxim-ic.com/en/ds/DS1371.pdf DS1371]. Dieser Baustein arbeitet auch mit einem 32,768 kHz Uhrenquarz, ist aber extrem auf Stromsparen optimiert (Stromverbrauch 800..1100nA). Gleichzeitig ist eine Uhr und Weckfunktion eingebaut. Ausgelesen werden kann sie über den [[I2C]]-[[Bus]]. Diese RTC kann den Mikrocontroller periodisch nach einer bestimmten Zeit (Sekunden bis Tage) über einen externen Interrupt wecken. Damit kann der Mikrocontroller in den Power Down Mode gehen und maximal Strom sparen. So eine Kombination aus AVR und RTC verbraucht dann nur noch ca. 1400nA! Eine kleine 3V Lithiumzelle mit 100mAh reicht dann unglaubliche 71.400 Stunden = 8 Jahre!

'''Allgemein gilt:'''

:<math>Lebensdauer [h] = \frac {Kapazitaet [Ah] }{Strom [A]}</math>

Zu beachten ist, daß diese Formel nur für relativ geringe Entladeströme gilt, typisch bei einer Entladung über 20 Stunden oder länger. Will man hohe Ströme in einer kurzen Zeit entnehmen, sinkt die verfügbare Kapazität. Genaueres findet man dazu [http://www.amplepower.com/pwrnews/beer/ hier] und im Datenblatt der Batterien.

== Beispiele ==

Die Beispiele sind mit WINAVR 20060421 compiliert und getestet worden. Zur Nutzung des Sleep Mode werden zwei C-Funktionen zur Verfügung gestellt, set_sleep_mode() und sleep_mode(). Genaueres hierzu findet man in der Dokumentation der libc im WINAVR. Alle Programme wurden mit Optimierungsstufe -Os compiliert.

=== UART Terminal ===

Soll der UART verwendet werden kommt nur der Idle Mode in Frage. In diesem Beispiel wird der AVR genutzt um Zeichen von der [[RS232]] Schnittstelle zu empfangen und per Morsezeichen auszugeben. Als Hauptoszillator wird ein 3,6864 MHz Quarz eingesetzt, wie für eine zuverlässige UART-Kommunikation notwendig ist. Siehe auch [[AVR-Tutorial: UART | AVR-Tutorial]], [[AVR Checkliste#UART.2FUSART | AVR Checkliste]] und [[AVR-GCC-Tutorial#Der_UART | AVR-GCC-Tutorial]]. Im Sleepmode verbraucht der AVR ca. 1,9mA, im aktiven Zustand mit eingeschalteter LED ca. 7,3mA.

<c>
/*
************************************************************************
*
* Sleep Mode Demo, Idle Mode
*
* ATmega32 mit externem 3,6864 MHz Quarz an XTAL1/XTAL2
*
* LOW Fuse Byte = 0xFF
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
* An PD0 ist ein MAX232 angeschlosssen, um Daten vom PC zu empfangen
*
************************************************************************
*/

#define F_CPU 3686400 // Taktfrequenz des Quarzes

#define BAUD 9600L // Baudrate, das L am Ende ist wichtig, NICHT UL verwenden!

// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1))) // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000) // Fehler in Promille

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// globale Variablen

volatile uint8_t uart_flag;
volatile uint8_t uart_data;

// lange, variable Wartezeit, Einheit in Millisekunden

void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

// Ein Byte als "Morsezeichen" auf eine LED ausgeben

void morse(uint8_t data) {
uint8_t i,j;

for(i=0; i<8; i++) {
if (data & 0x01) // Prüfe Bit #0
j=250; // Bit ist 1
else
j=100; // Bit ist 0

PORTD |= (1 << PD5); // LED an
long_delay(j);
PORTD &= ~(1 << PD5); // LED aus
long_delay(1000-j);
data >>= 1; // nächstes Bit auf Bit #0 schieben
}
}

int main (void) {

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFF;

// UART konfigurieren

UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
UCSRB = (1<<RXCIE) | (1<<RXEN);

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_mode(); // in den Schlafmodus wechseln

// hier wachen wir wieder auf
if (uart_flag==1) {
uart_flag =0;
morse(uart_data);
}
}
}

// UART RX complete interrupt

ISR(USART_RXC_vect) {
uart_flag = 1; // signalisiere neue Daten
uart_data = UDR; // Daten auslesen, dadurch wird auch der Interrupt gelöscht
}
</c>

=== Quarzgenaue Zeitbasis ===

Hier kommt der Power Save Mode zum Einsatz. Als Zeitbasis dient ein externer 32,768 kHz Uhrenquarz, welcher asynchron den Timer 2 taktet. Das ist zwar nur ein 8 Bit Zähler, der schon nach 256 Takten überläuft, aber es gibt ja zum Glück noch den Vorteiler (Prescaler). Dieser kann die Teilerverhältnisse 1/8/32/256/1024 annehmen, daraus ergeben sich Überlaufzeiten von 7,8125ms/62,5ms/500ms/2s/8s. Werden längere Zeiten benötigt muß man diese in Software nachbilden. Z. B. kann man mit einem zwei Sekunden Intervall in einer Variable bis 30 zählen um exakt eine Minute zu erhalten. Die 30 mal aufwachen, Variable hochzählen und wieder in den Sleep Mode schalten fallen praktisch nicht ins Gewicht, das dauert nur einige Dutzend Mikrosekunden.

Das hier gezeigte Beispiel ist sehr einfach gehalten, zeigt aber deutlich die Vorgehensweise. Im quarzgenauen Zeitraster von einer Minute wird eine LED für zwei Sekunden eingeschaltet. In den realen Anwendungen wird natürliche eine Messung etc. gemacht.

<c>
/*
************************************************************************
*
* Sleep Mode Demo, Power Save Mode
*
* ATmega32 mit internem 1 MHz Oszillator + 32 kHz Quarz
*
* LOW Fuse Byte = 0xE1
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
* An TOSC1/TOSC2 muss ein 32,768 kHz Quarz angeschlossen sein
*
************************************************************************
*/

#define F_CPU 1000000

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// globale Variablen

volatile uint8_t flag;

// lange, variable Wartezeit, Einheit in Millisekunden

void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

int main (void) {

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFF;

// Analogcomparator ausschalten

ACSR = 0x80;

// Timer2 konfigurieren

ASSR = (1<< AS2); // Timer2 asynchron takten
long_delay(1000); // Einschwingzeit des 32kHz Quarzes
TCCR2 = 6; // Vorteiler 256 -> 2s Überlaufperiode
while((ASSR & (1<< TCR2UB))); // Warte auf das Ende des Zugriffs
TIFR &= ~(1<<TOV2); // Interrupts löschen
TIMSK |= (1<<TOIE2); // Timer overflow Interrupt freischalten

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {

// WICHTIG!
// Wenn der Timer2 im asynchronen Modus periodisch zum Wecken aus dem Sleep Mode
// genutzt wird, dann muss vor dem Wiedereintritt mindestens
// 1 Oszillatortakt des Timers abgewartet werden (~30us), um die Interruptlogik
// wieder zu aktivieren, anderenfalls wacht der AVR nicht mehr auf.
// Die folgenden zwei Zeilen tun dies.
// Nur wenn sichergestellt ist, dass der Interrupt + Hauptschleife länger als 30us dauern,
// kann man den Test weglassen

OCR2 = 0; // Dummyzugriff
while((ASSR & (1<< OCR2UB))); // Warte auf das Ende des Zugriffs

set_sleep_mode(SLEEP_MODE_PWR_SAVE);
sleep_mode(); // in den Schlafmodus wechseln

// hier wachen wir wieder auf, nach Ausführung des Interupts

if (flag==1) { // Neues Messintervall ?
flag =0;
PORTD |= (1 << PD5); // LED für eine Sekunde anschalten
}
}
}

// Timer2 overflow Interrupt

ISR(TIMER2_OVF_vect) {
static uint8_t ticks; // Hilfsvariable für Messintervall

ticks++;
if (ticks==30) { // neues Messintervall ?
ticks=0;
flag=1;
}
PORTD &= ~(1 << PD5); // LED ausschalten
}
</c>

Im Sleep Mode beträgt die Stromaufnahme des AVR ca. 10μA, während der zwei Sekunden LED Leuchtdauer 2,3mA. Dadurch ergibt sich ein mittlerer Stromverbrauch von

:<math>I_m = \frac {10 \mu A \cdot 58s + 2,3mA \cdot 2s}{60s} = 86,3 \mu A</math>

Korrekterweise müßte man jedoch noch den Stromverbrauch berücksichtigen, welcher bei jedem Timerüberlauf alle zwei Sekunden entsteht. Dabei wird einmal der Timerinterrupt durchlaufen sowie einmal die Hauptschleife. Das dauert hier ca. 50 Takte, bei 1 MHz somit 50μs. Zusätzlich wird noch bis zu 30us gewartet, um garantiert einen Takt im Timer 2 vergehen zu lassen. Das passiert pro Minute 30 mal, somit erhöht sich der mittlere Stromverbrauch um

:<math>\frac {30 \cdot 80 \mu s \cdot 1,2mA}{60s}= 48nA</math> , was somit praktisch vollkommen vernachlässigbar ist.

=== Aufwachen per Tastendruck ===

Maximale Einsparung an Energie bringt der Power Down Modus. Das Aufwecken muß dann aber durch eine levelsensitiven externen Interrupt erfolgen. Ein flankensensitiver Interrupt ist nicht möglich! Auch hier blinkt eine LED.

<c>
/*
************************************************************************
*
* Sleep Mode Demo, Power Down Mode
*
* ATmega32 mit internem 1 MHz Oszillator
*
* LOW Fuse Byte = 0xE1
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
* An PD2 muss ein Taster gegen GND angeschlossen sein
*
************************************************************************
*/

#define F_CPU 1000000

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// lange, variable Wartezeit, Einheit in Millisekunden

void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

int main (void) {

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFB; // PD2 = INT0 = Eingang
PORTD = 0x04; // Pull Up aktivieren

// Analogcomparator ausschalten

ACSR = 0x80;

// Interrupt konfigurieren

MCUCR &= ~0x3; // levelgesteuerter Interrupt an INT0

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {

GICR |= (1 << INT0); // externen Interrupt freigeben

set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode(); // in den Schlafmodus wechseln

// hier wachen wir wieder auf
GICR &= ~(1 << INT0); // externen Interrupt sperren
// WICHTIG! falls der externe LOW Puls an INT0
// sehr lange dauert

PORTD |= (1 << PD5); // LED für eine Sekunde anschalten
long_delay(1000);
PORTD &= ~(1 << PD5);
}
}

// externer Interrupt INT0

// Die Interruptroutine kann leer sein, ABER sie muss existieren!
// Sonst springt der AVR nach dem Aufwachen zum Reset, weil kein sinnvoller
// Interruptvektor eingetragen ist!

ISR(INT0_vect) {
}
</c>

Im Power Down Mode beträgt die Stromaufnahme des AVR weniger als 1μA (weniger konnte mit dem verfügbaren Messgerät nicht gemessen werden), laut Datenblatt ca. 0,3μA. Während der einen Sekunde LED Leuchtdauer werden 3,8mA verbraucht. Wird einmal pro Minute die Taste gedrückt, ergibt sich ein mittlerer Stromverbrauch von

:<math>I_m = \frac {0,3 \mu A \cdot 59s + 3,8mA \cdot 1s}{60s} = 63,6 \mu A</math>

Wird nur einmal pro Stunde die Taste gedrückt, ergibt sich ein mittlerer Stromverbrauch von

:<math>I_m = \frac {0,3 \mu A \cdot 3559s + 3,8mA \cdot 1s}{3660s} = 1,3 \mu A</math>

== Bauteile ==

* [http://datasheets.maxim-ic.com/en/ds/DS1371.pdf DS1371], Echtzeituhr mit 1μA Stromverbrauch

== Links ==

* TODO

[[Category:AVR]]

74xx

2008-01-09T10:05:53Z

FalkB: Formatierung überarbeitet

== Einleitung ==

Die 74xx-Serie ist die am weitesten verbreitete [[Digital]]-IC-Familie. Das Präfix gibt Auskunft über den verwendbaren Temperaturbereich.

{| border="1"
! Familie || Temperaturbereich || Einsatzgebiet
|-
|align="center"|74||0°C bis +70°C || Standard (engl. Comercial)
|-
|align="center"|54||-55°C bis +125°C || Militärisch (engl. Military)
|-
|align="center"|84||-25°C bis +85°C || Industriell (engl. Industial)
|}

== Baureihen ==

* TTL ('''T'''ransistor '''T'''ransistor '''L'''ogic, Logik auf Transistorbasis)
** 74 = TTL (veraltet)
** 74H = Highspeed TTL (veraltet)
** 74ALS = Advanced Low Power Schottky TTL
** 74AS = Advanced Schottky TTL
** 74F = Fast TTL
** 74L = Low Power TTL (veraltet)
** 74LS = Low Power Schottky TTL (Ersatz für 74 und 74L)
** 74S = Schottky TTL

* CMOS ('''C'''omplementary '''M'''etal '''O'''xide '''S'''emiconductor, Halbleiter mit gegensäzlicher Polarität)
** 74AC = Advanced CMOS
** 74ACT = AC mit TTL-kompatiblen Eingängen
** 74HC = High Speed CMOS
** 74HCT = HC mit TTL-kompatiblen Eingängen
** 74AHC = Advanced High-Speed CMOS
** 74AHCT = AHC mit TTL-kompatiblen Eingängen
** 74VHC = Very High Speed CMOS
** 74VHCT = VHC mit TTL-kompatiblen Eingängen
** 74LV = Low-Voltage CMOS

* ECL ('''E'''mitter '''C'''oupled '''L'''ogic, Emittergekoppelte Logik)
** 74ECL
** 74ECTL

* Langsame störsichere Logik
** 74LSL
** 74SZL

* BICMOS [[Bus]]-Interface-Logik (CMOS und Bipolartechnik kombiniert)
** 74BCT (siehe [http://focus.ti.com/docs/logic/catalog/overview/overview.jhtml?templateId=5020&path=templatedata/cm/ovw/data/bct_overview Texas Instruments])
** 74ABT

== Typen ==


{| border="1" cellpadding="3" cellspacing="0"
|-
! style="background:#ffdead;" | Typ
! style="background:#ffdead;" | Pins
! style="background:#ffdead;" | Anzahl
! style="background:#ffdead;" | Beschreibung
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 00 || 14 || 4 || 2 Input NAND
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 01 || 14 || 4 || 2 Input NAND (OC=[[Ausgangsstufen Logik-ICs#Open_Collector|Open Collector]])
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 02 || 14 || 4 || 2 Input NOR
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 03 || 14 || 4 || 2 Input NAND (OC) Andere Belegung als 7401
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 04 || 14 || 6 || Inverter
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 05 || 14 || 6 || Inverter (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 06 || 14 || 6 || Inverter Buffer/Treiber (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 07 || 14 || 6 || Buffer/Treiber (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 08 || 14 || 4 || 2 Input AND
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 09 || 14 || 4 || 2 Input AND (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 10 || 14 || 3 || 3 Input NAND
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 11 || 14 || 3 || 3 Input AND
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 12 || 14 || 3 || 3 Input NAND (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 13 || 14 || 2 || 4 Input NAND [[Schmitt-Trigger]]
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 14 || 14 || 6 || Inverter Schmitt-Trigger
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 15 || 14 || 3 || 3 Input AND (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 16 || 14 || 6 || Inverter Treiber (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 17 || 14 || 6 || Treiber (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 18 || 14 || 2 || 4 Input NAND Schmitt-Trigger
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 19 || 14 || 6 || Inverter Schmitt-Trigger
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 20 || 14 || 2 || 4 Input NAND
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 21 || 14 || 2 || 4 Input AND
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 22 || 14 || 2 || 4 Input NAND (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 24 || 14 || 4 || 2 Input NAND Schmitt-Trigger
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 25 || 14 || 2 || 4 Input NOR
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 26 || 14 || 4 || 2 Input NAND (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 27 || 14 || 3 || 3 Input NOR
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 28 || 14 || 4 || 2 Input NOR
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 30 || 14 || 1 || 8 Input NAND
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 31 || 16 || - || Verzögerungs-Element (je 2 Non-Inverting, Inverting, 2 Input NAND)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 32 || 14 || 4 || 2 Input OR
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 33 || 14 || 4 || 2 Input NOR (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 34 || 14 || 6 || Treiber
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 35 || 14 || 6 || Treiber (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 36 || 14 || 4 || 2 Input NOR
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 37 || 14 || 4 || 2 Input NAND
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 38 || 14 || 4 || 2 Input NAND (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 39 || 14 || 4 || 2 Input NAND Treiber (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 40 || 14 || 2 || 4 Input NAND
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 41 || 16 || - || BCD -> Decimal Decoder (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 42 || 16 || - || BCD -> Decimal Decoder
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 43 || 16 || - || Excess-3 -> Decimal Decoder
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 44 || 16 || - || Excess-3-Gray -> Decimal Decoder
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 45 || 16 || - || BCD -> Decimal Decoder (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 46 || 16 || - || BCD -> 7-Segment Decoder (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 47 || 16 || - || BCD -> 7-Segment Decoder (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 48 || 16 || - || BCD -> 7-Segment Decoder (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 49 || 14 || - || BCD -> 7-Segment Decoder (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 50 || 14 || - || Dual 2-Wide 2-Input AND-OR-INVERT (1 expandable)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 51 || 14 || 2 || AND-OR-INVERT
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 52 || 14 || ? || Expandable AND-OR
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 53 || 14 || 1 || Expandable 4-Wide AND-OR-INVERT
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 54 || 14 || 1 || 3-2-2-3 Input AND-OR-INVERT
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 55 || 14 || 1 || 2-Wide 4-Input AND-OR-INVERT
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 73 || 14 || 2 || JK Flip Flop with clear
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 74 || 14 || 2 || D Flip Flop with preset & clear
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 75 || 16 || - || 4-Bit Bistable Latch
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 76 || 14 || 2 || JK Flip Flop with preset & clear
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 78 || 14 || 2 || JK Flip Flop
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 86 || 14 || 4 || 2 Input XOR
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 90 || 14 || - || Decade Counter
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 92 || 14 || - || Divide By-Twelve Couter
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 93 || 14 || - || 4-Bit Binary Counter
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 95 || 14 || - || 4 Bit Parallel Access Shift Register
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 121 || 14 || - || Monostable Multivibrator With Schmitt-Trigger
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 122 || 14 || - || Retriggerable Monostable Multivibrator
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 123 || 16 || 2 || Retriggerable Monostable Multivibrator
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 125 || 14 || 4 || [[Ausgangsstufen Logik-ICs#Tri-state|Tri-State]] Buffer
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 126 || 14 || 4 || Tri-State Buffer
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 132 || 14 || 4 || 2 Input NAND Schmitt-Trigger
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 133 || 14 || 1 || 13 Input NAND
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 136 || 14 || 4 || 2 Input XOR
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 137 || 16 || 1 || 3-to-8 line decoder / demultiplexer with address latches, low-active outputs
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 138 || 16 || 1 || 3-to-8 line decoder / demultiplexer , low-active outputs
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 139 || 16 || 2 || 2-to-4 line decoder / demultiplexer , low-active outputs
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 146 || 16 || - || BCD -> Decimal Decoder (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 147 || 16 || - || 10-Line -> 4-Line BCD Priority Encoder
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 148 || 16 || - || 8-Line -> 3-Line Priority Encoder
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 151 || 16 || 1 || 8:1 Multiplexer
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 154 || 24 || 1 || 4-Line -> 16-Line Decoder/Demultiplexer
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 155 || 16 || 2 || 2-Line -> 4-Line Decoder/Demultiplexer
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 156 || 16 || 2 || 2-Line -> 4-Line Decoder/Demultiplexer (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 157 || 16 || 4 || 2:1 Multiplexer
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 158 || 16 || 4 || 2:1 Multiplexer , inverted outputs
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 161 || 16 || - || Sync 4 Bit Binary Counter Async Reset
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 164 || 14 || - || 8 Bit Serial Shift Register
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 177 || 14 || - || Presetable Binary Counter/Latch
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 191 || 16 || - || 4-Bit Up/Down Binary Converter
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 193 || 16 || - || 4-Bit Up/Down Binary Counter
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 221 || 16 || 2 || Monostable Multivibrator with Reset
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 238 || 16 || 1 || 3-to-8 line decoder / demultiplexer , high-active outputs
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 239 || 16 || 2 || 2-to-4 line decoder / demultiplexer , high-active outputs
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 240 || 20 || - || 8-Bit Tri-State Buffer/Line Driver (invertierend)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 241 || 20 || - || 8-Bit Tri-State Buffer/Line Driver
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 242 || 14 || - || 4-Bit Bus Transceiver (invertierend)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 243 || 14 || - || 4-Bit Bus Transceiver (nicht invertierend)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 244 || 20 || - || 8-Bit Tri-State Buffer/Line Driver (nicht invertierend)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 245 || 20 || - || 8-Bit Bus Transceiver
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 251 || 16 || - || 8-Bit Input Multiplexer; 3-State
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 259 || 16 || - || 8-Bit Adressable Latch
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 260 || 14 || 2 || 5 Input NOR
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 266 || 14 || 4 || 2 Input Exclusive NOR (OC)
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 366 || 16 || 6 || Tri-State Inverting Buffer
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 367 || 16 || 6 || Tri-State Buffer
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 373 || 20 || - || 8-Bit Transparent Latch
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 541 || 20 || - || 8-Bit Tri-State Buffer/Line Driver
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 573 || 20 || - || 8-Bit Tri-State D-Type Latch
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 574 || 20 || 8 || Tri-State Flip Flop
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 590 || 16 || - || 8-Bit binary counter, 3-state output register
|-
| style="background:#efefef; text-align:right; font-weight: bold;" | 595 || 16 || - || 8-Bit Serial -> Parallel (SIPO) Shift Register siehe auch [[AVR-Tutorial: Schieberegister]]
|}

== Weblinks ==

* [http://www.kingswood-consulting.co.uk/giicm/ Giant Internet IC Masturbator] Umfassende Übersicht mit Pinouts über 4000, 7400 und Co (nach GIICM suchen, falls der Link mal ins Leere zeigen sollte)
* [http://www.mikrocontroller.net/topic/3725 "Ende der '244 Verwirrung ???"] im Forum

[[Category:Bauteile]]

AVR-Tutorial: Schieberegister

2008-01-09T09:50:57Z

FalkB:

Ab und an stellt sich folgendes Problem: Man würde wesentlich mehr Ausgangspins oder Eingangspins benötigen als der [[Mikrocontroller]] zur Verfügung stellt. Ein möglicher Ausweg ist eine Porterweiterung mit einem Schieberegister. Zwei beliebte Schieberegister sind beispielsweise der 74xx595 bzw. der 74xx165.

== Porterweiterung für Ausgänge ==

Um neue Ausgangspins zu gewinnen kann der [[74xx | 74xx595]] verwendet werden. Dabei handelt es sich um ein ''8-Bit 3-state Serial-in/Serial-out or Parallel-Out Schieberegister mit einem Ausgangsregister und einem asynchronen Reset''.

Hinter dieser kompliziert anmutenden Beschreibung verbirgt sich eine einfache Funktionalität: Das Schieberegister besteht aus zwei Funktionseinheiten: Dem eigentlichen Schieberegister und dem Ausgangsregister. In das Schieberegister können die Daten seriell hineingetaktet werden und durch ein bestimmtes Signal werden die Daten des Schieberegisters in das Ausgangsregister übernommen und können von dort auf die Ausgangspins geschaltet werden.

Im Einzelnen bedeuten die Begriffe:

{| border="1"
|-
! Begriff || Erklärung
|-
|8-Bit || Acht Ausgangs[[Bit|bit]]s
|-
|3-state || Die acht Registerausgänge können drei Zustände, Low, High und High-Impedanz annehmen. Siehe [[Ausgangsstufen Logik-ICs]]
|-
|Serial-in || Serieller Eingang des Schieberegisters
|-
|Serial-out || Serieller Ausgang des Schieberegisters
|-
|Parallel-Out || Parallele Ausgänge des Ausgangsregisters
|-
|Schieberegister || Serielle Daten werden durch den Baustein durchgeschoben
|-
|Ausgangsregister || Ein Speicher, welcher die Daten des Schieberegisters zwischenspeichern kann. Dieses besteht aus acht [[FlipFlop]]s.
|-
|Asynchroner Reset || Die Daten im Schieberegister können asynchron zum zurückgesetzt werden.
|}

=== Aufbau ===

[[Bild:74xx595-1.png]]

Hinweis: Die Benennung der Pins in den Datenblättern verschiedener Hersteller unterscheidet sich zum Teil. Die Funktionen der Pins sind jedoch gleich.

{| cellspacing=”0” border="1"
|+ '''Beispiele von Hersteller-Pinbenennungen'''
|-
! DIL Pin-Nummer || Funktion || Dieses Tutorial || Motorola / ON Semi || Philips || Fairchild || SGS|| Texas Instruments
|-
| 1 || Ausgang B || QB || QB || Q1 || QB || QB|| QB
|-
| 2 || Ausgang C || QC || QC || Q2 || QC || QC|| QC
|-
| 3 || Ausgang D || QD || QD || Q3 || QD || QD|| QD
|-
| 4 || Ausgang E || QE || QE || Q4 || QE || QE|| QE
|-
| 5 || Ausgang F || QF || QF || Q5 || QF || QF|| QF
|-
| 6 || Ausgang G || QG || QG || Q6 || QG || QG|| QG
|-
| 7 || Ausgang H || QH || QH || Q7 || QH || QH|| QH
|-
| 8 || Masse, 0 V || [nicht dargestellt] || GND || GND || GND || GND|| GND
|-
| 9 || Serieller Ausgang || QH* || SQH || Q7´ ||Q'H || QH´||QH'
|-
| 10 || Reset für Schieberegister || SCL || RESET || /MR || /SCLR || /SCLR || /SRCLR
|-
| 11 || Schiebetakt || SCK || SHIFT CLOCK || SHCP || SCK || SCK || SRCLK
|-
| 12 || Speichertakt || RCK || LATCH CLOCK || STCP || RCK || RCK || RCLK
|-
| 13 || Ausgangssteuerung || G || OUTPUT ENABLE || /OE || /G || /G || /OE
|-
| 14 || Serieller Dateneingang || SER || A || DS || SER || SI || SER
|-
| 15 || Ausgang A || QA || QA || Q0 || QA || QA|| QA
|-
| 16 || Betriebsspannung || [nicht dargestellt] || VCC || VCC || VCC || VCC|| VCC
|}

Der Baustein besteht aus zwei Einheiten:
* dem Schieberegister
* dem Ausgangsregister

Im Schieberegister werden die einzelnen Bits durchgeschoben. Mit jeder positiven Taktflanke(LOW -> HIGH) an '''SCK''' wird eine Schiebeoperation durchgeführt.

Das Ausgangsregister hat die Aufgabe die Ausgangspins des Bausteins anzusteuern. Durch dieses Ausgangsregister ist es möglich, die Schiebeoperationen im Hintergrund durchzuführen, ohne dass IC Pins ihren Wert ändern. Erst wenn die Schiebeoperation abgeschlossen ist, wird der aktuelle Zustand der Schieberegisterkette durch einen Puls an '''RCK''' in das Ausgangsregister übernommen.

===Funktionsweise===

Am Eingang '''SER''' (Pin 14) wird das gewünschte nächste Datum (0 oder 1) angelegt. Durch einen positiven Puls an '''SCK''' (Pin 1) wird der momentan an '''SER''' anliegende Wert als neuer Wert für Bit 0, das unterste Bit des Schieberegisters, übernommen. Gleichzeitig werden alle anderen Bits im Schieberegister um eine Stelle verschoben: Das Bit 6 wird ins Bit 7 übernommen, Bit 5 ins Bit 6, Bit 4 ins Bit 5, etc. sodass das Bit 0 zur Aufnahme des '''SER''' Bits frei wird.

[[Bild:74xx595-2.png]]

Eine Sonderstellung nimmt das ursprüngliche Bit 7 ein. Dieses Bit steht direkt auch am Ausgang '''QH*''' (Pin 9) zur Verfügung. Dadurch ist es möglich an ein Schieberegister einen weiteren Baustein 74xxx595 anzuschliessen und so beliebig viele Schieberegister hintereinander zu schalten (kaskadieren). Auf diese Art lassen sich Schieberegister mit beliebig vielen Stufen aufbauen.

Wurde das Schieberegister mit den Daten gefüllt, so wird mit einem LOW-HIGH Puls am Pin 12, '''RCK''' der Inhalt des Schieberegisters in das Ausgangsregister übernommen.

[[Bild:74xx595-3.png]]

Mit dem Eingang '''G''' (Pin 13) kann das Ausgangsregister freigegeben werden. Liegt '''G''' auf 0, so führen die Ausgänge '''QA''' bis '''QH''' entsprechende Pegel. Liegt '''G''' auf 1, so schalten die Ausgänge '''QA''' bis '''QH''' auf [[Ausgangsstufen Logik-ICs |Tristate]]. D.h. sie treiben aktiv weder LOW oder HIGH, sondern sind hochohmig wie ein Eingänge und nehmen jeden Pegel an, der ihnen von aussen aufgezwungen wird.

Bleibt nur noch der Eingang '''SCL'''(Pin 13). Mit ihm kann das Schieberegister im Baustein gelöscht, also auf eine definierte 0, gesetzt werden.

Die Programmierung eines 74xxx595 Schieberegisters gestaltet sich sehr einfach. Im Grunde gibt es 2 Möglichkeiten:
* Mittels [[SPI]] kann der [[AVR]] das Schieberegister direkt und autark ansteuern. Das ist sehr schnell und verbraucht nur wenig CPU-Leistung
* Sind die entsprechenden SPI-Pins am AVR nicht frei, so ist auch eine softwaremässige Ansteuerung des Schieberegisters mit einfachen Mitteln durchführbar.

=== Ansteuerung per Software===

Für eine komplette Softwarelösung kann das Schieberegister an jede beliebige Port-Pin Kombination angeschlossen werden. Wir wählen die Pins '''PB0''', '''PB1''', '''PB2''' und '''PB3''' um dort die Schieberegisteranschlüsse '''SER''', '''SCK''', '''SCL''' und '''RCK''' anzuschliessen.

[[Bild:Mega8-595.gif]]

Die Programmierung gestaltet sich dann nach folgendem Schema: Die 8 Bits eines Bytes werden nacheinander an den Ausgang '''PB0''' ('''SER''') ausgegeben. Durch Generierung eines Pulses 0-1-0 an Pin '''PB1''' ('''SCK''') übernimmt das Schieberegister nacheinander die einzelnen Bits. Dabei ist zu beachten, dass die Ausgabe mit dem höherwertigen Bit beginnen muss, denn dieses Bit wandert ja am weitesten zur Stelle '''QH'''. Sind alle 8 Bits ausgegeben, so wird durch einen weiteren 0-1-0 Impuls am Pin '''PB3''' ('''RCK''') der Inhalt der Schieberegisterbits 0 bis 7 in die Ausgaberegister '''QA''' bis '''QH''' übernommen. Dadurch, dass am Schieberegister der Eingang '''G''' konstant auf 0-Pegel gehalten wird, erscheint dann auch die Ausgabe sofort an den entsprechenden Pins und kann zb. mit LEDs (low-current LEDs + Vorwiderstand verwenden) sichtbar gemacht werden.

Der Schieberegistereingang '''SCL''' wird auf einer 1 gehalten. Würde er
auf 0 gehen, so würde die Schieberegisterkette gelöscht. Möchte man einen weiteren Prozessorpin einsparen, so kann man diesen Pin auch generell auf Vcc legen. Das Schieberegister könnte man in so einem Fall durch Einschreiben von 0x00 immer noch löschen.

<avrasm>
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = 3
.equ SCK = 1
.equ SCL = 2
.equ SIN = 0

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;
; Die Port Pins auf Ausgang konfigurieren
;
ldi temp1, (1<<RCK) | (1<<SCK) | (1<<SCL) | (1<<SIN)
out SCHIEBE_DDR, temp1

;
; die Clear Leitung am Schieberegister auf 1 stellen
;
sbi SCHIEBE_PORT, SCL

;
; Ein Datenbyte ausgeben
;
ldi temp1, 0b10101010
rcall Schiebe
rcall SchiebeOut

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; Die Ausgabe im Schieberegister in das Ausgaberegister übernehmen
;
; Dazu am RCK Eingang am Schieberegister einen 0-1-0 Puls erzeugen
;
SchiebeOut:
sbi SCHIEBE_PORT, RCK
cbi SCHIEBE_PORT, RCK
ret

;-----------------------------------------------------------------------------
;
; 8 Bits aus temp1 an das Schieberegister ausgeben
Schiebe:
push temp2
ldi temp2, 8 ; 8 Bits müssen ausgegeben werden

Schiebe_1:
;
; jeweils das höchstwertige Bit aus temp1 ins Carry-Flag schieben
; Je nach Zustand des Carry-Flags wird die Datenleitung entsprechend
; gesetzt oder gelöscht
;
rol temp1 ; MSB -> Carry
brcs Schiebe_One ; Carry gesetzt? -> weiter bei Schiebe_One
cbi SCHIEBE_PORT, SIN ; Eine 0 ausgeben
rjmp Schiebe_Clock ; und Sprung zur Clock Puls Generierung
Schiebe_One:
sbi SCHIEBE_PORT, SIN ; Eine 1 ausgeben

;
; einen Impuls an SCK zur Übernahme des Bits nachschieben
;
Schiebe_Clock:
sbi SCHIEBE_PORT, SCK ; Clock-Ausgang auf 1 ...
cbi SCHIEBE_PORT, SCK ; und wieder zurück auf 0

dec temp2 ; Anzahl der ausgegebenen Bits runterzählen
brne Schiebe_1 ; Wenn noch keine 8 Bits ausgegeben -> Schleife bilden

pop temp2
ret
</avrasm>

=== Ansteuerung per SPI-Modul===

Noch schneller geht die Ansteuerung des Schieberegisters mittels [[Serial_Peripheral_Interface | SPI]]-Modul, welches in fast allen AVRs vorhanden ist. Hier wird der Pin '''SCL''' nicht benutzt, da das praktisch keinen Sinn hat. Er muss also fest auf VCC gelegt werden. Die Pins für '''SCK''' und '''SIN''' sind duch den jeweiligen AVR fest vorgegeben. '''SCK''' vom 74xxx595 wird mit '''SCK''' vom AVR verbunden sowie '''SIN''' mit '''MOSI''' ('''M'''aster '''O'''ut, '''S'''lave '''I'''n). '''MISO''' ('''M'''aster '''I'''n, '''S'''lave '''O'''ut) ist hier ungenutzt. Es kann NICHT als '''RCK''' verwendet werden, da es im SPI-Master Modus immer ein Eingang ist! Es kann aber als allgemeiner Eingang verwendet werden. Der AVR-Pin '''SS''' wird sinnvollerweise als '''RCK''' benutzt, da er sowieso als Ausgang geschaltet werden '''muss''', sonst gibt es böse Überaschungen (siehe Datenblatt "SS Pin Functionality"). Je nach Bedarf kann man die Taktrate des SPI-Moduls zwischen 1/2 ... 1/128 des CPU-Taktes wählen. Es spricht kaum etwas dagegen mit maximaler Geschwindigkeit zu arbeiten. Die AVRs können zur Zeit mit maximal 20 MHz getaktet werden, d.h. es sind maximal 10 MHz SPI-Takt möglich. Das ist für ein 74xxx595 kein Problem. Die Übertragung von 8 Bit dauert dann gerade mal 800ns!

<avrasm>
.include "m8def.inc"

.def temp1 = r16

; Die Definitionen müssen an den jeweiligen AVR angepasst werden

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = PB2 ; SS
.equ SCK = PB5 ; SCK
.equ SIN = PB3 ; MOSI

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
; SCK, MOSI, SS als Ausgänge schalten
;
in temp1,SCHIEBE_DDR
ori temp1,(1<<SIN) | (1<<SCK) | (1<<RCK)
out SCHIEBE_DDR,temp1
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01010000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 0, CPHA =0
; SCK Takt = 1/2 XTAL
ldi temp1,1
out SPSR,temp1 ; double speed aktivieren
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen
;
; Ein Datenbyte ausgeben
;
ldi temp1, 0b10101010
rcall Schiebe ; Daten schieben
rcall SchiebeOut ; Daten in Ausgangsregister übernehmen

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; Die Daten im Schieberegister in das Ausgaberegister übernehmen
;
; Dazu am RCK Eingang am Schieberegister einen 0-1-0 Puls erzeugen
;
SchiebeOut:
sbi SCHIEBE_PORT, RCK
cbi SCHIEBE_PORT, RCK
ret

;-----------------------------------------------------------------------------
;
; 8 Bits aus temp1 an das Schieberegister ausgeben
;
Schiebe:
sbis SPSR,7 ; prüfe ob eine alte Übertragung beendet ist
rjmp Schiebe
out SPDR,temp1 ; Daten ins SPI Modul schreiben, Übertragung beginnt automatisch
ret
</avrasm>

===Kaskadieren von Schieberegistern===

Um ein Schieberegister anzuschließen genügen also im einfachsten Fall 4 freie Prozessorpins (3 wenn '''SCL''' nicht benutzt wird) um weitere 8 Ausgangsleitungen zu bekommen. Genügen diese 8 Leitungen nicht, so kann ohne Probleme ein weiteres Schieberegister an das bereits Vorhandene angeschlossen werden:

[[Bild:Mega8-595-2.gif]]

Das nächste Schieberegister wird mit seinem Dateneingang '''SER''' einfach an den dafür vorgesehenen Ausgang '''QH*''' des vorhergehenden Schieberegisters angeschlossen. Die Steuerleitungen '''SCK''', '''RCK''' und '''SCL''' werden parallel zu den bereits vorhandenen geschaltet. Konzeptionell erhält man dadurch ein Schieberegister mit einer Breite von 16 Bit. Werden weiter Bausteine in derselben Manier angeschlossen, so erhöht sich die Anzahl der zur Verfügung stehenden Ausgabeleitungen mit jedem Baustein um 8 ohne dass sich die Anzahl der am Prozessor notwendigen Ausgabepins erhöhen würde. Um diese weiteren Register zu nutzen, muss man in der reinen Softwarelösung nur mehrfach die Funktion '''Schiebe''' aufrufen, um alle Daten auszugeben. Am Ende werden dann mit '''SchiebeOut''' die Daten in die Ausgangsregister übernommen.

Bei der SPI Lösung werden ebenfalls ganz einfach mehrere Bytes über SPI ausgegeben, ehe dann mittels '''RCK''' die in die Schieberegisterkette eingetakteten Bits in das Ausgangsregister übernommen werden.
Um das Ganze ein wenig zu vereinfachen, soll hier eine Funktion zur Ansteuerung mehrerer kaskadierter Schieberegister über das SPI-Modul gezeigt werden. Dabei wird die Ausgabe mehrerer Bytes über eine Schleife realisiert, mehrfache Aufrufe der Funktion sind damit nicht nötig. Statt dessen übergibt man einen Zeiger auf einen Datenblock im RAM sowie die Anzahl der zu übertragenden Bytes. Ausserdem wird die Datenübernahme durch '''RCK''' standardkonform integriert. Denn bei nahezu allen ICs mit SPI wird ein sog. CS-Pin verwendet ('''C'''hip '''S'''elect) Dieser Pin ist meist LOW aktiv, d.h. wenn er HIGH ist, ignoriert der IC alle Signale an '''SCK''' und '''MOSI''' und gibt keine Daten an MISO aus. Ist er LOW, dann ist der IC aktiv und funktioniert normal. Bei der steigenden Flanke an '''CS''' werden die Daten ins Ausgangsregister übernommen. Die Fuktion ist sehr schnell, da die Zeit während der die Übertragung eines Bytes läuft, dazu genutzt wird, den Schleifenzähler zu verringern und zu prüfen sowie neue Sendedaten zu laden. Zwischen den einzelnen Bytes gibt es somit nur eine Pause von max. 6 Systemtakten.

<avrasm>
.include "m8def.inc"
.def temp1 = r16

; Die Definitionen müssen an den jeweiligen AVR angepasst werden

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = PB2 ; SS
.equ SCK = PB5 ; SCK
.equ SIN = PB3 ; MOSI

;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------

.dseg
.org $60
Schiebedaten: .byte 2

;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------

.cseg
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
; SCK, MOSI, SS als Ausgänge schalten
;
in temp1,SCHIEBE_DDR
ori temp1,(1<<SIN) | (1<<SCK) | (1<<RCK)
out SCHIEBE_DDR,temp1

sbi SCHIEBE_PORT, RCK ; Slave select inaktiv
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01010000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 0, CPHA =0
; SCK Takt = 1/2 XTAL
ldi r16,1
out SPSR,r16 ; Double Speed
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen

; den Datenblock mit Daten füllen

ldi temp1,$F0
sts Schiebedaten,temp1
ldi temp1,$55
sts Schiebedaten+1,temp1

loop:
; den Datenblock ausgeben

ldi r16,2
ldi zl,low(Schiebedaten)
ldi zh, high(Schiebedaten)
rcall Schiebe_alle ; Daten ausgeben

rjmp loop ; nur zur Simulation

;-----------------------------------------------------------------------------
;
; N Bytes an das Schieberegister ausgeben und in das Ausgaberegister übernehmen
;
; r16: Anzahl der Datenbytes
; Z: Zeiger auf Datenblock im RAM
;
;-----------------------------------------------------------------------------
Schiebe_alle:
cbi SCHIEBE_PORT, RCK ; RCK LOW, SPI Standardverfahren
push r17

Schiebe_alle_2:
ld r17,Z+
Schiebe_alle_3:
sbis SPSR,SPIF ; prüfe ob eine alte Übertragung beendet ist
rjmp Schiebe_alle_3
out SPDR,r17 ; Daten ins SPI Modul schreiben, Übertragung beginnt automatisch
dec r16
brne Schiebe_alle_2

Schiebe_alle_4:
sbis SPSR,SPIF ; prüfe ob die letzte Übertragung beendet ist
rjmp Schiebe_alle_4

pop r17
sbi SCHIEBE_PORT, RCK ; RCK inaktiv, Datenübernahme
ret
</avrasm>

Der Nachteil von Schieberegistern ist allerdings, dass sich die Zeit zum Setzten aller Ausgabeleitungen mit jedem weiteren Baustein immer weiter erhöht. Dies deshalb, da ja die einzelnen Bits im Gänsemarsch durch alle Bausteine geschleust werden müssen und für jeden einzelnen Schiebevorgang etwas Zeit notwendig ist. Ein Ausweg ist die Verwendung des SPI-Moduls, welches schneller arbeitet als die reine Softwarelösung. Ist noch mehr Geschwindigkeit gefragt, so sind mehr Port-Pins nötig. Kann ein kompletter Port mit 8 Pins für die Daten genutzt werden, sowie ein paar weitere Steuerleitungen, so können ein oder mehrere 74xxx573 eine Alternative sein, um jeweils ein vollständiges Byte auszugeben. Natürlich kann der 74xxx573 (oder ein ähnliches Schieberegister) auch mit dem 74xxx595 zusammen eingesetzt werden, beispielsweise in dem über das Schieberegister verschiedene 74xxx595 nacheinander aktiviert werden. Weitere Tips und Tricks dazu gibt es vielleicht in einem weiteren Tutorial...

=== Acht LEDs mit je 20mA pro Schieberegister ===

Will man nun acht [[LED]]s mit dem Schieberegister ansteuern, kann man diese direkt über Vorwiderstände anschliessen. Doch ein genauer Blick ins Datenblatt verrät, dass der 74xx595 nur maximal 70mA über VCC bzw. GND ableiten kann. Und wenn man den IC nicht gnadenlos quälen, und damit die Lebensdauer und Zuverlässigkeit drastisch reduzieren will, gibt es nur zwei Auswege.

* Den Strom pro LED auf 70/8 = 8,75mA begrenzen; Das reicht meistens aus um die LEDs schön leuchten zu lassen, vor allem bei low-current und ultrahellen LEDs
* Wenn doch 20 mA pro LED gebraucht werden, kann man die folgende Trickschaltung anwenden.

[[bild:8x20mA_LED_mit_74xx595.png]]

Der Trick besteht darin, dass 4 LEDs ihren Strom über das Schieberegister von VCC beziehen (HIGH aktiv) während die anderen vier ihren Strom über GND leiten (LOW aktiv). Damit bleiben ganz offiziell für jede LED 70/4 = 17,5mA. Um die Handhabung in der Software zu vereinfachen muss nur vor der Ausgabe der Daten das jeweilige Byte mit 0x0F XOR verknüpft werden, bevor es in das Schieberegister getaktet wird. Dadurch werden die LOW-aktiven LEDs richtig angesteuert und die Datenhandhabung in der Software muss nur mit HIGH-aktiven rechnen.

Achtung! Die Widerstände sind auf blaue LEDs mit 3,3V Flusspannung ausgelegt. Bei roten, gelben und grünen [[LED]]s ist die Flusspannung geringer und dementsprechend muss der Vorwiderstand grösser sein.

Ausserdem wird der G Eingang verwendet, um die Helligkeit aller LEDs per [[PWM]] zu steuern. Beachtet werden muss, dass die PWM im invertierten Modus generiert werden muss, da der Eingang G LOW aktiv ist.

== Porterweiterung für Eingänge ==

Ein naher Verwandter des 75xx595 ist der [[74xx | 74xx165]], er ist quasi das Gegenstück. Hierbei handet es sich um ein ''8-bit parallel-in/serial-out shift register''. Auf deutsch ein 8 Bit Schieberegister mit parallelem Eingang und seriellem Ausgang. Damit kann man ein grosse Anzahl Eingänge sehr einfach und preiswert zu seinem Mikrocontroller hinzufügen.

=== Aufbau ===

[[bild:74xx165-1.png]]

Der Aufbau ist sehr ähnlich zum 74xx595. Allerdings gibt es kein Register zum Zwischenspeichern. Das ist auch gar nicht nötig, da der IC ja einen parallelen Eingang hat. Der muss nicht zwischengespeichert werden. Es gibt hier also wirklich nur das Schieberegister. Dieses wird über den Eingang PL mit den parallelen Daten geladen. Dann können die Daten seriell mit Takten an CLK aus dem Ausgang Q7 geschoben werden.

=== Funktionsweise ===

DS ist der serielle Dateneingang, welcher im Falle von kaskadierten Schieberegistern mit dem Ausgang des vorhergehenden ICs verbunden wird.

D0..D7 sind die parallelen Dateneingänge.

Mittels des Eingangs PL ('''P'''arallel '''L'''oad) werden die Daten vom parallelen Eingang in das Schieberegister übernommen, wenn dieses Signal LOW ist. Hier muss man aber ein klein wenig aufpassen. Auf grund der Schaltungsstruktur ist der Eingang PL mit dem Takt CLK verknüpft (obwohl es dafür keinen logischen Grund gibt :-0). Damit es nicht zu unerwünschten Fehlschaltungen kommt, muss der Takt CLK während des Ladens auf HIGH liegen. Wird PL wieder auf HIGH gesetzt, sind die Daten geladen. Das erste Bit liegt direkt am Ausgang Q7 and. Die restlichen Bits können nach und nach durch das Register geschoben werden.

Der Eingang CE ('''C'''lock '''E'''nable) steuert, ob das Schieberegister auf den Takt CLK reagieren soll oder nicht. Ist CE gleich LOW werden alle Takte an CLK ignoriert. Bei HIGH werden mit jeder positiven Flanke die Daten um eine Stufe weiter geschoben.

Wird am Eingang CLK eine LOW-HIGH Flanke angelegt und ist dabei CE auf LOW, dann werden die Daten im Schieberegister um eine Position weiter geschoben: DS->Q0, Q0->Q1, Q1->Q2, Q2->Q3, Q3->Q4, Q4->Q5, Q5->Q6, Q6->Q7. Q0..Q6 sind interne Signale, siehe [http://www.nxp.com/acrobat/datasheets/74HC_HCT165_CNV_2.pdf Datenblatt].

Q7 ist der Ausgang des Schieberegisters. Dort Werden Takt für Takt die Daten ausgeggeben. Hier wird normalerweise der Eingang des Mikrocontrollers oder der Eingang des nächsten Schieberegisters angeschlossen.

Q7\ ist der invertierte Ausgang des Schieberegisters. Er wird meist nicht verwendet.

=== Schaltung ===

Um nun beispielsweise zwei Schieberegister zu kaskadieren um 16 Eingangspins zu erhalten sollte man folgende Verschaltung vornehmen. Beachten sollte man dabei, dass

* der serielle Eingang DS des ersten Schieberegisters (hier IC1) auf einen festen Pegel gelegt wird (LOW oder HIGH).
* der serielle Datenausgang bei der Benutzung des SPI-Moduls an MISO und nicht an MOSI angeschlossen wird.

[[bild:74xx165-2.png]]

Nachfolgend werden zwei Beispiele gezeigt, welche die Ansteuerung nach bekanntem Muster übernehemen. Nur dass hier eben Daten gelesen anstatt geschrieben werden. Zu beachten ist, dass hier ein anderer Modus der SPI-Ansteuerung verwendet werden muss, weil der Baustein das nötig macht. Das muss beachtet werden, wenn auch Schieberegister für Ausgänge verwendet werden. Dabei muss jeweils vor dem Zugriff auf die Ein- oder Ausgangsregister der Modus des Taktes (CPOL) umgeschaltet werden.

=== Ansteuerung per Software ===

<avrasm>
; Porterweiterung für Eingänge mit Schieberegister 74xx165
; Ansteuerung per Software

.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

; Pins anpassen, frei wählbar

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ SCHIEBE_PIN = PINB
.equ CLK = PB3
.equ PL = PB1
.equ DIN = PB2

;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------

.dseg
.org 0x60
Daten: .byte 2 ; Speicherplatz für Eingangsdaten

;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------
.cseg
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

; CLK und PL als Ausgänge schalten

ldi temp1, (1<<clk) | (1<<pl)
out SCHIEBE_DDR, temp1

sbi schiebe_port, clk ; Takt im Ruhezustand immer auf 1
; komische Schaltung im 74xx165

; Zwei Bytes einlesen

ldi ZL,low(Daten)
ldi ZH,high(Daten)
ldi temp1,2
rcall schiebe_eingang

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; N Bytes seriell einlesen
;
; temp1 : N, Anzahl der Bytes
; Z : Zeiger auf einen Datenbereich im SRAM
;-----------------------------------------------------------------------------

schiebe_eingang:
push temp2 ; Register sichern
push temp3

cbi schiebe_port, pl ; Daten parallel laden
sbi schiebe_port, pl

schiebe_eingang_byte_schleife:

ldi temp3, 8 ; Bitzähler
schiebe_eingang_bit_schleife:
lsl temp2 ; Daten weiterschieben

; das IO Bit Din in das niederwerigste Bit von temp2 kopieren

sbic schiebe_pin, din ; wenn Null, nächsten Befehl überspringen
ori temp2,1 ; nein, Bit setzen

cbi SCHIEBE_PORT, CLK ; Taktausgang auf 0
sbi SCHIEBE_PORT, CLK ; und wieder zurück auf 1, dabei Daten schieben

dec temp3 ; Bitzähler um eins verringern
brne schiebe_eingang_bit_schleife ;wenn noch keine 8 Bits ausgegeben, nochmal

st z+,temp2 ; Datenbyte speichern
dec temp1 ; Anzahl Bytes um eins verringern
brne schiebe_eingang_byte_schleife ; wenn noch mehr Bytes zu lesen sind

pop temp3
pop temp2
ret
</avrasm>

=== Ansteuerung per SPI-Modul ===

<avrasm>
; Porterweiterung für Eingänge mit Schieberegister 74xx165
; Ansteuerung per SPI-Modul

.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

; Pins anpassen
; diese müssen mit den SPI-Pins des AVR Typs übereinstimmen!

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ PL = PB2 ; SS
.equ CLK = PB5 ; SCK
.equ DIN = PB4 ; MISO

;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------

.dseg
.org 0x60
Daten: .byte 2 ; Speicherplatz für Eingangsdaten

;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------
.cseg
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

; CLK und PL als Ausgänge schalten

ldi temp1,(1<<CLK) | (1<<PL)
out SCHIEBE_DDR,temp1
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01011000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 1, CPHA =0
; SCK Takt = 1/2 XTAL
ldi temp1,1
out SPSR,temp1 ; double speed aktivieren
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen

; Zwei Bytes einlesen

ldi ZL,low(Daten)
ldi ZH,high(Daten)
ldi temp1,2
rcall schiebe_eingang

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; N Bytes seriell einlesen
;
; temp1 : N, Anzahl der Bytes
; Z : Zeiger auf einen Datenbereich im SRAM
;-----------------------------------------------------------------------------
schiebe_eingang:
push temp2 ; Register sichern

; CLK ist im Ruhezustand schon auf HIGH, CPOL=1

cbi schiebe_port, pl ; Daten parallel laden
sbi schiebe_port, pl

schiebe_eingang_1:
sbis SPSR,7 ; prüfe ob eine alte Übertragung beendet ist
rjmp schiebe_eingang_1

schiebe_eingang_byte_schleife:
out SPDR,temp1 ; beliebige Daten ins SPI Modul schreiben
; um die Übertragung zu starten
schiebe_eingang_2:
sbis SPSR,7 ; auf das Ende der Übertragung warten
rjmp schiebe_eingang_2

in temp2, spdr ; Daten lesen
st z+,temp2 ; Datenbyte speichern
dec temp1 ; Anzahl Bytes um eins verringern
brne schiebe_eingang_byte_schleife ; wenn noch mehr Bytes zu lesen sind

pop temp2
ret
</avrasm>

== Bekannte Probleme ==

AVR Studio 4.12 (Build 498) hat Probleme bei der korrekten Simulation des SPI-Moduls.

* Der Double-Speed Modus funktioniert nicht.

* Das Bit SPIF im Register SPSR, welches laut Dokumentation nur lesbar ist, ist im Simulator auch schreibbar! Das kann zu Verwirrung und Fehlern in der Simulation führen.

Hardwareprobleme

* Wenn das SPI-Modul aktiviert wird, wird '''NICHT''' automatisch SPIF gesetzt, es bleibt auf Null. Damit würde die erste Abfrage in ''Schiebe_alles'' in einer Endlosschleife hängen bleiben. Deshalb muss nach der Initialisierung des SPI-Moduls ein Dummy Byte gesendet werden, damit am Ende der Übertragung SPIF gesetzt wird

* Da das SPI-Modul in Senderichtung nur einfach gepuffert ist, ist es nicht möglich absolut lückenlos Daten zu senden, auch wenn man mit '''nop''' eine feste minimale Zeit zwischen zwei Bytes warten würde. Zwischen zwei Bytes muss immer eine Pause von mind. 2 Systemtakten eingehalten werden.

{{Navigation_zurückhochvor|
zurücktext=PWM|
zurücklink=AVR-Tutorial: PWM|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=SRAM|
vorlink=AVR-Tutorial: SRAM}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Schieberegister

2008-01-08T22:45:16Z

FalkB: /* Funktionsweise */ Link eingefügt

Ab und an stellt sich folgendes Problem: Man würde wesentlich mehr Ausgangspins oder Eingangspins benötigen als der [[Mikrocontroller]] zur Verfügung stellt. Ein möglicher Ausweg ist eine Porterweiterung mit einem Schieberegister. Zwei beliebte Schieberegister sind beispielsweise der 74xx595 bzw. der 74xx165.

== Porterweiterung für Ausgänge ==

Um neue Ausgangspins zu gewinnen kann der 74xx595 verwendet werden. Dabei handelt es sich um ein ''8-Bit 3-state Serial-in/Serial-out or Parallel-Out Schieberegister mit einem Ausgangsregister und einem asynchronen Reset''.

Hinter dieser kompliziert anmutenden Beschreibung verbirgt sich eine einfache Funktionalität: Das Schieberegister besteht aus zwei Funktionseinheiten: Dem eigentlichen Schieberegister und dem Ausgangsregister. In das Schieberegister können die Daten seriell hineingetaktet werden und durch ein bestimmtes Signal werden die Daten des Schieberegisters in das Ausgangsregister übernommen und können von dort auf die Ausgangspins geschaltet werden.

Im Einzelnen bedeuten die Begriffe:

{| border="1"
|-
! Begriff || Erklärung
|-
|8-Bit || Acht Ausgangs[[Bit|bit]]s
|-
|3-state || Die acht Registerausgänge können drei Zustände, Low, High und High-Impedanz annehmen. Siehe [[Ausgangsstufen Logik-ICs]]
|-
|Serial-in || Serieller Eingang des Schieberegisters
|-
|Serial-out || Serieller Ausgang des Schieberegisters
|-
|Parallel-Out || Parallele Ausgänge des Ausgangsregisters
|-
|Schieberegister || Serielle Daten werden durch den Baustein durchgeschoben
|-
|Ausgangsregister || Ein Speicher, welcher die Daten des Schieberegisters zwischenspeichern kann. Dieses besteht aus acht [[FlipFlop]]s.
|-
|Asynchroner Reset || Die Daten im Schieberegister können asynchron zum zurückgesetzt werden.
|}

=== Aufbau ===

[[Bild:74xx595-1.png]]

Hinweis: Die Benennung der Pins in den Datenblättern verschiedener Hersteller unterscheidet sich zum Teil. Die Funktionen der Pins sind jedoch gleich.

{| cellspacing=”0” border="1"
|+ '''Beispiele von Hersteller-Pinbenennungen'''
|-
! DIL Pin-Nummer || Funktion || Dieses Tutorial || Motorola / ON Semi || Philips || Fairchild || SGS|| Texas Instruments
|-
| 1 || Ausgang B || QB || QB || Q1 || QB || QB|| QB
|-
| 2 || Ausgang C || QC || QC || Q2 || QC || QC|| QC
|-
| 3 || Ausgang D || QD || QD || Q3 || QD || QD|| QD
|-
| 4 || Ausgang E || QE || QE || Q4 || QE || QE|| QE
|-
| 5 || Ausgang F || QF || QF || Q5 || QF || QF|| QF
|-
| 6 || Ausgang G || QG || QG || Q6 || QG || QG|| QG
|-
| 7 || Ausgang H || QH || QH || Q7 || QH || QH|| QH
|-
| 8 || Masse, 0 V || [nicht dargestellt] || GND || GND || GND || GND|| GND
|-
| 9 || Serieller Ausgang || QH* || SQH || Q7´ ||Q'H || QH´||QH'
|-
| 10 || Reset für Schieberegister || SCL || RESET || /MR || /SCLR || /SCLR || /SRCLR
|-
| 11 || Schiebetakt || SCK || SHIFT CLOCK || SHCP || SCK || SCK || SRCLK
|-
| 12 || Speichertakt || RCK || LATCH CLOCK || STCP || RCK || RCK || RCLK
|-
| 13 || Ausgangssteuerung || G || OUTPUT ENABLE || /OE || /G || /G || /OE
|-
| 14 || Serieller Dateneingang || SER || A || DS || SER || SI || SER
|-
| 15 || Ausgang A || QA || QA || Q0 || QA || QA|| QA
|-
| 16 || Betriebsspannung || [nicht dargestellt] || VCC || VCC || VCC || VCC|| VCC
|}

Der Baustein besteht aus zwei Einheiten:
* dem Schieberegister
* dem Ausgangsregister

Im Schieberegister werden die einzelnen Bits durchgeschoben. Mit jeder positiven Taktflanke(LOW -> HIGH) an '''SCK''' wird eine Schiebeoperation durchgeführt.

Das Ausgangsregister hat die Aufgabe die Ausgangspins des Bausteins anzusteuern. Durch dieses Ausgangsregister ist es möglich, die Schiebeoperationen im Hintergrund durchzuführen, ohne dass IC Pins ihren Wert ändern. Erst wenn die Schiebeoperation abgeschlossen ist, wird der aktuelle Zustand der Schieberegisterkette durch einen Puls an '''RCK''' in das Ausgangsregister übernommen.

===Funktionsweise===

Am Eingang '''SER''' (Pin 14) wird das gewünschte nächste Datum (0 oder 1) angelegt. Durch einen positiven Puls an '''SCK''' (Pin 1) wird der momentan an '''SER''' anliegende Wert als neuer Wert für Bit 0, das unterste Bit des Schieberegisters, übernommen. Gleichzeitig werden alle anderen Bits im Schieberegister um eine Stelle verschoben: Das Bit 6 wird ins Bit 7 übernommen, Bit 5 ins Bit 6, Bit 4 ins Bit 5, etc. sodass das Bit 0 zur Aufnahme des '''SER''' Bits frei wird.

[[Bild:74xx595-2.png]]

Eine Sonderstellung nimmt das ursprüngliche Bit 7 ein. Dieses Bit steht direkt auch am Ausgang '''QH*''' (Pin 9) zur Verfügung. Dadurch ist es möglich an ein Schieberegister einen weiteren Baustein 74xxx595 anzuschliessen und so beliebig viele Schieberegister hintereinander zu schalten (kaskadieren). Auf diese Art lassen sich Schieberegister mit beliebig vielen Stufen aufbauen.

Wurde das Schieberegister mit den Daten gefüllt, so wird mit einem LOW-HIGH Puls am Pin 12, '''RCK''' der Inhalt des Schieberegisters in das Ausgangsregister übernommen.

[[Bild:74xx595-3.png]]

Mit dem Eingang '''G''' (Pin 13) kann das Ausgangsregister freigegeben werden. Liegt '''G''' auf 0, so führen die Ausgänge '''QA''' bis '''QH''' entsprechende Pegel. Liegt '''G''' auf 1, so schalten die Ausgänge '''QA''' bis '''QH''' auf [[Ausgangsstufen Logik-ICs |Tristate]]. D.h. sie treiben aktiv weder LOW oder HIGH, sondern sind hochohmig wie ein Eingänge und nehmen jeden Pegel an, der ihnen von aussen aufgezwungen wird.

Bleibt nur noch der Eingang '''SCL'''(Pin 13). Mit ihm kann das Schieberegister im Baustein gelöscht, also auf eine definierte 0, gesetzt werden.

Die Programmierung eines 74xxx595 Schieberegisters gestaltet sich sehr einfach. Im Grunde gibt es 2 Möglichkeiten:
* Mittels [[SPI]] kann der [[AVR]] das Schieberegister direkt und autark ansteuern. Das ist sehr schnell und verbraucht nur wenig CPU-Leistung
* Sind die entsprechenden SPI-Pins am AVR nicht frei, so ist auch eine softwaremässige Ansteuerung des Schieberegisters mit einfachen Mitteln durchführbar.

=== Ansteuerung per Software===

Für eine komplette Softwarelösung kann das Schieberegister an jede beliebige Port-Pin Kombination angeschlossen werden. Wir wählen die Pins '''PB0''', '''PB1''', '''PB2''' und '''PB3''' um dort die Schieberegisteranschlüsse '''SER''', '''SCK''', '''SCL''' und '''RCK''' anzuschliessen.

[[Bild:Mega8-595.gif]]

Die Programmierung gestaltet sich dann nach folgendem Schema: Die 8 Bits eines Bytes werden nacheinander an den Ausgang '''PB0''' ('''SER''') ausgegeben. Durch Generierung eines Pulses 0-1-0 an Pin '''PB1''' ('''SCK''') übernimmt das Schieberegister nacheinander die einzelnen Bits. Dabei ist zu beachten, dass die Ausgabe mit dem höherwertigen Bit beginnen muss, denn dieses Bit wandert ja am weitesten zur Stelle '''QH'''. Sind alle 8 Bits ausgegeben, so wird durch einen weiteren 0-1-0 Impuls am Pin '''PB3''' ('''RCK''') der Inhalt der Schieberegisterbits 0 bis 7 in die Ausgaberegister '''QA''' bis '''QH''' übernommen. Dadurch, dass am Schieberegister der Eingang '''G''' konstant auf 0-Pegel gehalten wird, erscheint dann auch die Ausgabe sofort an den entsprechenden Pins und kann zb. mit LEDs (low-current LEDs + Vorwiderstand verwenden) sichtbar gemacht werden.

Der Schieberegistereingang '''SCL''' wird auf einer 1 gehalten. Würde er
auf 0 gehen, so würde die Schieberegisterkette gelöscht. Möchte man einen weiteren Prozessorpin einsparen, so kann man diesen Pin auch generell auf Vcc legen. Das Schieberegister könnte man in so einem Fall durch Einschreiben von 0x00 immer noch löschen.

<avrasm>
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = 3
.equ SCK = 1
.equ SCL = 2
.equ SIN = 0

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;
; Die Port Pins auf Ausgang konfigurieren
;
ldi temp1, (1<<RCK) | (1<<SCK) | (1<<SCL) | (1<<SIN)
out SCHIEBE_DDR, temp1

;
; die Clear Leitung am Schieberegister auf 1 stellen
;
sbi SCHIEBE_PORT, SCL

;
; Ein Datenbyte ausgeben
;
ldi temp1, 0b10101010
rcall Schiebe
rcall SchiebeOut

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; Die Ausgabe im Schieberegister in das Ausgaberegister übernehmen
;
; Dazu am RCK Eingang am Schieberegister einen 0-1-0 Puls erzeugen
;
SchiebeOut:
sbi SCHIEBE_PORT, RCK
cbi SCHIEBE_PORT, RCK
ret

;-----------------------------------------------------------------------------
;
; 8 Bits aus temp1 an das Schieberegister ausgeben
Schiebe:
push temp2
ldi temp2, 8 ; 8 Bits müssen ausgegeben werden

Schiebe_1:
;
; jeweils das höchstwertige Bit aus temp1 ins Carry-Flag schieben
; Je nach Zustand des Carry-Flags wird die Datenleitung entsprechend
; gesetzt oder gelöscht
;
rol temp1 ; MSB -> Carry
brcs Schiebe_One ; Carry gesetzt? -> weiter bei Schiebe_One
cbi SCHIEBE_PORT, SIN ; Eine 0 ausgeben
rjmp Schiebe_Clock ; und Sprung zur Clock Puls Generierung
Schiebe_One:
sbi SCHIEBE_PORT, SIN ; Eine 1 ausgeben

;
; einen Impuls an SCK zur Übernahme des Bits nachschieben
;
Schiebe_Clock:
sbi SCHIEBE_PORT, SCK ; Clock-Ausgang auf 1 ...
cbi SCHIEBE_PORT, SCK ; und wieder zurück auf 0

dec temp2 ; Anzahl der ausgegebenen Bits runterzählen
brne Schiebe_1 ; Wenn noch keine 8 Bits ausgegeben -> Schleife bilden

pop temp2
ret
</avrasm>

=== Ansteuerung per SPI-Modul===

Noch schneller geht die Ansteuerung des Schieberegisters mittels [[Serial_Peripheral_Interface | SPI]]-Modul, welches in fast allen AVRs vorhanden ist. Hier wird der Pin '''SCL''' nicht benutzt, da das praktisch keinen Sinn hat. Er muss also fest auf VCC gelegt werden. Die Pins für '''SCK''' und '''SIN''' sind duch den jeweiligen AVR fest vorgegeben. '''SCK''' vom 74xxx595 wird mit '''SCK''' vom AVR verbunden sowie '''SIN''' mit '''MOSI''' ('''M'''aster '''O'''ut, '''S'''lave '''I'''n). '''MISO''' ('''M'''aster '''I'''n, '''S'''lave '''O'''ut) ist hier ungenutzt. Es kann NICHT als '''RCK''' verwendet werden, da es im SPI-Master Modus immer ein Eingang ist! Es kann aber als allgemeiner Eingang verwendet werden. Der AVR-Pin '''SS''' wird sinnvollerweise als '''RCK''' benutzt, da er sowieso als Ausgang geschaltet werden '''muss''', sonst gibt es böse Überaschungen (siehe Datenblatt "SS Pin Functionality"). Je nach Bedarf kann man die Taktrate des SPI-Moduls zwischen 1/2 ... 1/128 des CPU-Taktes wählen. Es spricht kaum etwas dagegen mit maximaler Geschwindigkeit zu arbeiten. Die AVRs können zur Zeit mit maximal 20 MHz getaktet werden, d.h. es sind maximal 10 MHz SPI-Takt möglich. Das ist für ein 74xxx595 kein Problem. Die Übertragung von 8 Bit dauert dann gerade mal 800ns!

<avrasm>
.include "m8def.inc"

.def temp1 = r16

; Die Definitionen müssen an den jeweiligen AVR angepasst werden

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = PB2 ; SS
.equ SCK = PB5 ; SCK
.equ SIN = PB3 ; MOSI

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
; SCK, MOSI, SS als Ausgänge schalten
;
in temp1,SCHIEBE_DDR
ori temp1,(1<<SIN) | (1<<SCK) | (1<<RCK)
out SCHIEBE_DDR,temp1
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01010000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 0, CPHA =0
; SCK Takt = 1/2 XTAL
ldi temp1,1
out SPSR,temp1 ; double speed aktivieren
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen
;
; Ein Datenbyte ausgeben
;
ldi temp1, 0b10101010
rcall Schiebe ; Daten schieben
rcall SchiebeOut ; Daten in Ausgangsregister übernehmen

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; Die Daten im Schieberegister in das Ausgaberegister übernehmen
;
; Dazu am RCK Eingang am Schieberegister einen 0-1-0 Puls erzeugen
;
SchiebeOut:
sbi SCHIEBE_PORT, RCK
cbi SCHIEBE_PORT, RCK
ret

;-----------------------------------------------------------------------------
;
; 8 Bits aus temp1 an das Schieberegister ausgeben
;
Schiebe:
sbis SPSR,7 ; prüfe ob eine alte Übertragung beendet ist
rjmp Schiebe
out SPDR,temp1 ; Daten ins SPI Modul schreiben, Übertragung beginnt automatisch
ret
</avrasm>

===Kaskadieren von Schieberegistern===

Um ein Schieberegister anzuschließen genügen also im einfachsten Fall 4 freie Prozessorpins (3 wenn '''SCL''' nicht benutzt wird) um weitere 8 Ausgangsleitungen zu bekommen. Genügen diese 8 Leitungen nicht, so kann ohne Probleme ein weiteres Schieberegister an das bereits Vorhandene angeschlossen werden:

[[Bild:Mega8-595-2.gif]]

Das nächste Schieberegister wird mit seinem Dateneingang '''SER''' einfach an den dafür vorgesehenen Ausgang '''QH*''' des vorhergehenden Schieberegisters angeschlossen. Die Steuerleitungen '''SCK''', '''RCK''' und '''SCL''' werden parallel zu den bereits vorhandenen geschaltet. Konzeptionell erhält man dadurch ein Schieberegister mit einer Breite von 16 Bit. Werden weiter Bausteine in derselben Manier angeschlossen, so erhöht sich die Anzahl der zur Verfügung stehenden Ausgabeleitungen mit jedem Baustein um 8 ohne dass sich die Anzahl der am Prozessor notwendigen Ausgabepins erhöhen würde. Um diese weiteren Register zu nutzen, muss man in der reinen Softwarelösung nur mehrfach die Funktion '''Schiebe''' aufrufen, um alle Daten auszugeben. Am Ende werden dann mit '''SchiebeOut''' die Daten in die Ausgangsregister übernommen.

Bei der SPI Lösung werden ebenfalls ganz einfach mehrere Bytes über SPI ausgegeben, ehe dann mittels '''RCK''' die in die Schieberegisterkette eingetakteten Bits in das Ausgangsregister übernommen werden.
Um das Ganze ein wenig zu vereinfachen, soll hier eine Funktion zur Ansteuerung mehrerer kaskadierter Schieberegister über das SPI-Modul gezeigt werden. Dabei wird die Ausgabe mehrerer Bytes über eine Schleife realisiert, mehrfache Aufrufe der Funktion sind damit nicht nötig. Statt dessen übergibt man einen Zeiger auf einen Datenblock im RAM sowie die Anzahl der zu übertragenden Bytes. Ausserdem wird die Datenübernahme durch '''RCK''' standardkonform integriert. Denn bei nahezu allen ICs mit SPI wird ein sog. CS-Pin verwendet ('''C'''hip '''S'''elect) Dieser Pin ist meist LOW aktiv, d.h. wenn er HIGH ist, ignoriert der IC alle Signale an '''SCK''' und '''MOSI''' und gibt keine Daten an MISO aus. Ist er LOW, dann ist der IC aktiv und funktioniert normal. Bei der steigenden Flanke an '''CS''' werden die Daten ins Ausgangsregister übernommen. Die Fuktion ist sehr schnell, da die Zeit während der die Übertragung eines Bytes läuft, dazu genutzt wird, den Schleifenzähler zu verringern und zu prüfen sowie neue Sendedaten zu laden. Zwischen den einzelnen Bytes gibt es somit nur eine Pause von max. 6 Systemtakten.

<avrasm>
.include "m8def.inc"
.def temp1 = r16

; Die Definitionen müssen an den jeweiligen AVR angepasst werden

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = PB2 ; SS
.equ SCK = PB5 ; SCK
.equ SIN = PB3 ; MOSI

;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------

.dseg
.org $60
Schiebedaten: .byte 2

;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------

.cseg
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
; SCK, MOSI, SS als Ausgänge schalten
;
in temp1,SCHIEBE_DDR
ori temp1,(1<<SIN) | (1<<SCK) | (1<<RCK)
out SCHIEBE_DDR,temp1

sbi SCHIEBE_PORT, RCK ; Slave select inaktiv
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01010000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 0, CPHA =0
; SCK Takt = 1/2 XTAL
ldi r16,1
out SPSR,r16 ; Double Speed
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen

; den Datenblock mit Daten füllen

ldi temp1,$F0
sts Schiebedaten,temp1
ldi temp1,$55
sts Schiebedaten+1,temp1

loop:
; den Datenblock ausgeben

ldi r16,2
ldi zl,low(Schiebedaten)
ldi zh, high(Schiebedaten)
rcall Schiebe_alle ; Daten ausgeben

rjmp loop ; nur zur Simulation

;-----------------------------------------------------------------------------
;
; N Bytes an das Schieberegister ausgeben und in das Ausgaberegister übernehmen
;
; r16: Anzahl der Datenbytes
; Z: Zeiger auf Datenblock im RAM
;
;-----------------------------------------------------------------------------
Schiebe_alle:
cbi SCHIEBE_PORT, RCK ; RCK LOW, SPI Standardverfahren
push r17

Schiebe_alle_2:
ld r17,Z+
Schiebe_alle_3:
sbis SPSR,SPIF ; prüfe ob eine alte Übertragung beendet ist
rjmp Schiebe_alle_3
out SPDR,r17 ; Daten ins SPI Modul schreiben, Übertragung beginnt automatisch
dec r16
brne Schiebe_alle_2

Schiebe_alle_4:
sbis SPSR,SPIF ; prüfe ob die letzte Übertragung beendet ist
rjmp Schiebe_alle_4

pop r17
sbi SCHIEBE_PORT, RCK ; RCK inaktiv, Datenübernahme
ret
</avrasm>

Der Nachteil von Schieberegistern ist allerdings, dass sich die Zeit zum Setzten aller Ausgabeleitungen mit jedem weiteren Baustein immer weiter erhöht. Dies deshalb, da ja die einzelnen Bits im Gänsemarsch durch alle Bausteine geschleust werden müssen und für jeden einzelnen Schiebevorgang etwas Zeit notwendig ist. Ein Ausweg ist die Verwendung des SPI-Moduls, welches schneller arbeitet als die reine Softwarelösung. Ist noch mehr Geschwindigkeit gefragt, so sind mehr Port-Pins nötig. Kann ein kompletter Port mit 8 Pins für die Daten genutzt werden, sowie ein paar weitere Steuerleitungen, so können ein oder mehrere 74xxx573 eine Alternative sein, um jeweils ein vollständiges Byte auszugeben. Natürlich kann der 74xxx573 (oder ein ähnliches Schieberegister) auch mit dem 74xxx595 zusammen eingesetzt werden, beispielsweise in dem über das Schieberegister verschiedene 74xxx595 nacheinander aktiviert werden. Weitere Tips und Tricks dazu gibt es vielleicht in einem weiteren Tutorial...

=== Acht LEDs mit je 20mA pro Schieberegister ===

Will man nun acht [[LED]]s mit dem Schieberegister ansteuern, kann man diese direkt über Vorwiderstände anschliessen. Doch ein genauer Blick ins Datenblatt verrät, dass der 74xx595 nur maximal 70mA über VCC bzw. GND ableiten kann. Und wenn man den IC nicht gnadenlos quälen, und damit die Lebensdauer und Zuverlässigkeit drastisch reduzieren will, gibt es nur zwei Auswege.

* Den Strom pro LED auf 70/8 = 8,75mA begrenzen; Das reicht meistens aus um die LEDs schön leuchten zu lassen, vor allem bei low-current und ultrahellen LEDs
* Wenn doch 20 mA pro LED gebraucht werden, kann man die folgende Trickschaltung anwenden.

[[bild:8x20mA_LED_mit_74xx595.png]]

Der Trick besteht darin, dass 4 LEDs ihren Strom über das Schieberegister von VCC beziehen (HIGH aktiv) während die anderen vier ihren Strom über GND leiten (LOW aktiv). Damit bleiben ganz offiziell für jede LED 70/4 = 17,5mA. Um die Handhabung in der Software zu vereinfachen muss nur vor der Ausgabe der Daten das jeweilige Byte mit 0x0F XOR verknüpft werden, bevor es in das Schieberegister getaktet wird. Dadurch werden die LOW-aktiven LEDs richtig angesteuert und die Datenhandhabung in der Software muss nur mit HIGH-aktiven rechnen.

Achtung! Die Widerstände sind auf blaue LEDs mit 3,3V Flusspannung ausgelegt. Bei roten, gelben und grünen [[LED]]s ist die Flusspannung geringer und dementsprechend muss der Vorwiderstand grösser sein.

Ausserdem wird der G Eingang verwendet, um die Helligkeit aller LEDs per [[PWM]] zu steuern. Beachtet werden muss, dass die PWM im invertierten Modus generiert werden muss, da der Eingang G LOW aktiv ist.

== Porterweiterung für Eingänge ==

Ein naher Verwandter des 75xx595 ist der 74xx165, er ist quasi das Gegenstück. Hierbei handet es sich um ein ''8-bit parallel-in/serial-out shift register''. Auf deutsch ein 8 Bit Schieberegister mit parallelem Eingang und seriellem Ausgang. Damit kann man ein grosse Anzahl Eingänge sehr einfach und preiswert zu seinem Mikrocontroller hinzufügen.

=== Aufbau ===

[[bild:74xx165-1.png]]

Der Aufbau ist sehr ähnlich zum 74xx595. Allerdings gibt es kein Register zum Zwischenspeichern. Das ist auch gar nicht nötig, da der IC ja einen parallelen Eingang hat. Der muss nicht zwischengespeichert werden. Es gibt hier also wirklich nur das Schieberegister. Dieses wird über den Eingang PL mit den parallelen Daten geladen. Dann können die Daten seriell mit Takten an CLK aus dem Ausgang Q7 geschoben werden.

=== Funktionsweise ===

DS ist der serielle Dateneingang, welcher im Falle von kaskadierten Schieberegistern mit dem Ausgang des vorhergehenden ICs verbunden wird.

D0..D7 sind die parallelen Dateneingänge.

Mittels des Eingangs PL ('''P'''arallel '''L'''oad) werden die Daten vom parallelen Eingang in das Schieberegister übernommen, wenn dieses Signal LOW ist. Hier muss man aber ein klein wenig aufpassen. Auf grund der Schaltungsstruktur ist der Eingang PL mit dem Takt CLK verknüpft (obwohl es dafür keinen logischen Grund gibt :-0). Damit es nicht zu unerwünschten Fehlschaltungen kommt, muss der Takt CLK während des Ladens auf HIGH liegen. Wird PL wieder auf HIGH gesetzt, sind die Daten geladen. Das erste Bit liegt direkt am Ausgang Q7 and. Die restlichen Bits können nach und nach durch das Register geschoben werden.

Der Eingang CE ('''C'''lock '''E'''nable) steuert, ob das Schieberegister auf den Takt CLK reagieren soll oder nicht. Ist CE gleich LOW werden alle Takte an CLK ignoriert. Bei HIGH werden mit jeder positiven Flanke die Daten um eine Stufe weiter geschoben.

Wird am Eingang CLK eine LOW-HIGH Flanke angelegt und ist dabei CE auf LOW, dann werden die Daten im Schieberegister um eine Position weiter geschoben: DS->Q0, Q0->Q1, Q1->Q2, Q2->Q3, Q3->Q4, Q4->Q5, Q5->Q6, Q6->Q7. Q0..Q6 sind interne Signale, siehe [http://www.nxp.com/acrobat/datasheets/74HC_HCT165_CNV_2.pdf Datenblatt].

Q7 ist der Ausgang des Schieberegisters. Dort Werden Takt für Takt die Daten ausgeggeben. Hier wird normalerweise der Eingang des Mikrocontrollers oder der Eingang des nächsten Schieberegisters angeschlossen.

Q7\ ist der invertierte Ausgang des Schieberegisters. Er wird meist nicht verwendet.

=== Schaltung ===

Um nun beispielsweise zwei Schieberegister zu kaskadieren um 16 Eingangspins zu erhalten sollte man folgende Verschaltung vornehmen. Beachten sollte man dabei, dass

* der serielle Eingang DS des ersten Schieberegisters (hier IC1) auf einen festen Pegel gelegt wird (LOW oder HIGH).
* der serielle Datenausgang bei der Benutzung des SPI-Moduls an MISO und nicht an MOSI angeschlossen wird.

[[bild:74xx165-2.png]]

Nachfolgend werden zwei Beispiele gezeigt, welche die Ansteuerung nach bekanntem Muster übernehemn. Nur dass hier eben Daten gelesen anstatt geschrieben werden. Zu beachten ist, dass hier ein anderer Modus der SPI-Ansteuerung verwendet werden muss, weil der Baustein das nötig macht. Das muss beachtet werden, wenn auch Schieberegister für Ausgänge verwendet werden. Dabei muss jeweils vor dem Zugriff auf die Ein- oder Ausgangsregister der Modus des Taktes (CPOL) umgeschaltet werden.

=== Ansteuerung per Software ===

<avrasm>
; Porterweiterung für Eingänge mit Schieberegister 74xx165
; Ansteuerung per Software

.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

; Pins anpassen, frei wählbar

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ SCHIEBE_PIN = PINB
.equ CLK = PB3
.equ PL = PB1
.equ DIN = PB2

;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------

.dseg
.org 0x60
Daten: .byte 2 ; Speicherplatz für Eingangsdaten

;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------
.cseg
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

; CLK und PL als Ausgänge schalten

ldi temp1, (1<<clk) | (1<<pl)
out SCHIEBE_DDR, temp1

sbi schiebe_port, clk ; Takt im Ruhezustand immer auf 1
; komische Schaltung im 74xx165

; Zwei Bytes einlesen

ldi ZL,low(Daten)
ldi ZH,high(Daten)
ldi temp1,2
rcall schiebe_eingang

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; N Bytes seriell einlesen
;
; temp1 : N, Anzahl der Bytes
; Z : Zeiger auf einen Datenbereich im SRAM
;-----------------------------------------------------------------------------

schiebe_eingang:
push temp2 ; Register sichern
push temp3

cbi schiebe_port, pl ; Daten parallel laden
sbi schiebe_port, pl

schiebe_eingang_byte_schleife:

ldi temp3, 8 ; Bitzähler
schiebe_eingang_bit_schleife:
lsl temp2 ; Daten weiterschieben

; das IO Bit Din in das niederwerigste Bit von temp2 kopieren

sbic schiebe_pin, din
ori temp2,1 ; Bit setzen
sbis schiebe_pin, din
andi temp2, ~1 ; Bit löschen

cbi SCHIEBE_PORT, CLK ; Taktausgang auf 0
sbi SCHIEBE_PORT, CLK ; und wieder zurück auf 1, dabei Daten schieben

dec temp3 ; Bitzähler um eins verringern
brne schiebe_eingang_bit_schleife ;wenn noch keine 8 Bits ausgegeben, nochmal

st z+,temp2 ; Datenbyte speichern
dec temp1 ; Anzahl Bytes um eins verringern
brne schiebe_eingang_byte_schleife ; wenn noch mehr Bytes zu lesen sind

pop temp3
pop temp2
ret
</avrasm>

=== Ansteuerung per SPI-Modul ===

<avrasm>
; Porterweiterung für Eingänge mit Schieberegister 74xx165
; Ansteuerung per SPI-Modul

.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

; Pins anpassen
; diese müssen mit den SPI-Pins des AVR Typs übereinstimmen!

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ PL = PB2 ; SS
.equ CLK = PB5 ; SCK
.equ DIN = PB4 ; MISO

;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------

.dseg
.org 0x60
Daten: .byte 2 ; Speicherplatz für Eingangsdaten

;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------
.cseg
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

; CLK und PL als Ausgänge schalten

ldi temp1,(1<<CLK) | (1<<PL)
out SCHIEBE_DDR,temp1
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01011000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 1, CPHA =0
; SCK Takt = 1/2 XTAL
ldi temp1,1
out SPSR,temp1 ; double speed aktivieren
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen

; Zwei Bytes einlesen

ldi ZL,low(Daten)
ldi ZH,high(Daten)
ldi temp1,2
rcall schiebe_eingang

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; N Bytes seriell einlesen
;
; temp1 : N, Anzahl der Bytes
; Z : Zeiger auf einen Datenbereich im SRAM
;-----------------------------------------------------------------------------
schiebe_eingang:
push temp2 ; Register sichern

; CLK ist im Ruhezustand schon auf HIGH, CPOL=1

cbi schiebe_port, pl ; Daten parallel laden
sbi schiebe_port, pl

schiebe_eingang_1:
sbis SPSR,7 ; prüfe ob eine alte Übertragung beendet ist
rjmp schiebe_eingang_1

schiebe_eingang_byte_schleife:
out SPDR,temp1 ; beliebige Daten ins SPI Modul schreiben
; um die Übertragung zu starten
schiebe_eingang_2:
sbis SPSR,7 ; auf das Ende der Übertragung warten
rjmp schiebe_eingang_2

in temp2, spdr ; Daten lesen
st z+,temp2 ; Datenbyte speichern
dec temp1 ; Anzahl Bytes um eins verringern
brne schiebe_eingang_byte_schleife ; wenn noch mehr Bytes zu lesen sind

pop temp2
ret
</avrasm>

== Bekannte Probleme ==

AVR Studio 4.12 (Build 498) hat Probleme bei der korrekten Simulation des SPI-Moduls.

* Der Double-Speed Modus funktioniert nicht.

* Das Bit SPIF im Register SPSR, welches laut Dokumentation nur lesbar ist, ist im Simulator auch schreibbar! Das kann zu Verwirrung und Fehlern in der Simulation führen.

Hardwareprobleme

* Wenn das SPI-Modul aktiviert wird, wird '''NICHT''' automatisch SPIF gesetzt, es bleibt auf Null. Damit würde die erste Abfrage in ''Schiebe_alles'' in einer Endlosschleife hängen bleiben. Deshalb muss nach der Initialisierung des SPI-Moduls ein Dummy Byte gesendet werden, damit am Ende der Übertragung SPIF gesetzt wird

* Da das SPI-Modul in Senderichtung nur einfach gepuffert ist, ist es nicht möglich absolut lückenlos Daten zu senden, auch wenn man mit '''nop''' eine feste minimale Zeit zwischen zwei Bytes warten würde. Zwischen zwei Bytes muss immer eine Pause von mind. 2 Systemtakten eingehalten werden.

{{Navigation_zurückhochvor|
zurücktext=PWM|
zurücklink=AVR-Tutorial: PWM|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=SRAM|
vorlink=AVR-Tutorial: SRAM}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Schieberegister

2008-01-08T22:39:41Z

FalkB: Artikel erweitert um Eingangsregister 74xx165

Ab und an stellt sich folgendes Problem: Man würde wesentlich mehr Ausgangspins oder Eingangspins benötigen als der [[Mikrocontroller]] zur Verfügung stellt. Ein möglicher Ausweg ist eine Porterweiterung mit einem Schieberegister. Zwei beliebte Schieberegister sind beispielsweise der 74xx595 bzw. der 74xx165.

== Porterweiterung für Ausgänge ==

Um neue Ausgangspins zu gewinnen kann der 74xx595 verwendet werden. Dabei handelt es sich um ein ''8-Bit 3-state Serial-in/Serial-out or Parallel-Out Schieberegister mit einem Ausgangsregister und einem asynchronen Reset''.

Hinter dieser kompliziert anmutenden Beschreibung verbirgt sich eine einfache Funktionalität: Das Schieberegister besteht aus zwei Funktionseinheiten: Dem eigentlichen Schieberegister und dem Ausgangsregister. In das Schieberegister können die Daten seriell hineingetaktet werden und durch ein bestimmtes Signal werden die Daten des Schieberegisters in das Ausgangsregister übernommen und können von dort auf die Ausgangspins geschaltet werden.

Im Einzelnen bedeuten die Begriffe:

{| border="1"
|-
! Begriff || Erklärung
|-
|8-Bit || Acht Ausgangs[[Bit|bit]]s
|-
|3-state || Die acht Registerausgänge können drei Zustände, Low, High und High-Impedanz annehmen. Siehe [[Ausgangsstufen Logik-ICs]]
|-
|Serial-in || Serieller Eingang des Schieberegisters
|-
|Serial-out || Serieller Ausgang des Schieberegisters
|-
|Parallel-Out || Parallele Ausgänge des Ausgangsregisters
|-
|Schieberegister || Serielle Daten werden durch den Baustein durchgeschoben
|-
|Ausgangsregister || Ein Speicher, welcher die Daten des Schieberegisters zwischenspeichern kann. Dieses besteht aus acht [[FlipFlop]]s.
|-
|Asynchroner Reset || Die Daten im Schieberegister können asynchron zum zurückgesetzt werden.
|}

=== Aufbau ===

[[Bild:74xx595-1.png]]

Hinweis: Die Benennung der Pins in den Datenblättern verschiedener Hersteller unterscheidet sich zum Teil. Die Funktionen der Pins sind jedoch gleich.

{| cellspacing=”0” border="1"
|+ '''Beispiele von Hersteller-Pinbenennungen'''
|-
! DIL Pin-Nummer || Funktion || Dieses Tutorial || Motorola / ON Semi || Philips || Fairchild || SGS|| Texas Instruments
|-
| 1 || Ausgang B || QB || QB || Q1 || QB || QB|| QB
|-
| 2 || Ausgang C || QC || QC || Q2 || QC || QC|| QC
|-
| 3 || Ausgang D || QD || QD || Q3 || QD || QD|| QD
|-
| 4 || Ausgang E || QE || QE || Q4 || QE || QE|| QE
|-
| 5 || Ausgang F || QF || QF || Q5 || QF || QF|| QF
|-
| 6 || Ausgang G || QG || QG || Q6 || QG || QG|| QG
|-
| 7 || Ausgang H || QH || QH || Q7 || QH || QH|| QH
|-
| 8 || Masse, 0 V || [nicht dargestellt] || GND || GND || GND || GND|| GND
|-
| 9 || Serieller Ausgang || QH* || SQH || Q7´ ||Q'H || QH´||QH'
|-
| 10 || Reset für Schieberegister || SCL || RESET || /MR || /SCLR || /SCLR || /SRCLR
|-
| 11 || Schiebetakt || SCK || SHIFT CLOCK || SHCP || SCK || SCK || SRCLK
|-
| 12 || Speichertakt || RCK || LATCH CLOCK || STCP || RCK || RCK || RCLK
|-
| 13 || Ausgangssteuerung || G || OUTPUT ENABLE || /OE || /G || /G || /OE
|-
| 14 || Serieller Dateneingang || SER || A || DS || SER || SI || SER
|-
| 15 || Ausgang A || QA || QA || Q0 || QA || QA|| QA
|-
| 16 || Betriebsspannung || [nicht dargestellt] || VCC || VCC || VCC || VCC|| VCC
|}

Der Baustein besteht aus zwei Einheiten:
* dem Schieberegister
* dem Ausgangsregister

Im Schieberegister werden die einzelnen Bits durchgeschoben. Mit jeder positiven Taktflanke(LOW -> HIGH) an '''SCK''' wird eine Schiebeoperation durchgeführt.

Das Ausgangsregister hat die Aufgabe die Ausgangspins des Bausteins anzusteuern. Durch dieses Ausgangsregister ist es möglich, die Schiebeoperationen im Hintergrund durchzuführen, ohne dass IC Pins ihren Wert ändern. Erst wenn die Schiebeoperation abgeschlossen ist, wird der aktuelle Zustand der Schieberegisterkette durch einen Puls an '''RCK''' in das Ausgangsregister übernommen.

===Funktionsweise===

Am Eingang '''SER''' (Pin 14) wird das gewünschte nächste Datum (0 oder 1) angelegt. Durch einen positiven Puls an '''SCK''' (Pin 1) wird der momentan an '''SER''' anliegende Wert als neuer Wert für Bit 0, das unterste Bit des Schieberegisters, übernommen. Gleichzeitig werden alle anderen Bits im Schieberegister um eine Stelle verschoben: Das Bit 6 wird ins Bit 7 übernommen, Bit 5 ins Bit 6, Bit 4 ins Bit 5, etc. sodass das Bit 0 zur Aufnahme des '''SER''' Bits frei wird.

[[Bild:74xx595-2.png]]

Eine Sonderstellung nimmt das ursprüngliche Bit 7 ein. Dieses Bit steht direkt auch am Ausgang '''QH*''' (Pin 9) zur Verfügung. Dadurch ist es möglich an ein Schieberegister einen weiteren Baustein 74xxx595 anzuschliessen und so beliebig viele Schieberegister hintereinander zu schalten (kaskadieren). Auf diese Art lassen sich Schieberegister mit beliebig vielen Stufen aufbauen.

Wurde das Schieberegister mit den Daten gefüllt, so wird mit einem LOW-HIGH Puls am Pin 12, '''RCK''' der Inhalt des Schieberegisters in das Ausgangsregister übernommen.

[[Bild:74xx595-3.png]]

Mit dem Eingang '''G''' (Pin 13) kann das Ausgangsregister freigegeben werden. Liegt '''G''' auf 0, so führen die Ausgänge '''QA''' bis '''QH''' entsprechende Pegel. Liegt '''G''' auf 1, so schalten die Ausgänge '''QA''' bis '''QH''' auf [[Ausgangsstufen Logik-ICs |Tristate]]. D.h. sie treiben aktiv weder LOW oder HIGH, sondern sind hochohmig wie ein Eingänge und nehmen jeden Pegel an, der ihnen von aussen aufgezwungen wird.

Bleibt nur noch der Eingang '''SCL'''(Pin 13). Mit ihm kann das Schieberegister im Baustein gelöscht, also auf eine definierte 0, gesetzt werden.

Die Programmierung eines 74xxx595 Schieberegisters gestaltet sich sehr einfach. Im Grunde gibt es 2 Möglichkeiten:
* Mittels [[SPI]] kann der [[AVR]] das Schieberegister direkt und autark ansteuern. Das ist sehr schnell und verbraucht nur wenig CPU-Leistung
* Sind die entsprechenden SPI-Pins am AVR nicht frei, so ist auch eine softwaremässige Ansteuerung des Schieberegisters mit einfachen Mitteln durchführbar.

=== Ansteuerung per Software===

Für eine komplette Softwarelösung kann das Schieberegister an jede beliebige Port-Pin Kombination angeschlossen werden. Wir wählen die Pins '''PB0''', '''PB1''', '''PB2''' und '''PB3''' um dort die Schieberegisteranschlüsse '''SER''', '''SCK''', '''SCL''' und '''RCK''' anzuschliessen.

[[Bild:Mega8-595.gif]]

Die Programmierung gestaltet sich dann nach folgendem Schema: Die 8 Bits eines Bytes werden nacheinander an den Ausgang '''PB0''' ('''SER''') ausgegeben. Durch Generierung eines Pulses 0-1-0 an Pin '''PB1''' ('''SCK''') übernimmt das Schieberegister nacheinander die einzelnen Bits. Dabei ist zu beachten, dass die Ausgabe mit dem höherwertigen Bit beginnen muss, denn dieses Bit wandert ja am weitesten zur Stelle '''QH'''. Sind alle 8 Bits ausgegeben, so wird durch einen weiteren 0-1-0 Impuls am Pin '''PB3''' ('''RCK''') der Inhalt der Schieberegisterbits 0 bis 7 in die Ausgaberegister '''QA''' bis '''QH''' übernommen. Dadurch, dass am Schieberegister der Eingang '''G''' konstant auf 0-Pegel gehalten wird, erscheint dann auch die Ausgabe sofort an den entsprechenden Pins und kann zb. mit LEDs (low-current LEDs + Vorwiderstand verwenden) sichtbar gemacht werden.

Der Schieberegistereingang '''SCL''' wird auf einer 1 gehalten. Würde er
auf 0 gehen, so würde die Schieberegisterkette gelöscht. Möchte man einen weiteren Prozessorpin einsparen, so kann man diesen Pin auch generell auf Vcc legen. Das Schieberegister könnte man in so einem Fall durch Einschreiben von 0x00 immer noch löschen.

<avrasm>
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = 3
.equ SCK = 1
.equ SCL = 2
.equ SIN = 0

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;
; Die Port Pins auf Ausgang konfigurieren
;
ldi temp1, (1<<RCK) | (1<<SCK) | (1<<SCL) | (1<<SIN)
out SCHIEBE_DDR, temp1

;
; die Clear Leitung am Schieberegister auf 1 stellen
;
sbi SCHIEBE_PORT, SCL

;
; Ein Datenbyte ausgeben
;
ldi temp1, 0b10101010
rcall Schiebe
rcall SchiebeOut

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; Die Ausgabe im Schieberegister in das Ausgaberegister übernehmen
;
; Dazu am RCK Eingang am Schieberegister einen 0-1-0 Puls erzeugen
;
SchiebeOut:
sbi SCHIEBE_PORT, RCK
cbi SCHIEBE_PORT, RCK
ret

;-----------------------------------------------------------------------------
;
; 8 Bits aus temp1 an das Schieberegister ausgeben
Schiebe:
push temp2
ldi temp2, 8 ; 8 Bits müssen ausgegeben werden

Schiebe_1:
;
; jeweils das höchstwertige Bit aus temp1 ins Carry-Flag schieben
; Je nach Zustand des Carry-Flags wird die Datenleitung entsprechend
; gesetzt oder gelöscht
;
rol temp1 ; MSB -> Carry
brcs Schiebe_One ; Carry gesetzt? -> weiter bei Schiebe_One
cbi SCHIEBE_PORT, SIN ; Eine 0 ausgeben
rjmp Schiebe_Clock ; und Sprung zur Clock Puls Generierung
Schiebe_One:
sbi SCHIEBE_PORT, SIN ; Eine 1 ausgeben

;
; einen Impuls an SCK zur Übernahme des Bits nachschieben
;
Schiebe_Clock:
sbi SCHIEBE_PORT, SCK ; Clock-Ausgang auf 1 ...
cbi SCHIEBE_PORT, SCK ; und wieder zurück auf 0

dec temp2 ; Anzahl der ausgegebenen Bits runterzählen
brne Schiebe_1 ; Wenn noch keine 8 Bits ausgegeben -> Schleife bilden

pop temp2
ret
</avrasm>

=== Ansteuerung per SPI-Modul===

Noch schneller geht die Ansteuerung des Schieberegisters mittels [[Serial_Peripheral_Interface | SPI]]-Modul, welches in fast allen AVRs vorhanden ist. Hier wird der Pin '''SCL''' nicht benutzt, da das praktisch keinen Sinn hat. Er muss also fest auf VCC gelegt werden. Die Pins für '''SCK''' und '''SIN''' sind duch den jeweiligen AVR fest vorgegeben. '''SCK''' vom 74xxx595 wird mit '''SCK''' vom AVR verbunden sowie '''SIN''' mit '''MOSI''' ('''M'''aster '''O'''ut, '''S'''lave '''I'''n). '''MISO''' ('''M'''aster '''I'''n, '''S'''lave '''O'''ut) ist hier ungenutzt. Es kann NICHT als '''RCK''' verwendet werden, da es im SPI-Master Modus immer ein Eingang ist! Es kann aber als allgemeiner Eingang verwendet werden. Der AVR-Pin '''SS''' wird sinnvollerweise als '''RCK''' benutzt, da er sowieso als Ausgang geschaltet werden '''muss''', sonst gibt es böse Überaschungen (siehe Datenblatt "SS Pin Functionality"). Je nach Bedarf kann man die Taktrate des SPI-Moduls zwischen 1/2 ... 1/128 des CPU-Taktes wählen. Es spricht kaum etwas dagegen mit maximaler Geschwindigkeit zu arbeiten. Die AVRs können zur Zeit mit maximal 20 MHz getaktet werden, d.h. es sind maximal 10 MHz SPI-Takt möglich. Das ist für ein 74xxx595 kein Problem. Die Übertragung von 8 Bit dauert dann gerade mal 800ns!

<avrasm>
.include "m8def.inc"

.def temp1 = r16

; Die Definitionen müssen an den jeweiligen AVR angepasst werden

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = PB2 ; SS
.equ SCK = PB5 ; SCK
.equ SIN = PB3 ; MOSI

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
; SCK, MOSI, SS als Ausgänge schalten
;
in temp1,SCHIEBE_DDR
ori temp1,(1<<SIN) | (1<<SCK) | (1<<RCK)
out SCHIEBE_DDR,temp1
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01010000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 0, CPHA =0
; SCK Takt = 1/2 XTAL
ldi temp1,1
out SPSR,temp1 ; double speed aktivieren
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen
;
; Ein Datenbyte ausgeben
;
ldi temp1, 0b10101010
rcall Schiebe ; Daten schieben
rcall SchiebeOut ; Daten in Ausgangsregister übernehmen

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; Die Daten im Schieberegister in das Ausgaberegister übernehmen
;
; Dazu am RCK Eingang am Schieberegister einen 0-1-0 Puls erzeugen
;
SchiebeOut:
sbi SCHIEBE_PORT, RCK
cbi SCHIEBE_PORT, RCK
ret

;-----------------------------------------------------------------------------
;
; 8 Bits aus temp1 an das Schieberegister ausgeben
;
Schiebe:
sbis SPSR,7 ; prüfe ob eine alte Übertragung beendet ist
rjmp Schiebe
out SPDR,temp1 ; Daten ins SPI Modul schreiben, Übertragung beginnt automatisch
ret
</avrasm>

===Kaskadieren von Schieberegistern===

Um ein Schieberegister anzuschließen genügen also im einfachsten Fall 4 freie Prozessorpins (3 wenn '''SCL''' nicht benutzt wird) um weitere 8 Ausgangsleitungen zu bekommen. Genügen diese 8 Leitungen nicht, so kann ohne Probleme ein weiteres Schieberegister an das bereits Vorhandene angeschlossen werden:

[[Bild:Mega8-595-2.gif]]

Das nächste Schieberegister wird mit seinem Dateneingang '''SER''' einfach an den dafür vorgesehenen Ausgang '''QH*''' des vorhergehenden Schieberegisters angeschlossen. Die Steuerleitungen '''SCK''', '''RCK''' und '''SCL''' werden parallel zu den bereits vorhandenen geschaltet. Konzeptionell erhält man dadurch ein Schieberegister mit einer Breite von 16 Bit. Werden weiter Bausteine in derselben Manier angeschlossen, so erhöht sich die Anzahl der zur Verfügung stehenden Ausgabeleitungen mit jedem Baustein um 8 ohne dass sich die Anzahl der am Prozessor notwendigen Ausgabepins erhöhen würde. Um diese weiteren Register zu nutzen, muss man in der reinen Softwarelösung nur mehrfach die Funktion '''Schiebe''' aufrufen, um alle Daten auszugeben. Am Ende werden dann mit '''SchiebeOut''' die Daten in die Ausgangsregister übernommen.

Bei der SPI Lösung werden ebenfalls ganz einfach mehrere Bytes über SPI ausgegeben, ehe dann mittels '''RCK''' die in die Schieberegisterkette eingetakteten Bits in das Ausgangsregister übernommen werden.
Um das Ganze ein wenig zu vereinfachen, soll hier eine Funktion zur Ansteuerung mehrerer kaskadierter Schieberegister über das SPI-Modul gezeigt werden. Dabei wird die Ausgabe mehrerer Bytes über eine Schleife realisiert, mehrfache Aufrufe der Funktion sind damit nicht nötig. Statt dessen übergibt man einen Zeiger auf einen Datenblock im RAM sowie die Anzahl der zu übertragenden Bytes. Ausserdem wird die Datenübernahme durch '''RCK''' standardkonform integriert. Denn bei nahezu allen ICs mit SPI wird ein sog. CS-Pin verwendet ('''C'''hip '''S'''elect) Dieser Pin ist meist LOW aktiv, d.h. wenn er HIGH ist, ignoriert der IC alle Signale an '''SCK''' und '''MOSI''' und gibt keine Daten an MISO aus. Ist er LOW, dann ist der IC aktiv und funktioniert normal. Bei der steigenden Flanke an '''CS''' werden die Daten ins Ausgangsregister übernommen. Die Fuktion ist sehr schnell, da die Zeit während der die Übertragung eines Bytes läuft, dazu genutzt wird, den Schleifenzähler zu verringern und zu prüfen sowie neue Sendedaten zu laden. Zwischen den einzelnen Bytes gibt es somit nur eine Pause von max. 6 Systemtakten.

<avrasm>
.include "m8def.inc"
.def temp1 = r16

; Die Definitionen müssen an den jeweiligen AVR angepasst werden

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = PB2 ; SS
.equ SCK = PB5 ; SCK
.equ SIN = PB3 ; MOSI

;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------

.dseg
.org $60
Schiebedaten: .byte 2

;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------

.cseg
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
; SCK, MOSI, SS als Ausgänge schalten
;
in temp1,SCHIEBE_DDR
ori temp1,(1<<SIN) | (1<<SCK) | (1<<RCK)
out SCHIEBE_DDR,temp1

sbi SCHIEBE_PORT, RCK ; Slave select inaktiv
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01010000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 0, CPHA =0
; SCK Takt = 1/2 XTAL
ldi r16,1
out SPSR,r16 ; Double Speed
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen

; den Datenblock mit Daten füllen

ldi temp1,$F0
sts Schiebedaten,temp1
ldi temp1,$55
sts Schiebedaten+1,temp1

loop:
; den Datenblock ausgeben

ldi r16,2
ldi zl,low(Schiebedaten)
ldi zh, high(Schiebedaten)
rcall Schiebe_alle ; Daten ausgeben

rjmp loop ; nur zur Simulation

;-----------------------------------------------------------------------------
;
; N Bytes an das Schieberegister ausgeben und in das Ausgaberegister übernehmen
;
; r16: Anzahl der Datenbytes
; Z: Zeiger auf Datenblock im RAM
;
;-----------------------------------------------------------------------------
Schiebe_alle:
cbi SCHIEBE_PORT, RCK ; RCK LOW, SPI Standardverfahren
push r17

Schiebe_alle_2:
ld r17,Z+
Schiebe_alle_3:
sbis SPSR,SPIF ; prüfe ob eine alte Übertragung beendet ist
rjmp Schiebe_alle_3
out SPDR,r17 ; Daten ins SPI Modul schreiben, Übertragung beginnt automatisch
dec r16
brne Schiebe_alle_2

Schiebe_alle_4:
sbis SPSR,SPIF ; prüfe ob die letzte Übertragung beendet ist
rjmp Schiebe_alle_4

pop r17
sbi SCHIEBE_PORT, RCK ; RCK inaktiv, Datenübernahme
ret
</avrasm>

Der Nachteil von Schieberegistern ist allerdings, dass sich die Zeit zum Setzten aller Ausgabeleitungen mit jedem weiteren Baustein immer weiter erhöht. Dies deshalb, da ja die einzelnen Bits im Gänsemarsch durch alle Bausteine geschleust werden müssen und für jeden einzelnen Schiebevorgang etwas Zeit notwendig ist. Ein Ausweg ist die Verwendung des SPI-Moduls, welches schneller arbeitet als die reine Softwarelösung. Ist noch mehr Geschwindigkeit gefragt, so sind mehr Port-Pins nötig. Kann ein kompletter Port mit 8 Pins für die Daten genutzt werden, sowie ein paar weitere Steuerleitungen, so können ein oder mehrere 74xxx573 eine Alternative sein, um jeweils ein vollständiges Byte auszugeben. Natürlich kann der 74xxx573 (oder ein ähnliches Schieberegister) auch mit dem 74xxx595 zusammen eingesetzt werden, beispielsweise in dem über das Schieberegister verschiedene 74xxx595 nacheinander aktiviert werden. Weitere Tips und Tricks dazu gibt es vielleicht in einem weiteren Tutorial...

=== Acht LEDs mit je 20mA pro Schieberegister ===

Will man nun acht [[LED]]s mit dem Schieberegister ansteuern, kann man diese direkt über Vorwiderstände anschliessen. Doch ein genauer Blick ins Datenblatt verrät, dass der 74xx595 nur maximal 70mA über VCC bzw. GND ableiten kann. Und wenn man den IC nicht gnadenlos quälen, und damit die Lebensdauer und Zuverlässigkeit drastisch reduzieren will, gibt es nur zwei Auswege.

* Den Strom pro LED auf 70/8 = 8,75mA begrenzen; Das reicht meistens aus um die LEDs schön leuchten zu lassen, vor allem bei low-current und ultrahellen LEDs
* Wenn doch 20 mA pro LED gebraucht werden, kann man die folgende Trickschaltung anwenden.

[[bild:8x20mA_LED_mit_74xx595.png]]

Der Trick besteht darin, dass 4 LEDs ihren Strom über das Schieberegister von VCC beziehen (HIGH aktiv) während die anderen vier ihren Strom über GND leiten (LOW aktiv). Damit bleiben ganz offiziell für jede LED 70/4 = 17,5mA. Um die Handhabung in der Software zu vereinfachen muss nur vor der Ausgabe der Daten das jeweilige Byte mit 0x0F XOR verknüpft werden, bevor es in das Schieberegister getaktet wird. Dadurch werden die LOW-aktiven LEDs richtig angesteuert und die Datenhandhabung in der Software muss nur mit HIGH-aktiven rechnen.

Achtung! Die Widerstände sind auf blaue LEDs mit 3,3V Flusspannung ausgelegt. Bei roten, gelben und grünen [[LED]]s ist die Flusspannung geringer und dementsprechend muss der Vorwiderstand grösser sein.

Ausserdem wird der G Eingang verwendet, um die Helligkeit aller LEDs per [[PWM]] zu steuern. Beachtet werden muss, dass die PWM im invertierten Modus generiert werden muss, da der Eingang G LOW aktiv ist.

== Porterweiterung für Eingänge ==

Ein naher Verwandter des 75xx595 ist der 74xx165, er ist quasi das Gegenstück. Hierbei handet es sich um ein ''8-bit parallel-in/serial-out shift register''. Auf deutsch ein 8 Bit Schieberegister mit parallelem Eingang und seriellem Ausgang. Damit kann man ein grosse Anzahl Eingänge sehr einfach und preiswert zu seinem Mikrocontroller hinzufügen.

=== Aufbau ===

[[bild:74xx165-1.png]]

Der Aufbau ist sehr ähnlich zum 74xx595. Allerdings gibt es kein Register zum Zwischenspeichern. Das ist auch gar nicht nötig, da der IC ja einen parallelen Eingang hat. Der muss nicht zwischengespeichert werden. Es gibt hier also wirklich nur das Schieberegister. Dieses wird über den Eingang PL mit den parallelen Daten geladen. Dann können die Daten seriell mit Takten an CLK aus dem Ausgang Q7 geschoben werden.

=== Funktionsweise ===

DS ist der serielle Dateneingang, welcher im Falle von kaskadierten Schieberegistern mit dem Ausgang des vorhergehenden ICs verbunden wird.

D0..D7 sind die parallelen Dateneingänge.

Mittels des Eingangs PL ('''P'''arallel '''L'''oad) werden die Daten vom parallelen Eingang in das Schieberegister übernommen, wenn dieses Signal LOW ist. Hier muss man aber ein klein wenig aufpassen. Auf grund der Schaltungsstruktur ist der Eingang PL mit dem Takt CLK verknüpft (obwohl es dafür keinen logischen Grund gibt :-0). Damit es nicht zu unerwünschten Fehlschaltungen kommt, muss der Takt CLK während des Ladens auf HIGH liegen. Wird PL wieder auf HIGH gesetzt, sind die Daten geladen. Das erste Bit liegt direkt am Ausgang Q7 and. Die restlichen Bits können nach und nach durch das Register geschoben werden.

Der Eingang CE ('''C'''lock '''E'''nable) steuert, ob das Schieberegister auf den Takt CLK reagieren soll oder nicht. Ist CE gleich LOW werden alle Takte an CLK ignoriert. Bei HIGH werden mit jeder positiven Flanke die Daten um eine Stufe weiter geschoben.

Wird am Eingang CLK eine LOW-HIGH Flanke angelegt und ist dabei CE auf LOW, dann werden die Daten im Schieberegister um eine Position weiter geschoben: DS->Q0, Q0->Q1, Q1->Q2, Q2->Q3, Q3->Q4, Q4->Q5, Q5->Q6, Q6->Q7. Q0..Q6 sind interne Signale, siehe [http://nxp.com/ Datenblatt].

Q7 ist der Ausgang des Schieberegisters. Dort Werden Takt für Takt die Daten ausgeggeben. Hier wird normalerweise der Eingang des Mikrocontrollers oder der Eingang des nächsten Schieberegisters angeschlossen.

Q7\ ist der invertierte Ausgang des Schieberegisters. Er wird meist nicht verwendet.

=== Schaltung ===

Um nun beispielsweise zwei Schieberegister zu kaskadieren um 16 Eingangspins zu erhalten sollte man folgende Verschaltung vornehmen. Beachten sollte man dabei, dass

* der serielle Eingang DS des ersten Schieberegisters (hier IC1) auf einen festen Pegel gelegt wird (LOW oder HIGH).
* der serielle Datenausgang bei der Benutzung des SPI-Moduls an MISO und nicht an MOSI angeschlossen wird.

[[bild:74xx165-2.png]]

Nachfolgend werden zwei Beispiele gezeigt, welche die Ansteuerung nach bekanntem Muster übernehemn. Nur dass hier eben Daten gelesen anstatt geschrieben werden. Zu beachten ist, dass hier ein anderer Modus der SPI-Ansteuerung verwendet werden muss, weil der Baustein das nötig macht. Das muss beachtet werden, wenn auch Schieberegister für Ausgänge verwendet werden. Dabei muss jeweils vor dem Zugriff auf die Ein- oder Ausgangsregister der Modus des Taktes (CPOL) umgeschaltet werden.

=== Ansteuerung per Software ===

<avrasm>
; Porterweiterung für Eingänge mit Schieberegister 74xx165
; Ansteuerung per Software

.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

; Pins anpassen, frei wählbar

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ SCHIEBE_PIN = PINB
.equ CLK = PB3
.equ PL = PB1
.equ DIN = PB2

;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------

.dseg
.org 0x60
Daten: .byte 2 ; Speicherplatz für Eingangsdaten

;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------
.cseg
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

; CLK und PL als Ausgänge schalten

ldi temp1, (1<<clk) | (1<<pl)
out SCHIEBE_DDR, temp1

sbi schiebe_port, clk ; Takt im Ruhezustand immer auf 1
; komische Schaltung im 74xx165

; Zwei Bytes einlesen

ldi ZL,low(Daten)
ldi ZH,high(Daten)
ldi temp1,2
rcall schiebe_eingang

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; N Bytes seriell einlesen
;
; temp1 : N, Anzahl der Bytes
; Z : Zeiger auf einen Datenbereich im SRAM
;-----------------------------------------------------------------------------

schiebe_eingang:
push temp2 ; Register sichern
push temp3

cbi schiebe_port, pl ; Daten parallel laden
sbi schiebe_port, pl

schiebe_eingang_byte_schleife:

ldi temp3, 8 ; Bitzähler
schiebe_eingang_bit_schleife:
lsl temp2 ; Daten weiterschieben

; das IO Bit Din in das niederwerigste Bit von temp2 kopieren

sbic schiebe_pin, din
ori temp2,1 ; Bit setzen
sbis schiebe_pin, din
andi temp2, ~1 ; Bit löschen

cbi SCHIEBE_PORT, CLK ; Taktausgang auf 0
sbi SCHIEBE_PORT, CLK ; und wieder zurück auf 1, dabei Daten schieben

dec temp3 ; Bitzähler um eins verringern
brne schiebe_eingang_bit_schleife ;wenn noch keine 8 Bits ausgegeben, nochmal

st z+,temp2 ; Datenbyte speichern
dec temp1 ; Anzahl Bytes um eins verringern
brne schiebe_eingang_byte_schleife ; wenn noch mehr Bytes zu lesen sind

pop temp3
pop temp2
ret
</avrasm>

=== Ansteuerung per SPI-Modul ===

<avrasm>
; Porterweiterung für Eingänge mit Schieberegister 74xx165
; Ansteuerung per SPI-Modul

.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18

; Pins anpassen
; diese müssen mit den SPI-Pins des AVR Typs übereinstimmen!

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ PL = PB2 ; SS
.equ CLK = PB5 ; SCK
.equ DIN = PB4 ; MISO

;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------

.dseg
.org 0x60
Daten: .byte 2 ; Speicherplatz für Eingangsdaten

;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------
.cseg
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

; CLK und PL als Ausgänge schalten

ldi temp1,(1<<CLK) | (1<<PL)
out SCHIEBE_DDR,temp1
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01011000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 1, CPHA =0
; SCK Takt = 1/2 XTAL
ldi temp1,1
out SPSR,temp1 ; double speed aktivieren
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen

; Zwei Bytes einlesen

ldi ZL,low(Daten)
ldi ZH,high(Daten)
ldi temp1,2
rcall schiebe_eingang

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; N Bytes seriell einlesen
;
; temp1 : N, Anzahl der Bytes
; Z : Zeiger auf einen Datenbereich im SRAM
;-----------------------------------------------------------------------------
schiebe_eingang:
push temp2 ; Register sichern

; CLK ist im Ruhezustand schon auf HIGH, CPOL=1

cbi schiebe_port, pl ; Daten parallel laden
sbi schiebe_port, pl

schiebe_eingang_1:
sbis SPSR,7 ; prüfe ob eine alte Übertragung beendet ist
rjmp schiebe_eingang_1

schiebe_eingang_byte_schleife:
out SPDR,temp1 ; beliebige Daten ins SPI Modul schreiben
; um die Übertragung zu starten
schiebe_eingang_2:
sbis SPSR,7 ; auf das Ende der Übertragung warten
rjmp schiebe_eingang_2

in temp2, spdr ; Daten lesen
st z+,temp2 ; Datenbyte speichern
dec temp1 ; Anzahl Bytes um eins verringern
brne schiebe_eingang_byte_schleife ; wenn noch mehr Bytes zu lesen sind

pop temp2
ret
</avrasm>

== Bekannte Probleme ==

AVR Studio 4.12 (Build 498) hat Probleme bei der korrekten Simulation des SPI-Moduls.

* Der Double-Speed Modus funktioniert nicht.

* Das Bit SPIF im Register SPSR, welches laut Dokumentation nur lesbar ist, ist im Simulator auch schreibbar! Das kann zu Verwirrung und Fehlern in der Simulation führen.

Hardwareprobleme

* Wenn das SPI-Modul aktiviert wird, wird '''NICHT''' automatisch SPIF gesetzt, es bleibt auf Null. Damit würde die erste Abfrage in ''Schiebe_alles'' in einer Endlosschleife hängen bleiben. Deshalb muss nach der Initialisierung des SPI-Moduls ein Dummy Byte gesendet werden, damit am Ende der Übertragung SPIF gesetzt wird

* Da das SPI-Modul in Senderichtung nur einfach gepuffert ist, ist es nicht möglich absolut lückenlos Daten zu senden, auch wenn man mit '''nop''' eine feste minimale Zeit zwischen zwei Bytes warten würde. Zwischen zwei Bytes muss immer eine Pause von mind. 2 Systemtakten eingehalten werden.

{{Navigation_zurückhochvor|
zurücktext=PWM|
zurücklink=AVR-Tutorial: PWM|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=SRAM|
vorlink=AVR-Tutorial: SRAM}}

[[Category:AVR]][[Category:AVR-Tutorial]]

Datei:74xx165-2.png

2008-01-08T22:37:28Z

FalkB:

Datei:74xx165-1.png

2008-01-08T22:37:08Z

FalkB:

AVR-Tutorial: Schieberegister

2008-01-08T18:44:57Z

FalkB: Formatierung verbessert

Ab und an stellt sich folgendes Problem: Man würde wesentlich mehr Ausgangsleitungen zu Steuerzwecken benötigen, als der µC zur Verfügung stellt. Ein möglicher Ausweg ist eine Porterweiterung mit einem Schieberegister. Ein beliebter Schieberegisterbaustein ist beispielsweise der 74xxx595 (74HC595, 74HCT595, 74SN595, 74AC595...).

==Der Baustein 74xxx595==
Ein 74xxx595 ist ein ''8-Bit 3-state Serial-in/Serial-out or Parallel-Out Schieberegister mit einem Ausgaberegister und einem asynchronen Reset''.

Hinter dieser kompliziert anmutenden Beschreibung verbirgt sich eine einfache Funktionalität: Das Schieberegister besteht aus zwei Funktionseinheiten: Dem eigentlichen Schieberegister und dem Ausgangsregister. In das Schieberegister können die Daten seriell hineingetaktet werden und durch ein bestimmtes Signal werden die Daten der Schiebestufe in das Ausgangsregister übernommen und können von dort auf die Ausgangspins geschaltet werden.

Im Einzelnen bedeuten die Begriffe:

{| border="1"
|-
! Begriff || Erklärung
|-
|8-Bit || Acht Ausgangs[[Bit|bit]]s
|-
|3-state || Die acht Registerausgänge können drei Zustände, Low, High und High-Impedanz annehmen. Siehe [[Ausgangsstufen Logik-ICs]]
|-
|Serial-in || Serieller Eingang des Schieberegisters
|-
|Serial-out || Serieller Ausgang des Schieberegisters
|-
|Parallel-Out || Parallele Ausgänge des Ausgangsregisters
|-
|Schieberegister || Serielle Daten werden durch den Baustein durchgeschoben
|-
|Ausgangsregister || Ein Speicher, welcher die Daten des Schieberegisters zwischenspeichern kann. Dieses besteht aus acht [[FlipFlop]]s.
|-
|Asynchroner Reset || Die Daten im Schieberegister können asynchron zum zurückgesetzt werden.
|}

===Pinbelegung des Bausteins===

[[Bild:74xx595-1.png]]

Hinweis: Die Benennung der Pins in den Datenblättern verschiedener Hersteller unterscheidet sich zum Teil. Die Funktionen der Pins sind jedoch gleich.

{| cellspacing=”0” border="1"
|+ '''Beispiele von Hersteller-Pinbenennungen'''
|-
! DIL Pin-Nummer || Funktion || Dieses Tutorial || Motorola / ON Semi || Philips || Fairchild || SGS|| Texas Instruments
|-
| 1 || Ausgang B || QB || QB || Q1 || QB || QB|| QB
|-
| 2 || Ausgang C || QC || QC || Q2 || QC || QC|| QC
|-
| 3 || Ausgang D || QD || QD || Q3 || QD || QD|| QD
|-
| 4 || Ausgang E || QE || QE || Q4 || QE || QE|| QE
|-
| 5 || Ausgang F || QF || QF || Q5 || QF || QF|| QF
|-
| 6 || Ausgang G || QG || QG || Q6 || QG || QG|| QG
|-
| 7 || Ausgang H || QH || QH || Q7 || QH || QH|| QH
|-
| 8 || Masse, 0 V || [nicht dargestellt] || GND || GND || GND || GND|| GND
|-
| 9 || Serieller Ausgang || QH* || SQH || Q7´ ||Q'H || QH´||QH'
|-
| 10 || Reset für Schieberegister || SCL || RESET || /MR || /SCLR || /SCLR || /SRCLR
|-
| 11 || Schiebetakt || SCK || SHIFT CLOCK || SHCP || SCK || SCK || SRCLK
|-
| 12 || Speichertakt || RCK || LATCH CLOCK || STCP || RCK || RCK || RCLK
|-
| 13 || Ausgangssteuerung || G || OUTPUT ENABLE || /OE || /G || /G || /OE
|-
| 14 || Serieller Dateneingang || SER || A || DS || SER || SI || SER
|-
| 15 || Ausgang A || QA || QA || Q0 || QA || QA|| QA
|-
| 16 || Betriebsspannung || [nicht dargestellt] || VCC || VCC || VCC || VCC|| VCC
|}

===Prinzipskizze des Bausteins===

Der Baustein besteht aus zwei Einheiten:
* dem Schieberegister
* dem Ausgangsregister

Im Schieberegister werden die einzelnen Bits durchgeschoben. Mit jeder positiven Taktflanke(LOW -> HIGH) an '''SCK''' wird eine Schiebeoperation durchgeführt.

Das Ausgangsregister hat die Aufgabe die Ausgangspins des Bausteins anzusteuern. Durch dieses Ausgangsregister ist es möglich, die Schiebeoperationen im Hintergrund durchzuführen, ohne dass IC Pins ihren Wert ändern. Erst wenn die Schiebeoperation abgeschlossen ist, wird der aktuelle Zustand der Schieberegisterkette durch einen Puls an '''RCK''' in das Ausgangsregister übernommen.

===Funktionsweise===

Am Eingang '''SER''' (Pin 14) wird das gewünschte nächste Datum (0 oder 1) angelegt. Durch einen positiven Puls an '''SCK''' (Pin 1) wird der momentan an '''SER''' anliegende Wert als neuer Wert für Bit 0, das unterste Bit des Schieberegisters, übernommen. Gleichzeitig werden alle anderen Bits im Schieberegister um eine Stelle verschoben: Das Bit 6 wird ins Bit 7 übernommen, Bit 5 ins Bit 6, Bit 4 ins Bit 5, etc. sodass das Bit 0 zur Aufnahme des '''SER''' Bits frei wird.

[[Bild:74xx595-2.png]]

Eine Sonderstellung nimmt das ursprüngliche Bit 7 ein. Dieses Bit steht direkt auch am Ausgang '''QH*''' (Pin 9) zur Verfügung. Dadurch ist es möglich an ein Schieberegister einen weiteren Baustein 74xxx595 anzuschliessen und so beliebig viele Schieberegister hintereinander zu schalten (kaskadieren). Auf diese Art lassen sich Schieberegister mit beliebig vielen Stufen aufbauen.

Wurde das Schieberegister mit den Daten gefüllt, so wird mit einem LOW-HIGH Puls am Pin 12, '''RCK''' der Inhalt des Schieberegisters in das Ausgangsregister übernommen.

[[Bild:74xx595-3.png]]

Mit dem Eingang '''G''' (Pin 13) kann das Ausgangsregister freigegeben werden. Liegt '''G''' auf 0, so führen die Ausgänge '''QA''' bis '''QH''' entsprechende Pegel. Liegt '''G''' auf 1, so schalten die Ausgänge '''QA''' bis '''QH''' auf [[Ausgangsstufen Logik-ICs |Tristate]]. D.h. sie treiben aktiv weder LOW oder HIGH, sondern sind hochohmig wie ein Eingänge und nehmen jeden Pegel an, der ihnen von aussen aufgezwungen wird.

Bleibt nur noch der Eingang '''SCL'''(Pin 13). Mit ihm kann das Schieberegister im Baustein gelöscht, also auf eine definierte 0, gesetzt werden.

==Programmierung des 74xxx595==

Die Programmierung eines 74xxx595 Schieberegisters gestaltet sich sehr einfach. Im Grunde gibt es 2 Möglichkeiten:
* Mittels [[SPI]] kann der [[AVR]] das Schieberegister direkt und autark ansteuern. Das ist sehr schnell und verbraucht nur wenig CPU-Leistung
* Sind die entsprechenden SPI-Pins am AVR nicht frei, so ist auch eine softwaremässige Ansteuerung des Schieberegisters mit einfachen Mitteln durchführbar.

=== Direkte Ansteuerung per Software===

Für eine komplette Softwarelösung kann das Schieberegister an jede beliebige Port-Pin Kombination angeschlossen werden. Wir wählen die Pins '''PB0''', '''PB1''', '''PB2''' und '''PB3''' um dort die Schieberegisteranschlüsse '''SER''', '''SCK''', '''SCL''' und '''RCK''' anzuschliessen.

[[Bild:Mega8-595.gif]]

Die Programmierung gestaltet sich dann nach folgendem Schema: Die 8 Bits eines Bytes werden nacheinander an den Ausgang '''PB0''' ('''SER''') ausgegeben. Durch Generierung eines Pulses 0-1-0 an Pin '''PB1''' ('''SCK''') übernimmt das Schieberegister nacheinander die einzelnen Bits. Dabei ist zu beachten, dass die Ausgabe mit dem höherwertigen Bit beginnen muss, denn dieses Bit wandert ja am weitesten zur Stelle '''QH'''. Sind alle 8 Bits ausgegeben, so wird durch einen weiteren 0-1-0 Impuls am Pin '''PB3''' ('''RCK''') der Inhalt der Schieberegisterbits 0 bis 7 in die Ausgaberegister '''QA''' bis '''QH''' übernommen. Dadurch, dass am Schieberegister der Eingang '''G''' konstant auf 0-Pegel gehalten wird, erscheint dann auch die Ausgabe sofort an den entsprechenden Pins und kann zb. mit LEDs (low-current LEDs + Vorwiderstand verwenden) sichtbar gemacht werden.

Der Schieberegistereingang '''SCL''' wird auf einer 1 gehalten. Würde er
auf 0 gehen, so würde die Schieberegisterkette gelöscht. Möchte man einen weiteren Prozessorpin einsparen, so kann man diesen Pin auch generell auf Vcc legen. Das Schieberegister könnte man in so einem Fall durch Einschreiben von 0x00 immer noch löschen.

<avrasm>
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = 3
.equ SCK = 1
.equ SCL = 2
.equ SIN = 0

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;
; Die Port Pins auf Ausgang konfigurieren
;
ldi temp1, (1<<RCK) | (1<<SCK) | (1<<SCL) | (1<<SIN)
out SCHIEBE_DDR, temp1

;
; die Clear Leitung am Schieberegister auf 1 stellen
;
sbi SCHIEBE_PORT, SCL

;
; Ein Datenbyte ausgeben
;
ldi temp1, 0b10101010
rcall Schiebe
rcall SchiebeOut

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; Die Ausgabe im Schieberegister in das Ausgaberegister übernehmen
;
; Dazu am RCK Eingang am Schieberegister einen 0-1-0 Puls erzeugen
;
SchiebeOut:
sbi SCHIEBE_PORT, RCK
cbi SCHIEBE_PORT, RCK
ret

;-----------------------------------------------------------------------------
;
; 8 Bits aus temp1 an das Schieberegister ausgeben
Schiebe:
push temp2
ldi temp2, 8 ; 8 Bits müssen ausgegeben werden

Schiebe_1:
;
; jeweils das höchstwertige Bit aus temp1 ins Carry-Flag schieben
; Je nach Zustand des Carry-Flags wird die Datenleitung entsprechend
; gesetzt oder gelöscht
;
rol temp1 ; MSB -> Carry
brcs Schiebe_One ; Carry gesetzt? -> weiter bei Schiebe_One
cbi SCHIEBE_PORT, SIN ; Eine 0 ausgeben
rjmp Schiebe_Clock ; und Sprung zur Clock Puls Generierung
Schiebe_One:
sbi SCHIEBE_PORT, SIN ; Eine 1 ausgeben

;
; einen Impuls an SCK zur Übernahme des Bits nachschieben
;
Schiebe_Clock:
sbi SCHIEBE_PORT, SCK ; Clock-Ausgang auf 1 ...
cbi SCHIEBE_PORT, SCK ; und wieder zurück auf 0

dec temp2 ; Anzahl der ausgegebenen Bits runterzählen
brne Schiebe_1 ; Wenn noch keine 8 Bits ausgegeben -> Schleife bilden

pop temp2
ret
</avrasm>

===Ansteuerung mittels SPI===

Noch schneller geht die Ansteuerung des Schieberegisters mittels [[Serial_Peripheral_Interface | SPI]]-Modul, welches in fast allen AVRs vorhanden ist. Hier wird der Pin '''SCL''' nicht benutzt, da das praktisch keinen Sinn hat. Er muss also fest auf VCC gelegt werden. Die Pins für '''SCK''' und '''SIN''' sind duch den jeweiligen AVR fest vorgegeben. '''SCK''' vom 74xxx595 wird mit '''SCK''' vom AVR verbunden sowie '''SIN''' mit '''MOSI''' ('''M'''aster '''O'''ut, '''S'''lave '''I'''n). '''MISO''' ('''M'''aster '''I'''n, '''S'''lave '''O'''ut) ist hier ungenutzt. Es kann NICHT als '''RCK''' verwendet werden, da es im SPI-Master Modus immer ein Eingang ist! Es kann aber als allgemeiner Eingang verwendet werden. Der AVR-Pin '''SS''' wird sinnvollerweise als '''RCK''' benutzt, da er sowieso als Ausgang geschaltet werden '''muss''', sonst gibt es böse Überaschungen (siehe Datenblatt "SS Pin Functionality"). Je nach Bedarf kann man die Taktrate des SPI-Moduls zwischen 1/2 ... 1/128 des CPU-Taktes wählen. Es spricht kaum etwas dagegen mit maximaler Geschwindigkeit zu arbeiten. Die AVRs können zur Zeit mit maximal 20 MHz getaktet werden, d.h. es sind maximal 10 MHz SPI-Takt möglich. Das ist für ein 74xxx595 kein Problem. Die Übertragung von 8 Bit dauert dann gerade mal 800ns!

<avrasm>
.include "m8def.inc"

.def temp1 = r16

; Die Definitionen müssen an den jeweiligen AVR angepasst werden

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = PB2 ; SS
.equ SCK = PB5 ; SCK
.equ SIN = PB3 ; MOSI

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
; SCK, MOSI, SS als Ausgänge schalten
;
in temp1,SCHIEBE_DDR
ori temp1,(1<<SIN) | (1<<SCK) | (1<<RCK)
out SCHIEBE_DDR,temp1
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01010000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 0, CPHA =0
; SCK Takt = 1/2 XTAL
ldi temp1,1
out SPSR,temp1 ; double speed aktivieren
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen
;
; Ein Datenbyte ausgeben
;
ldi temp1, 0b10101010
rcall Schiebe ; Daten schieben
rcall SchiebeOut ; Daten in Ausgangsregister übernehmen

loop:
rjmp loop

;-----------------------------------------------------------------------------
;
; Die Daten im Schieberegister in das Ausgaberegister übernehmen
;
; Dazu am RCK Eingang am Schieberegister einen 0-1-0 Puls erzeugen
;
SchiebeOut:
sbi SCHIEBE_PORT, RCK
cbi SCHIEBE_PORT, RCK
ret

;-----------------------------------------------------------------------------
;
; 8 Bits aus temp1 an das Schieberegister ausgeben
;
Schiebe:
sbis SPSR,7 ; prüfe ob eine alte Übertragung beendet ist
rjmp Schiebe
out SPDR,temp1 ; Daten ins SPI Modul schreiben, Übertragung beginnt automatisch
ret
</avrasm>

==Kaskadieren von Schieberegistern==

Um ein Schieberegister anzuschließen genügen also im einfachsten Fall 4 freie Prozessorpins (3 wenn '''SCL''' nicht benutzt wird) um weitere 8 Ausgangsleitungen zu bekommen. Genügen diese 8 Leitungen nicht, so kann ohne Probleme ein weiteres Schieberegister an das bereits Vorhandene angeschlossen werden:

[[Bild:Mega8-595-2.gif]]

Das nächste Schieberegister wird mit seinem Dateneingang '''SER''' einfach an den dafür vorgesehenen Ausgang '''QH*''' des vorhergehenden Schieberegisters angeschlossen. Die Steuerleitungen '''SCK''', '''RCK''' und '''SCL''' werden parallel zu den bereits vorhandenen geschaltet. Konzeptionell erhält man dadurch ein Schieberegister mit einer Breite von 16 Bit. Werden weiter Bausteine in derselben Manier angeschlossen, so erhöht sich die Anzahl der zur Verfügung stehenden Ausgabeleitungen mit jedem Baustein um 8 ohne dass sich die Anzahl der am Prozessor notwendigen Ausgabepins erhöhen würde. Um diese weiteren Register zu nutzen, muss man in der reinen Softwarelösung nur mehrfach die Funktion '''Schiebe''' aufrufen, um alle Daten auszugeben. Am Ende werden dann mit '''SchiebeOut''' die Daten in die Ausgangsregister übernommen.

Bei der SPI Lösung werden ebenfalls ganz einfach mehrere Bytes über SPI ausgegeben, ehe dann mittels '''RCK''' die in die Schieberegisterkette eingetakteten Bits in das Ausgangsregister übernommen werden.
Um das Ganze ein wenig zu vereinfachen, soll hier eine Funktion zur Ansteuerung mehrerer kaskadierter Schieberegister über das SPI-Modul gezeigt werden. Dabei wird die Ausgabe mehrerer Bytes über eine Schleife realisiert, mehrfache Aufrufe der Funktion sind damit nicht nötig. Statt dessen übergibt man einen Zeiger auf einen Datenblock im RAM sowie die Anzahl der zu übertragenden Bytes. Ausserdem wird die Datenübernahme durch '''RCK''' standardkonform integriert. Denn bei nahezu allen ICs mit SPI wird ein sog. CS-Pin verwendet ('''C'''hip '''S'''elect) Dieser Pin ist meist LOW aktiv, d.h. wenn er HIGH ist, ignoriert der IC alle Signale an '''SCK''' und '''MOSI''' und gibt keine Daten an MISO aus. Ist er LOW, dann ist der IC aktiv und funktioniert normal. Bei der steigenden Flanke an '''CS''' werden die Daten ins Ausgangsregister übernommen. Die Fuktion ist sehr schnell, da die Zeit während der die Übertragung eines Bytes läuft, dazu genutzt wird, den Schleifenzähler zu verringern und zu prüfen sowie neue Sendedaten zu laden. Zwischen den einzelnen Bytes gibt es somit nur eine Pause von max. 6 Systemtakten.

<avrasm>
.include "m8def.inc"
.def temp1 = r16

; Die Definitionen müssen an den jeweiligen AVR angepasst werden

.equ SCHIEBE_DDR = DDRB
.equ SCHIEBE_PORT = PORTB
.equ RCK = PB2 ; SS
.equ SCK = PB5 ; SCK
.equ SIN = PB3 ; MOSI

;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------

.dseg
.org $60
Schiebedaten: .byte 2

;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------

.cseg
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
; SCK, MOSI, SS als Ausgänge schalten
;
in temp1,SCHIEBE_DDR
ori temp1,(1<<SIN) | (1<<SCK) | (1<<RCK)
out SCHIEBE_DDR,temp1

sbi SCHIEBE_PORT, RCK ; Slave select inaktiv
;
; SPI Modul konfigurieren
;
ldi temp1, 0b01010000
out SPCR, temp1 ; keine Interrupts, MSB first, Master
; CPOL = 0, CPHA =0
; SCK Takt = 1/2 XTAL
ldi r16,1
out SPSR,r16 ; Double Speed
out SPDR,temp1 ; Dummy Daten, um SPIF zu setzen

; den Datenblock mit Daten füllen

ldi temp1,$F0
sts Schiebedaten,temp1
ldi temp1,$55
sts Schiebedaten+1,temp1

loop:
; den Datenblock ausgeben

ldi r16,2
ldi zl,low(Schiebedaten)
ldi zh, high(Schiebedaten)
rcall Schiebe_alle ; Daten ausgeben

rjmp loop ; nur zur Simulation

;-----------------------------------------------------------------------------
;
; N Bytes an das Schieberegister ausgeben und in das Ausgaberegister übernehmen
;
; r16: Anzahl der Datenbytes
; Z: Zeiger auf Datenblock im RAM
;
;-----------------------------------------------------------------------------
Schiebe_alle:
cbi SCHIEBE_PORT, RCK ; RCK LOW, SPI Standardverfahren
push r17

Schiebe_alle_2:
ld r17,Z+
Schiebe_alle_3:
sbis SPSR,SPIF ; prüfe ob eine alte Übertragung beendet ist
rjmp Schiebe_alle_3
out SPDR,r17 ; Daten ins SPI Modul schreiben, Übertragung beginnt automatisch
dec r16
brne Schiebe_alle_2

Schiebe_alle_4:
sbis SPSR,SPIF ; prüfe ob die letzte Übertragung beendet ist
rjmp Schiebe_alle_4

pop r17
sbi SCHIEBE_PORT, RCK ; RCK inaktiv, Datenübernahme
ret
</avrasm>

Der Nachteil von Schieberegistern ist allerdings, dass sich die Zeit zum Setzten aller Ausgabeleitungen mit jedem weiteren Baustein immer weiter erhöht. Dies deshalb, da ja die einzelnen Bits im Gänsemarsch durch alle Bausteine geschleust werden müssen und für jeden einzelnen Schiebevorgang etwas Zeit notwendig ist. Ein Ausweg ist die Verwendung des SPI-Moduls, welches schneller arbeitet als die reine Softwarelösung. Ist noch mehr Geschwindigkeit gefragt, so sind mehr Port-Pins nötig. Kann ein kompletter Port mit 8 Pins für die Daten genutzt werden, sowie ein paar weitere Steuerleitungen, so können ein oder mehrere 74xxx573 eine Alternative sein, um jeweils ein vollständiges Byte auszugeben. Natürlich kann der 74xxx573 (oder ein ähnliches Schieberegister) auch mit dem 74xxx595 zusammen eingesetzt werden, beispielsweise in dem über das Schieberegister verschiedene 74xxx595 nacheinander aktiviert werden. Weitere Tips und Tricks dazu gibt es vielleicht in einem weiteren Tutorial...

== Acht LEDs mit je 20mA pro Schieberegister ==

Will man nun acht [[LED]]s mit dem Schieberegister ansteuern, kann man diese direkt über Vorwiderstände anschliessen. Doch ein genauer Blick ins Datenblatt verrät, dass der 74xx595 nur maximal 70mA über VCC bzw. GND ableiten kann. Und wenn man den IC nicht gnadenlos quälen, und damit die Lebensdauer und Zuverlässigkeit drastisch reduzieren will, gibt es nur zwei Auswege.

* Den Strom pro LED auf 70/8 = 8,75mA begrenzen; Das reicht meistens aus um die LEDs schön leuchten zu lassen, vor allem bei low-current und ultrahellen LEDs
* Wenn doch 20 mA pro LED gebraucht werden, kann man die folgende Trickschaltung anwenden.

[[bild:8x20mA_LED_mit_74xx595.png]]

Der Trick besteht darin, dass 4 LEDs ihren Strom über das Schieberegister von VCC beziehen (HIGH aktiv) während die anderen vier ihren Strom über GND leiten (LOW aktiv). Damit bleiben ganz offiziell für jede LED 70/4 = 17,5mA. Um die Handhabung in der Software zu vereinfachen muss nur vor der Ausgabe der Daten das jeweilige Byte mit 0x0F XOR verknüpft werden, bevor es in das Schieberegister getaktet wird. Dadurch werden die LOW-aktiven LEDs richtig angesteuert und die Datenhandhabung in der Software muss nur mit HIGH-aktiven rechnen.

Achtung! Die Widerstände sind auf blaue LEDs mit 3,3V Flusspannung ausgelegt. Bei roten, gelben und grünen [[LED]]s ist die Flusspannung geringer und dementsprechend muss der Vorwiderstand grösser sein.

Ausserdem wird der G Eingang verwendet, um die Helligkeit aller LEDs per [[PWM]] zu steuern. Beachtet werden muss, dass die PWM im invertierten Modus generiert werden muss, da der Eingang G LOW aktiv ist.

== Bekannte Probleme ==

AVR Studio 4.12 (Build 498) hat Probleme bei der korrekten Simulation des SPI-Moduls.

* Der Double-Speed Modus funktioniert nicht.

* Das Bit SPIF im Register SPSR, welches laut Dokumentation nur lesbar ist, ist im Simulator auch schreibbar! Das kann zu Verwirrung und Fehlern in der Simulation führen.

Hardwareprobleme

* Wenn das SPI-Modul aktiviert wird, wird '''NICHT''' automatisch SPIF gesetzt, es bleibt auf Null. Damit würde die erste Abfrage in ''Schiebe_alles'' in einer Endlosschleife hängen bleiben. Deshalb muss nach der Initialisierung des SPI-Moduls ein Dummy Byte gesendet werden, damit am Ende der Übertragung SPIF gesetzt wird

* Da das SPI-Modul in Senderichtung nur einfach gepuffert ist, ist es nicht möglich absolut lückenlos Daten zu senden, auch wenn man mit '''nop''' eine feste minimale Zeit zwischen zwei Bytes warten würde. Zwischen zwei Bytes muss immer eine Pause von mind. 2 Systemtakten eingehalten werden.

{{Navigation_zurückhochvor|
zurücktext=PWM|
zurücklink=AVR-Tutorial: PWM|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=SRAM|
vorlink=AVR-Tutorial: SRAM}}

[[Category:AVR]][[Category:AVR-Tutorial]]

Datei:74xx595-3.png

2008-01-08T18:35:54Z

FalkB:

Datei:74xx595-2.png

2008-01-08T18:35:00Z

FalkB:

Datei:74xx595-1.png

2008-01-08T18:31:38Z

FalkB:

AVR-Tutorial: ADC

2008-01-08T16:44:38Z

FalkB: Beispiele überarbeitet

== Was macht der ADC? ==

Wenn es darum geht Spannungen zu messen, wird der [[ADC | '''A'''nalog '''D'''igital '''C'''onverter]] benutzt. Er konvertiert eine elektrische Spannung in eine Digitalzahl. Diese kann dann in gewohnter Weise von einem [[Mikrocontroller]] weiterverarbeitet werden.

== Elektronische Grundlagen ==

Natürlich kann der ADC nicht beliebig hohe Spannungen verarbeiten. Die Grenze, bis zu der der ADC arbeitet ohne Schaden zu nehmen, liegt bei der analogen Versorgungsspannung (AVcc). Die ADC-Eingangsspannung darf diese maximal um 0.5 Volt überschreiten. Wird der Mikrocontroller also mit 5 Volt betrieben, so liegt die maximale Eingangsspannung bei ca. 5.5 Volt.

Der Eingangswiderstand des ADC liegt in der Größenordnung von einigen Megaohm, so dass der ADC die Sgnalquelle praktisch nicht belastet. Desweiteren enthält der Mikrocontroller eine sog. '''Sample&Hold''' Schaltung. Dies ist wichtig, wenn sich während des Wandlungsvorgangs die Eingangsspannung verändert, da die AD-Wandlung eine bestimmte Zeit dauert. Die Sample&Hold-Stufe speichert zum Beginn der Wandlung die anliegende Spannung und hält sie während des Wandlungsvorgangs konstant.

=== Beschaltung des ADC-Eingangs ===

Um den ADC im Folgenden zu testen wird eine einfache Schaltung an den PC0-Pin des ATmega8 angeschlossen. Dies ist der ADC-Kanal 0. Bei anderen AVR-Typen liegt der entsprechende Eingang auf einem andern Pin, hier ist ein Blick ins Datenblatt angesagt.

[[Bild:Tut_ADC_01.gif]]

Der Wert des [[Potentiometer]]s ist Dank des hohen Eingangswiderstandes des ADC ziemlich unkritisch. Es kann jedes Potentiometer von 1kΩ bis 1MΩ benutzt werden.

Wenn andere Messgrößen gemessen werden sollen, so bedient man sich oft und gern des Prinzips des [[Spannungsteiler]]s. Der Sensor ist ein veränderlicher Widerstand. Zusammen mit einem zweiten, konstanten Widerstand bekannter Größe wird ein Spannungsteiler aufgebaut. Aus der Variation der durch den variablen Spannungsteiler entstehenden Spannung kann auf den Messwert zurückgerechnet werden.

Vcc ----------+ Vcc ---------+
| |
--- Sensor,
| | der seinen Widerstand
| | in Abhängigkeit der
--- Messgröße ändert
| |
+------- PC0 +-------- PC0
| |
Sensor, ---
der seinen Widerstand | |
in Abhängigkeit der | |
Messgröße ändert ---
| |
GND ---------+ GND --------+

Die Größe des zweiten Widerstandes im Spannungsteiler richtet sich nach dem Wertebereich, in dem der Sensor seinen Wert ändert. Als Daumenregel kann man sagen, dass der Widerstand so gross sein sollte wie der Widerstand des Sensors in der Mitte des Messbereichs.

Beispiel: Wenn ein Temperatursensor seinen Widerstand von 0..100 Grad von 2kΩ auf 5kΩ ändert, sollte der zweite Widerstand eine Grösse von etwa (2+5)/2 = 3,5kΩ haben.

===Referenzspannung AREF===

Der ADC benötigt für seine Arbeit eine Referenzspannung. Dabei gibt es 2 Möglichkeiten:
* interne Referenzspannung
* externe Referenzspannung

==== Interne Referenzspannung ====

Mittels Konfigurationsregister können beim ATmega8 verschiedene Referenzspannungen eingestellt werden. Dies umfasst die Versorungsspannung AVcc sowie eine vom AVR bereitgestellte Spannung von 2,56V (bzw. bei den neueren AVRs 1,1V, wie z.B. beim ATtiny13, ATmega48, 88, 168, ...). In beiden Fällen wird an den AREF-Pin des Prozessors ein Kondensator von 100nF als Minimalbeschaltung nach Masse angeschlossen, um die Spannung zu puffern/glätten.

==== Externe Referenzspannung ====

Wird eine externe Referenz verwendet, so wird diese an AREF angeschlossen. Aber aufgepasst! Wenn eine Referenz in Höhe der Versorgungsspannung benutzt werden soll, so ist es besser dies über die interne Referenz zu tun. Ausser bei anderen Spannungen als 5V bzw. 2,56V gibt es eigentlich keinen Grund an AREF eine Spannungsquelle anzuschliessen. In Standardanwendungen fährt man immer besser wenn die interne Referenzspannung mit einem Kondensator an AREF benutzt wird.

== Ein paar ADC-Grundlagen ==

Der ADC ist ein 10-Bit ADC, d.h. er liefert Messwerte im Bereich 0 bis 1023. Liegt am Eingangskanal 0V an, so liefert der ADC einen Wert von 0. Hat die Spannung am Eingangskanal die Referenzspannung erreicht (stimmt nicht ganz), so liefert der ADC einen Wert von 1023. Unterschreitet oder überschreitet die zu messende Spannung diese Grenzen, so liefert der ADC 0 bzw. 1023. Wird die Auflösung von 10 Bit nicht benötigt, so ist es möglich die Ausgabe durch ein Konfigurationsregister so einzuschränken, dass ein leichter Zugriff auf die 8 höchstwertigen Bits möglich ist.

Wie bei vielen analogen Schaltungen, unterliegt auch der ADC einem Rauschen. Das bedeutet, dass man nicht davon ausgehen sollte, dass der ADC bei konstanter Eingangsspannung auch immer denselben konstanten Wert ausgibt. Ein "Zittern" der niederwertigsten 2 Bits ist durchaus nicht ungewöhnlich. Besonders hervorgehoben werden soll an dieser Stelle nochmals die Qualität der Referenzspannung. Diese Qualität geht in erheblichem Maße in die Qualität der Wandelergebnisse ein. Die Beschaltung von AREF mit einem Kondensator ist die absolut notwendige Mindestbeschaltung, um eine einigermaßen akzeptable Referenzspannung zu erhalten. Reicht dies nicht aus, so kann die Qualität einer Messung durch Oversampling erhöht werden. Dazu werden mehrere Messungen gemacht und deren Mittelwert gebildet.

Oft interessiert auch der absolute Spannungspegel nicht. Im Beschaltungsbeispiel oben ist man normalerweise nicht direkt an der am Poti entstehenden Spannung interessiert. Viel mehr ist diese Spannung nur ein notwendiges Übel, um die Stellung des Potis zu bestimmen. In solchen Fällen kann die Poti-Beschaltung wie folgt abgewandelt werden:

[[Bild:Tut_ADC_03.gif]]

Hier wird AREF (bei interner Referenz) als vom µC gelieferte Spannung benutzt und vom Spannungsteiler bearbeitet wieder an den µC zur Messung zurückgegeben. Dies hat den Vorteil, dass der Spannungsteiler automatisch Spannungen bis zur Höhe der Referenzspannung ausgibt, ohne dass eine externe Spannung mit AREF abgeglichen werden müsste. Selbst Schwankungen in AREF wirken sich hier nicht mehr aus, da ja das Verhältnis der Spannungsteilerspannung zu AREF immer konstant bleibt (ratiometrische Messung). Und im Grunde bestimmt der ADC ja nur dieses Verhältnis. Wird diese Variante gewählt, so muss berücksichtigt werden, dass die Ausgangsspannung an AREF nicht allzusehr belastet wird. Der Spannungsteiler muss einen Gesamtwiderstamd von deutlich über 10kΩ besitzen. Werte von 100kΩ oder höher sind anzustreben. Verwendet man anstatt AREF AVCC und schaltet auch die Referenzspannung auf AVCC um, ist die Belastung durch den Poti unkritisch, weil hier die Stromversorgung direkt zur Speisung verwendet wird.

Ist hingegen die absolute Spannung von Interesse, so muss man darauf achten, dass ein ADC in [[Digital | digitalen]] Bereichen arbeitet ([[Quantisierung]]). An einem einfacheren Beispiel soll demonstriert werden was damit gemeint ist.

Angenommen der ADC würde nur 5 Stufen auflösen können und AREF sei 5V:

Volt Wert vom ADC

0 -+
| 0
1 -+
| 1
2 -+
| 2
3 -+
| 3
4 -+
| 4
5 -+

Ein ADC Wert von 0 bedeutet also keineswegs, dass die zu messende Spannung exakt den Wert 0 hat. Es bedeutet lediglich, dass die Messspannung irgendwo im Bereich von 0V bis 1V liegt. Sinngemäß bedeutet daher auch das Auftreten des Maximalwertes nicht, dass die Spannung exakt AREF beträgt, sondern lediglich, dass die Messspannung sich irgendwo im Bereich der letzten Stufe (also von 4V bis 5V) bewegt.

== Umrechnung des ADC Wertes in eine Spannung ==

Die Größe eines "Bereiches" bestimmt sich also zu

<math>
Bereichsbreite = \frac {Referenzspannung}{Maximalwert + 1}
</math>

Der Messwert vom ADC rechnet sich dann wie folgt in eine Spannung um:

<math>
Spannung = ADCwert \cdot \frac {Referenzspannung} {Maximalwert + 1}
</math>

Wird der ADC also mit 10 Bit an 5 V betrieben, so lauten die Umrechnungen:

<math>
Spannung = ADCwert \cdot \frac{5}{1024}
</math>

<math>
Bereichsbreite = \frac{5}{1024} = 0,004883V = 4,883mV
</math>

Wenn man genau hinsieht stellt man fest, dass sowohl die Referenzspannung als auch der Maximalwert Konstanten sind. D.h. der Quotient aus Referenzspannung und Maximalwert+1 ist konstant. Somit muss nicht immer eine Multiplikation und Division ausgeführt werden, sondern nur eine Multiplikation! Das spart viel Aufwand und Rechenzeit! Dabei kommt [[Festkommaarithmetik]] zum Einsatz.

== Die Steuerregister des ADC ==

=== ADMUX ===

+-------+-------+-------+-------+-------+-------+-------+-------+
| REFS1 | REFS0 | ADLAR | | MUX3 | MUX2 | MUX1 | MUX0 |
+-------+-------+-------+-------+-------+-------+-------+-------+

* Referenzspannung REFS1, REFS0

<table border="0">
<tr>
<th align="left">REFS1</th><th align="left">REFS0</th><th align="left">Referenz</th>
</tr>
<tr>
<td>0</td><td>0</td><td>externe Referenz</td>
</tr>
<tr>
<td>0</td><td>1</td><td>interne Referenz: Avcc</td>
</tr>
<tr>
<td>1</td><td>0</td><td>wird beim Mega8 nicht benutzt</td>
</tr>
<tr>
<td>1</td><td>1</td><td>interne Referenz: 2.56 Volt</td>
</tr>
</table>

* Ausrichtung ADLAR
<table border="0">
<tr>
<th align="left">ADLAR</th><th align="left"></th>
</tr>
<tr>
<td>0</td><td>Das Ergebnis wird in den Registern ADCH/ADCL rechtsbündig ausgerichtet. Die 8 niederwertigsten Bits des Ergebnisses werden in ADCL abgelegt. Die verbleibenden 2 Bits des Ergebnisses werden im Register ADCH in den Bits 0 und 1 abgelegt.</td>
</tr>
<tr>
<td>1</td><td>Das Ergebnis wird in den Registern ADCH/ADCL linksbündig ausgerichtet. Die 8 höchstwertigen Bits des Ergebnisses werden in ADCH abgelegt. Die verbleibenden 2 niederwertigen Bits werden im Register ADCL in den Bits 6 und 7 abgelegt.</td>
</tr>
</table>

* Kanalwahl MUX3, MUX2, MUX1, MUX0
<table border="0">
<tr>
<th align="left">MUX3</th><th align="left">MUX2</th><th align="left">MUX1</th><th align="left">MUX0</th><th align="left">Kanal</th>
</tr>
<tr>
<td>0</td><td>0</td><td>0</td><td>0</td><td>Kanal 0, Pin PC0</td>
</tr>
<tr>
<td>0</td><td>0</td><td>0</td><td>1</td><td>Kanal 1, Pin PC1</td>
</tr>
<tr>
<td>0</td><td>0</td><td>1</td><td>0</td><td>Kanal 2, Pin PC2</td>
</tr>
<tr>
<td>0</td><td>0</td><td>1</td><td>1</td><td>Kanal 3, Pin PC3</td>
</tr>
<tr>
<td>0</td><td>1</td><td>0</td><td>0</td><td>Kanal 4, Pin PC4</td>
</tr>
<tr>
<td>0</td><td>1</td><td>0</td><td>1</td><td>Kanal 5, Pin PC5</td>
</tr>
<tr>
<td>0</td><td>1</td><td>1</td><td>0</td><td>Kanal 6, Pin ADC7 (*)</td>
</tr>
<tr>
<td>0</td><td>1</td><td>1</td><td>1</td><td>Kanal 7, Pin ADC8 (*)</td>
</tr>
<tr>
<td>1</td><td>1</td><td>1</td><td>0</td><td>1.23V, Vbg</td>
</tr>
<tr>
<td>1</td><td>1</td><td>1</td><td>1</td><td>0V, GND</td>
</tr>
</table>

(*) nur in der Gehäusebauform TQFP und MLF verfügbar

===ADCSRA===

+-------+-------+-------+-------+-------+-------+-------+-------+
| ADEN | ADSC | ADFR | ADIF | ADIE | ADPS2 | ADPS1 | ADPS0 |
+-------+-------+-------+-------+-------+-------+-------+-------+

* ADEN (ADC Enable): Mittels ADEN wird der ADC ein und ausgeschaltet. Eine 1 an dieser Bitposition schaltet den ADC ein.
* ADSC (ADC Start Conversion): Wird eine 1 an diese Bitposition geschrieben, so beginnt der ADC mit der Wandlung. Das Bit bleibt auf 1, solange die Wandlung im Gange ist. Wenn die Wandlung beendet ist, wird dieses Bit von der ADC Hardware wieder auf 0 gesetzt.
* ADFR (ADC Free Running): Wird eine 1 an ADFR geschrieben, so wird der ADC im Free Running Modus betrieben. Dabei startet der '''ADC''' nach dem Abschluss einer Messung automatisch die nächste Messung. Die erste Messung wird ganz normal über das Setzen des '''ADSC''' Bits gestartet.
* ADIF (ADC Interrupt Flag): Wenn eine Messung abgeschlossen ist, wird das ADIF Bit gesetzt. Ist zusätzlich noch das ADIE Bit gesetzt, so wird ein Interrupt ausgelöst und der entsprechende Interrupt Handler angesprungen.
* ADIE (ADC Interrupt Enable): Wird eine 1 an ADIE geschrieben, so löst der '''ADC''' nach Beendigung einer Messung einen Interrupt aus.
* ADPS2, ADPS1, ADPS0 (ADC Prescaler): Mit dem Prescaler kann die ADC-Frequenz gewählt werden. Laut Datenblatt sollte diese für die optimale Auflösung zwischen 50KHz und 200kHz liegen. Ist die Wandlerfrequenz langsamer eingestellt, kann es passieren dass die eingebaute Sample & Hold Schaltung die Eingangsspannung nicht lange genug konstant halten kann. Ist die Frequenz aber zu schnell eingestellt, dann kann es passieren dass sich die Sample & Hold Schaltung nicht schnell genug an die Eingangsspannung anpassen kann.

<table border="0">
<tr>
<th align="left">ADPS2</th><th align="left">ADPS1</th><th align="left">ADPS0</th><th align="left">Vorteiler</th>
</tr>
<tr>
<td>0</td><td>0</td><td>0</td><td>2</td>
</tr>
<tr>
<td>0</td><td>0</td><td>1</td><td>2</td>
</tr>
<tr>
<td>0</td><td>1</td><td>0</td><td>4</td>
</tr>
<tr>
<td>0</td><td>1</td><td>1</td><td>8</td>
</tr>
<tr>
<td>1</td><td>0</td><td>0</td><td>16</td>
</tr>
<tr>
<td>1</td><td>0</td><td>1</td><td>32</td>
</tr>
<tr>
<td>1</td><td>1</td><td>0</td><td>64</td>
</tr>
<tr>
<td>1</td><td>1</td><td>1</td><td>128</td>
</tr>
</table>

== Die Ergebnisregister ADCL und ADCH ==

Da das Ergebnis des ADC ein 10 Bit Wert ist, passt dieser Wert naturgemäß nicht in ein einzelnes Register, das je bekanntlich nur 8 Bit breit ist. Daher wird das Ergebnis in 2 Register '''ADCL''' und '''ADCH''' abgelegt. Von den 10 Ergebnisbits sind die niederwertigsten 8 im Register '''ADCL''' abgelegt und die noch fehlenden 2 Bits werden im Register '''ADCH''' an den niederwertigsten Bitpositionen gespeichert.

ADCH ADCL
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | | | | | | | | | | | | | | | |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
9 8 7 6 5 4 3 2 1 0

Diese Zuordnung kann aber auch geändert werden: Durch setzen des '''ADLAR''' Bits im '''ADMUX''' Register wird die Ausgabe geändert zu:

ADCH ADCL
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | | | | | | | | | | | | | | | |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
9 8 7 6 5 4 3 2 1 0

Dies ist besonders dann interessant, wenn das ADC Ergebnis als 8 Bit Zahl weiterverarbeitet werden soll. In diesem Fall stehen die 8 höchstwertigen Bits bereits verarbeitungsfertig im Register '''ADCH''' zur Verfügung.

Beim Auslesen der ADC-Register ist zu beachten:
Immer zuerst '''ADCL''' und erst dann '''ADCH''' auslesen. Beim Zugriff auf '''ADCL''' wird das '''ADCH''' Register gegenüber Veränderungen vom '''ADC''' gesperrt. Erst beim nächsten Auslesen des '''ADCH'''-Registers wird diese Sperre wieder aufgehoben. Dadurch ist sichergestellt, daß die Inhalte von '''ADCL''' und '''ADCH''' immer aus demselben Wandlungsergebnis stammen, selbst wenn der '''ADC''' im Hintergrund selbsttätig weiterwandelt. Das '''ADCH''' Register '''muss''' ausgelesen werden!

== Beispiele ==

=== Ausgabe als ADC-Wert ===

Das folgende Programm liest in einer Schleife ständig den ADC aus und verschickt des Ergebnis im Klartext (ASCII) über die [[AVR-Tutorial: UART|UART]]. Zur Verringerung des unvermeidlichen Rauschens werden 256 Messwerte herangezogen und deren Mittelwert als endgültiges Messergebnis gewertet. Dazu werden die einzelnen Messungen in den Registern temp2, temp3, temp4 als 24 Bit Zahl aufaddiert. Die Division durch 256 erfolgt dann ganz einfach dadurch, dass das Register temp2 verworfen wird und die Register temp3 und temp4 als 16 Bit Zahl aufgefasst werden. Eine Besonderheit ist noch, dass je nach dem Wert in temp2 die 16 Bit Zahl in temp3 und temp4 noch aufgerundet wird: Enthält temp2 einen Wert größer als 128, dann wird zur 16 Bit Zahl in temp3/temp4 noch 1 dazu addiert.

In diesem Programm findet man oft die Konstruktion

<avrasm>
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry
</avrasm>

Dabei handelt es sich um einen kleinen Trick. Um eine Konstante zu einem Register direkt addieren zu können bäuchte man dazu ein Befehl ala addi (Add Immediate, Addiere Konstante), den der AVR aber nicht hat. Ebenso gibt es kein adci (Add with carry Immediate, Addiere Konstante mit Carry Flag). Man müsste also erst eine Konstante in ein Register laden und addieren. Das kostet aber Programmspeicher, Rechenzeit und man muss ein Register zusätzlich frei haben.

<avrasm>
; 16 Bit Addition mit Konstante, ohne Cleverness
ldi temp5, low(1)
add temp3, temp5 ; addieren von 1
ldi temp5, high(1)
add temp3, temp5 ; addieren des Carry
</avrasm>

Hier greift man einfach zu dem Trick, dass eine Addition gleich der Subtraktion der negativen Werts ist. Also "addiere +1" ist gleich "subtrahiere -1". Dafür hat der AVR zwei Befehle, subi (Substract Immediate, Subtrahiere Konstante) und sbci (Substract Immediate with carry, Subtrahiere Konstante mit Carry Flag).

<avrasm>
.include "m8def.inc"

.def temp1 = r16 ; allgemeines temp Register, zur krufristigen Verwendung
.def temp2 = r17 ; Register für 24 Bit Addition, Lowest Byte
.def temp3 = r18 ; Register für 24 Bit Addition, Middle Byte
.def temp4 = r19 ; Register für 24 Bit Addition, Highest Byte
.def adlow = r20 ; Ergebnis vom ADC / Mittelwert der 256 Messungen
.def adhigh = r21 ; Ergebnis vom ADC / Mittelwert der 256 Messungen
.def messungen = r22 ; Schleifenzähler für die Messungen
.def ztausend = r23 ; Zehntausenderstelle des ADC Wertes
.def tausend = r24 ; Tausenderstelle des ADC Wertes
.def hundert = r25 ; Hunderterstelle des ADC Wertes
.def zehner = r26 ; Zehnerstelle des ADC Wertes
.def zeichen = r27 ; Zeichen zur Ausgabe auf den UART

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

; hier geht das Programm los

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;UART Initalisierung

ldi temp1, LOW(UBRR_VAL) ; Baudrate einstellen
out UBRRL, temp1
ldi temp1, HIGH(UBRR_VAL)
out UBRRH, temp1

sbi UCSRB, TXEN ; TX einschalten

; ADC initialisieren: Single Conversion, Vorteiler 128

ldi temp1, (1<<REFS0) ; Kanal 0, interne Referenzspannung 5V
out ADMUX, temp1
ldi temp1, (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)
out ADCSRA, temp1

Main:
clr temp1
clr temp2
clr temp3
clr temp4

ldi messungen, 0 ; 256 Schleifendurchläufe

; neuen ADC-Wert lesen (Schleife - 256 mal)

sample_adc:
sbi ADCSRA, ADSC ; den ADC starten

wait_adc:
sbic ADCSRA, ADSC ; wenn der ADC fertig ist, wird dieses Bit gelöscht
rjmp wait_adc

; ADC einlesen:

in adlow, ADCL ; immer zuerst LOW Byte lesen
in adhigh, ADCH ; danach das mittlerweile gesperrte High Byte

; alle 256 ADC-Werte addieren
; dazu wird mit den Registern temp4, temp3 und temp2 ein
; 24-Bit breites Akkumulationsregister gebildet, in dem
; die 10 Bit Werte aus adhigh, adlow aufsummiert werden

add temp2, adlow ; addieren
adc temp3, adhigh ; addieren über Carry
adc temp4, temp1 ; addieren über Carry, temp1 enthält 0
dec messungen ; Schleifenzähler MINUS 1
brne sample_adc ; wenn noch keine 256 ADC Werte -> nächsten Wert einlesen

; Aus den 256 Werten den Mittelwert berechnen
; Mathematisch eine Division durch 256
; Da aber 2^8 = 256 ist ist da einfach durch das weglassen des niederwertigsten Bytes
; erreicht werden
;
; allerdings wird der Wert noch gerundet

cpi temp2,128 ; "Kommastelle" kleiner als 128 ?
brlo no_round ; ist kleiner ==> Sprung

; Aufrunden
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry

no_round:

; Ergebnis nach adlow und adhigh kopieren
; damit die temp Register frei werden

mov adlow, temp3
mov adhigh, temp4

;in ASCII umwandeln
; Division durch mehrfache Subtraktion

ldi ztausend, '0'-1 ; Ziffernzähler direkt als ASCII Code
Z_ztausend:
inc ztausend
subi adlow, low(10000) ; -10,000
sbci adhigh, high(10000) ; 16 Bit
brcc Z_ztausend

subi adlow, low(-10000) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-10000); +10,000

ldi tausend, '0'-1 ; Ziffernzähler direkt als ASCII Code
Z_tausend:
inc tausend
subi adlow, low(1000) ; -1,000
sbci adhigh, high(1000) ; 16 Bit
brcc Z_tausend

subi adlow, low(-1000) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-1000) ; +1,000

ldi hundert, '0'-1 ; Ziffernzähler direkt als ASCII Code
Z_hundert:
inc hundert
subi adlow, low(100) ; -100
sbci adhigh, high(100) ; 16 Bit
brcc Z_hundert

subi adlow, low(-100) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-100) ; +100

ldi zehner, '0'-1 ; Ziffernzähler direkt als ASCII Code
Z_zehner:
inc zehner
subi adlow, low(10) ; -10
sbci adhigh, high(10) ; 16 Bit
brcc Z_zehner

subi adlow, low(-10) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-10) ; +10

subi adlow, -'0' ; adlow enthält die Einer, Umwandlung in ASCII

;an UART Senden

mov zeichen, ztausend ; Zehntausender Stelle
rcall transmit
mov zeichen, tausend ; Tausender Stelle ausgeben
rcall transmit
mov zeichen, hundert ; Hunderter Stelle ausgeben
rcall transmit
mov zeichen, zehner ; Zehner Stelle ausgeben
rcall transmit
mov zeichen, adlow ; Einer Stelle ausgeben
rcall transmit
ldi zeichen, 13 ; CR, Carrige Return (Wagenrücklauf)
rcall transmit
ldi zeichen, 10 ; LF, Line Feed (Neue Zeile)
rcall transmit

rjmp Main

transmit:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp transmit
out UDR, zeichen ; und Zeichen ausgeben
ret
</avrasm>

=== Ausgabe als Spannungswert ===

Das zweite Beispiel ist schon um einiges größer. Hier wird der gemittelte ADC-Wert in eine Spannung umgerechnet. Dazu wird [[Festkommaarithmetik]] verwendet. Die Daten sind in diesem Fall

* Referenzspannung : 5V
* alte Auflösung : 5V / 1024 = 4,8828125mV
* neue Auflösung : 1mV

-> Faktor = 4,8828125mV / 1mV = 4,8828125

Der Faktor wird dreimal mit 10 multipliziert und das Ergebnis auf 4883 gerundet. Die neue Auflösung wird dreimal durch 10 dividiert und beträgt 1μV. Der relative Fehler beträgt

:<math> F_r = \frac {4883}{4882,8125}-1 = 0,00384% = \frac {1}{26042}</math>

Diese Fehler ist absolut vernachlässigbar. Nach der Multiplikation des ADC-Wertes mit 4883 liegt die gemessene Spannung in der Einheit μV vor. Vorsicht! Das ist '''nicht''' die reale [[Auflösung und Genauigkeit]], nur rein mathematisch bedingt. Für maximale Genauigkeit sollte man die Versorgungsspannung AVCC, welche hier gleichzeitig als Referenzspannung dient, exakt messen, die Rechnung nachvollziehen und den Wert im Quelltext eintragen. Damit führt man eine einfach Einpunktkalibrierung durch.

Da das Programm schon um einiges größer und komplexer ist, wurde es im Vergleich zur Vorgängerversion geändert. Die Multiplikation sowie die Umwandung der Zahl in einen ASCII-String sind als Unterprogramme geschrieben, dadurch erhält man wesentlich mehr Überblick im Hauptprogramm und die Wiederverwendung in anderen Programmen vereinfacht sich. Ausserdem wird der String im RAM gespeichert und nicht mehr in CPU-Registern. Die Berechung der einzelnen Ziffern erfolgt über ein Schleife, das ist kompakter und übersichtlicher.

<avrasm>
.include "m8def.inc"

.def z0 = r1 ; Zahl für Integer -> ASCII Umwandlung
.def z1 = r2
.def z2 = r3
.def z3 = r4
.def temp1 = r16 ; allgemeines Register, zur kurzfristigen Verwendung
.def temp2 = r17 ; Register für 24 Bit Addition, niederwertigstes Byte (LSB)
.def temp3 = r18 ; Register für 24 Bit Addition, mittlerers Byte
.def temp4 = r19 ; Register für 24 Bit Addition, höchstwertigstes Byte (MSB)
.def adlow = r20 ; Ergebnis vom ADC-Mittelwert der 256 Messungen
.def adhigh = r21 ; Ergebnis vom ADC-Mittelwert der 256 Messungen
.def messungen = r22 ; Schleifenzähler für die Messungen
.def zeichen = r23 ; Zeichen zur Ausgabe auf den UART
.def temp5 = r24
.def temp6 = r25

; Faktor für Umrechung des ADC-Wertes in Spannung
; = (Referenzspannung / 1024 ) * 100000
; = 5V / 1024 * 1.000.000
.equ Faktor = 4883

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

; RAM
.dseg
.org 0x60
Puffer: .byte 10

; hier geht das Programm los
.cseg
.org 0

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;UART Initalisierung

ldi temp1, LOW(UBRR_VAL) ; Baudrate einstellen
out UBRRL, temp1
ldi temp1, HIGH(UBRR_VAL)
out UBRRH, temp1

sbi UCSRB, TXEN ; TX einschalten

; ADC initialisieren: Single Conversion, Vorteiler 128
; Kanal 0, interne Referenzspannung AVCC

ldi temp1, (1<<REFS0)
out ADMUX, temp1
ldi temp1, (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)
out ADCSRA, temp1

Hauptschleife:
clr temp1
clr temp2
clr temp3
clr temp4

ldi messungen, 0 ; 256 Schleifendurchläufe

; neuen ADC-Wert lesen (Schleife - 256 mal)

adc_messung:
sbi ADCSRA, ADSC ; den ADC starten

adc_warten:
sbic ADCSRA, ADSC ; wenn der ADC fertig ist, wird dieses Bit gelöscht
rjmp adc_warten

; ADC einlesen:

in adlow, ADCL ; immer zuerst LOW Byte lesen
in adhigh, ADCH ; danach das mittlerweile gesperrte High Byte

; alle 256 ADC-Werte addieren
; dazu wird mit den Registern temp4, temp3 und temp2 ein
; 24-Bit breites Akkumulationsregister gebildet, in dem
; die 10 Bit Werte aus adhigh, adlow aufsummiert werden

add temp2, adlow ; addieren
adc temp3, adhigh ; addieren über Carry
adc temp4, temp1 ; addieren über Carry, temp1 enthält 0
dec messungen ; Schleifenzähler MINUS 1
brne adc_messung ; wenn noch keine 256 ADC Werte -> nächsten Wert einlesen

; Aus den 256 Werten den Mittelwert berechnen
; Bei 256 Werten ist das ganz einfach: Das niederwertigste Byte
; (im Register temp2) fällt einfach weg
;
; allerdings wird der Wert noch gerundet

cpi temp2,128 ; "Kommastelle" kleiner als 128 ?
brlo nicht_runden ; ist kleiner ==> Sprung

; Aufrunden
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry

nicht_runden:

; Ergebnis nach adlow und adhigh kopieren
; damit die temp Register frei werden

mov adlow, temp3
mov adhigh, temp4

; in Spannung umrechnen

ldi temp5,low(Faktor)
ldi temp6,high(Faktor)
rcall mul_16x16

; in ASCII umwandeln

ldi XL, low(Puffer)
ldi XH, high(Puffer)
rcall Int_to_ASCII

;an UART Senden

ldi ZL, low(Puffer+3)
ldi ZH, high(Puffer+3)
ldi temp1, 1
rcall sende_zeichen ; eine Vorkommastelle ausgeben

ldi zeichen, ',' ; Komma ausgeben
rcall sende_einzelzeichen

ldi temp1, 3 ; Drei Nachkommastellen ausgeben
rcall sende_zeichen

ldi zeichen, 'V' ; Volt Zeichen ausgeben
rcall sende_einzelzeichen

ldi zeichen, 10 ; New Line Steuerzeichen
rcall sende_einzelzeichen

ldi zeichen, 13 ; Carrige Return Steuerzeichen
rcall sende_einzelzeichen

rjmp Hauptschleife

; Ende des Hauptprogramms

; Unterprogramme

; ein Zeichen per UART senden

sende_einzelzeichen:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp sende_einzelzeichen
out UDR, zeichen ; und Zeichen ausgeben
ret

; mehrere Zeichen ausgeben, welche durch Z adressiert werden
; Anzahl in temp1

sende_zeichen:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp sende_zeichen
ld zeichen, Z+ ; Zeichen laden
out UDR, zeichen ; und Zeichen ausgeben
dec temp1
brne sende_zeichen
ret

; 32 Bit Zahl in ASCII umwandeln
; Zahl liegt in temp1..4
; Ergebnis ist ein 10stelliger ASCII String, welcher im SRAM abgelegt wird
; Adressierung über X Pointer
; mehrfache Subtraktion wird als Ersatz für eine Division durchgeführt.

Int_to_ASCII:

push ZL ; Register sichern
push ZH
push temp5
push temp6

ldi ZL,low(Tabelle*2) ; Zeiger auf Tabelle
ldi ZH,high(Tabelle*2)
ldi temp5, 10 ; Schleifenzähler

Int_to_ASCII_schleife:
ldi temp6, -1+'0' ; Ziffernzähler zählt direkt im ASCII Code
lpm z0,Z+ ; Nächste Zahl laden
lpm z1,Z+
lpm z2,Z+
lpm z3,Z+

Int_to_ASCII_ziffer:
inc temp6 ; Ziffer erhöhen
sub temp1, z0 ; Zahl subrahieren
sbc temp2, z1 ; 32 Bit
sbc temp3, z2
sbc temp4, z3
brge Int_to_ASCII_ziffer ; noch kein Unterlauf, nochmal

add temp1, z0 ; Unterlauf, eimal wieder addieren
adc temp2, z1 ; 32 Bit
adc temp3, z2
adc temp4, z3
st X+,temp6 ; Ziffer speichern
dec temp5
brne Int_to_ASCII_schleife ; noch eine Ziffer?

pop temp6
pop temp5
pop ZH
pop ZL ; Register wieder herstellen
ret

; Tabelle mit Zahlen für die Berechung der Ziffern
; 1 Milliarde bis 1
Tabelle:
.dd 1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1

; 16 Bit Wert in Spannung umrechnen
;
; = 16Bitx16Bit=32 Bit Multiplikation
; = vier 8x8 Bit Multiplikationen
;
; adlow/adhigh * temp5/temp6

mul_16x16:
push zeichen
clr temp1 ; 32 Bit Akku löschen
clr temp2
clr temp3
clr temp4
clr zeichen ; Null, für Carry-Addition

mul adlow, temp5 ; erste Multiplikation
add temp1, r0 ; und akkumulieren
adc temp2, r1

mul adhigh, temp5 ; zweite Multiplikation
add temp2, r0 ; und gewichtet akkumlieren
adc temp3, r1

mul adlow, temp6 ; dritte Multiplikation
add temp2, r0 ; und gewichtet akkumlieren
adc temp3, r1
adc temp4, zeichen ; carry addieren

mul adhigh, temp6 ; vierte Multiplikation
add temp3, r0 ; und gewichtet akkumlieren
adc temp4, r1

pop zeichen
ret
</avrasm>

Für alle, die es besonders eilig haben gibt es hier eine geschwindigkeitsoptimierte Version der Integer in ASCII Umwandlung. Zunächst wird keine Schleife verwendet sondern alle Stufen der Schleife direkt hingeschrieben. Das braucht zwar mehr Programmspeicher, ist aber schneller. Ausserdem wird abwechselnd subtrahiert uund addiert, dadurch entfällt das immer wieder notwendige addieren nach dem Unterlauf. Zu guter Letzt werden die Berechnungen nur mit der minimal notwenigen Wortbreite durchgeführt. Am Anfang mit 32 Bit, dann nur noch mit 16 bzw. 8 Bit.

<avrasm>
; 32 Bit Zahl in ASCII umwandeln
; geschwindigkeitsoptimierte Version
; Zahl liegt in temp1..4
; Ergebnis ist ein 10stelliger ASCII String, welcher im SRAM abgelegt wird
; Adressierung über X Pointer

Int_to_ASCII:
ldi temp5, -1 + '0'
_a1ser:
inc temp5
subi temp1,BYTE1(1000000000) ; - 1.000.000.000
sbci temp2,BYTE2(1000000000)
sbci temp3,BYTE3(1000000000)
sbci temp4,BYTE4(1000000000)
brcc _a1ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a2ser:
dec temp5
subi temp1,BYTE1(-100000000) ; + 100.000.000
sbci temp2,BYTE2(-100000000)
sbci temp3,BYTE3(-100000000)
sbci temp4,BYTE4(-100000000)
brcs _a2ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a3ser:
inc temp5
subi temp1,low(10000000) ; - 10.000.000
sbci temp2,high(10000000)
sbci temp3,BYTE3(10000000)
brcc _a3ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a4ser:
dec temp5
subi temp1,low(-1000000) ; + 1.000.000
sbci temp2,high(-1000000)
sbci temp3,BYTE3(-1000000)
brcs _a4ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a5ser:
inc temp5
subi temp1,low(100000) ; -100.000
sbci temp2,high(100000)
sbci temp3,BYTE3(100000)
brcc _a5ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a6ser:
dec temp5
subi temp1,low(-10000) ; +10,000
sbci temp2,high(-10000)
sbci temp3,BYTE3(-10000)
brcs _a6ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a7ser:
inc temp5
subi temp1,low(1000) ; -1000
sbci temp2,high(1000)
brcc _a7ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a8ser:
dec temp5
subi temp1,low(-100) ; +100
sbci temp2,high(-100)
brcs _a8ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a9ser:
inc temp5
subi temp1, 10 ; -10
brcc _a9ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a10ser:
dec temp5
subi temp1, -1 ; +1
brcs _a10ser

st X+,temp5 ; im Puffer speichern
ret
</avrasm>

{{Navigation_zurückhochvor|
zurücktext=Uhr|
zurücklink=AVR-Tutorial: Uhr|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Tasten|
vorlink=AVR-Tutorial: Tasten}}

[[Category:AVR]][[Category:AVR-Tutorial]]

Logische Verknüpfungen

2008-01-07T20:53:48Z

FalkB: Änderung 25393 von 82.83.71.54 (Diskussion) wurde rückgängig gemacht.

====UND====
Verknüpfung (Konjunktion)

:<math>x = a \wedge b</math>

<table border="0">
<tr>
<td>[[Bild:AND.png]]</td>
<td>
<table border="0">
<tr>
<td> ''' a ''' </td>
<td> ''' b ''' </td>
<td> | </td>
<td> ''' x ''' </td>
</tr>
<td>----</td>
<td>----</td>
<td>+</td>
<td>----</td>
<tr>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td> | </td>
<td>0</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td> | </td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td> | </td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td> | </td>
<td>1</td>
</tr>
</table>
</td>
</tr>
</table>
-.-*
-----

====ODER====
Verknüpfung (Disjunktion)

:<math>x = a \vee b</math>

<table border="0">
<tr>
<td>[[Bild:ODER.png]]</td>
<td>
<table border="1">
<tr>
<td> '''a''' </td>
<td> '''b''' </td>
<td> '''x''' </td>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>1</td>
</tr>
</table>
</td></tr>
</table>

-----

====NICHT====
Verknüpfung (Negation)

:<math>x = \overline{a}</math>

<table border="0">
<tr>
<td>[[Bild:NOT.png]]</td>
<td>
<table border="1">
<tr>
<td> '''a''' </td>
<td> '''b''' </td>
<td> '''x''' </td>
</tr>
<tr>
<td>0</td>
<td>-</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>-</td>
<td>0</td>
</tr>
</table>
</td></tr>
</table>

-----

====NAND====
Verknüpfung

:<math>x = \overline{a \wedge b}</math>

<table border="0">
<tr>
<td>[[Bild:NAND.png]]</td>
<td>
<table border="1">
<tr>
<td> '''a''' </td>
<td> '''b''' </td>
<td> '''x''' </td>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>0</td>
</tr>
</table>
</td></tr>
</table>

-----

====NOR====
Verknüpfung (Konjunktion)

:<math>x = \overline{a \vee b}</math>

<table border="0">
<tr>
<td>[[Bild:NOR.png]]</td>
<td>
<table border="1">
<tr>
<td> '''a''' </td>
<td> '''b''' </td>
<td> '''x''' </td>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>0</td>
</tr>
</table>
</td></tr>
</table>

-----

====XOR====
Exklusiv-ODER-Verknüpfung (Antivalenz)

:<math>x = (a \wedge \overline{b}) \vee (\overline{a} \wedge b)</math>

<table border="0">
<tr>
<td>[[Bild:XOR.png]]</td>
<td>
<table border="1">
<tr>
<td> '''a''' </td>
<td> '''b''' </td>
<td> '''x''' </td>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>0</td>
</tr>
</table>
</td></tr>
</table>

-----

====XNOR====
Exklusiv-NOR-Verknüpfung (Äquivalenz)

:<math>x = (a \wedge b) \vee (\overline{a} \wedge \overline{b})</math>

<table border="0">
<tr>
<td>[[Bild:XNOR.png]]</td>
<td>
<table border="1">
<tr>
<td> '''a''' </td>
<td> '''b''' </td>
<td> '''x''' </td>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>1</td>
</tr>
</table>
</td></tr>
</table>

-----

'''Sperrgatter''' (Inhibition)

:<math>x = \overline{a} \wedge b</math>

<table border="0">
<tr>
<td>[[Bild:Inhibition.png]]</td>
<td>
<table border="1">
<tr>
<td> '''a''' </td>
<td> '''b''' </td>
<td> '''x''' </td>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>0</td>
</tr>
</table>
</td></tr>
</table>

-----

'''Subjunktion''' (Implikation)

:<math>x = \overline{a} \vee b</math>

<table border="0">
<tr>
<td>[[Bild:Implikation.png]]</td>
<td>
<table border="1">
<tr>
<td> '''a''' </td>
<td> '''b''' </td>
<td> '''x''' </td>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>1</td>
</tr>
</table>
</td></tr>
</table>

AVR-Tutorial: 7-Segment-Anzeige

2008-01-06T13:25:54Z

FalkB: Sprachliche Überarbeitung

Die Ausgabe von Zahlenwerten auf ein Text-LCD ist sicherlich das Nonplusultra, aber manchmal liegen die Dinge sehr viel einfacher. Um beispielsweise eine Temperatur anzuzeigen ist ein LCD etwas Overkill. In solchen Fällen kann die Ausgabe auf ein paar 7-Segmentanzeigen gemacht werden. Ausserdem haben 7-Segmentanzeigen einen ganz besonderen Charme :-)

==Typen von 7-Segment Anzeigen==

Eine einzelne 7-Segmentanzeige besteht aus sieben (mit Dezimalpunkt acht) einzelnen [[LED]]s in einem gemeinsamen Gehäuse. Aus praktischen Gründen wird einer der beiden Anschlüsse jeder LED mit den gleichen Anschlüssen der anderen LED verbunden und gemeinsam aus dem Gehäuse herausgeführt. Das spart Pins am Gehäuse und später bei der Ansteuerung. Dementsprechend spricht man von Anzeigen mit ''gemeinsamer Anode'' (engl. common anode) bzw. ''gemeinsamer Kathode'' (engl. common cathode) .

[[Bild:Tut_7_Seg_00.gif | framed | left | Interne Verschaltung der 7-Segmentanzeigen]]
 

==Eine einzelne 7-Segment Anzeige==

===Schaltung===

Eine einzelne 7-Segmentanzeige wird nach dem folgenden Schema am '''Port D''' des Mega8 angeschlossen. Port D wurde deshalb gewählt, da er am Mega8 als einziger Port aus den vollen 8 Bit besteht. Die 7-Segmentanzeige hat eine gemeinsame Anode.

[[Bild:Tut_7_Seg_01.gif | framed | left | Ansteuerung einer einzelnen 7-Segmentanzeige]]
 

Welcher Pin an der Anzeige welchem Segment (a-g) bzw. dem Dezimalpunkt entspricht wird am besten dem Datenblatt zur Anzeige entnommen. Im Folgenden wird von dieser Segmentbelegung ausgegangen:

[[Bild:Tut_7_Seg_02.gif | framed | left | Pinbelegung der 7-Segmentanzeige]]
 

Wird eine andere Belegung genutzt dann ist das prinzipiell möglich, jedoch müsste das in der Programmierung berücksichtigt werden.

Da eine 7-Segmentanzeige konzeptionell sieben einzelnen LEDs entspricht, ergibt sich im Prinzip keine Änderung in der Ansteuerung einer derartigen Anzeige im Vergleich zur LED Ansteuerung wie sie im [[AVR-Tutorial: IO-Grundlagen]] gezeigt wird. Genau wie bei den einzelnen LEDs wird eine davon eingeschaltet, indem der zugehörige Port Pin auf 0 gesetzt wird. Aber anders als bei einzelnen LED möchte man mit einer derartigen Anzeige eine Ziffernanzeige erhalten. Dazu ist es lediglich notwendig, für eine bestimmte Ziffer die richtigen LEDs einzuschalten.

===Codetabelle===

Die Umkodierung von einzelnen Ziffern in ein bestimmtes Ausgabemuster bezeichnet man als Codetabelle. Die auszugebende Ziffer wird als Offset zum Anfang dieser Tabelle aufgefasst und aus der Tabelle erhält man ein Byte (Code), welches direkt auf den Port ausgegeben werden kann und das entsprechende Bitmuster enthält, sodass die für diese Ziffer notwendigen LED ein- bzw. ausgeschaltet sind.

Beispiel: Um die Ziffer '''3''' anzuzeigen, müssen auf der Anzeige die Segmente '''a''', '''b''', '''c''', '''d''' und '''g''' aufleuchten. Alle anderen Segmente sollen dunkel sein.

[[Bild:Tut_7_Seg_02a.gif | framed | left | Darstellung der Ziffer "3"]]
 

Aus dem Anschlußschema ergibt sich, dass die dazu notwendige Ausgabe am Port binär '''10110000''' lauten muss. Untersucht man dies für alle Ziffern, so ergibt sich folgende Tabelle:
<avrasm>
.db 0b11000000 ; 0: a, b, c, d, e, f
.db 0b11111001 ; 1: b, c
.db 0b10100100 ; 2: a, b, d, e, g
.db 0b10110000 ; 3: a, b, c, d, g
.db 0b10011001 ; 4: b, c, f, g
.db 0b10010010 ; 5: a, c, d, f, g
.db 0b10000010 ; 6: a, c, d, e, f, g
.db 0b11111000 ; 7: a, b, c
.db 0b10000000 ; 8: a, b, c, d, e, f, g
.db 0b10010000 ; 9: a, b, c, d, f, g
</avrasm>

===Programm===

Das Testprogramm stellt nacheinander die Ziffern 0 bis 9 auf der 7-Segmentanzeige dar. Die jeweils auszugebende Zahl steht im Register '''count''' und wird innerhalb der Schleife um jeweils 1 erhöht. Hat das Register den Wert 10 erreicht, so wird es wieder auf 0 zurückgesetzt. Nach der Erhöhung folgt eine Warteschleife, welche dafür sorgt, dass bis zur nächsten Ausgabe eine gewisse Zeit vergeht. Normalerweise macht man keine derartigen langen Warteschleifen, aber hier geht es ja nicht ums Warten sondern um die Ansteuerung einer 7-Segmentanzeige. Einen Timer dafür zu benutzen wäre zunächst zuviel Aufwand.

Die eigentliche Ausgabe und damit der in diesem Artikel interessante Teil findet jedoch direkt nach dem Label loop statt. Die bereits bekannte Codetabelle wird mittels '''.db''' Direktive ('''d'''efine '''b'''yte) in den [[Speicher#Flash-ROM | Flash-Speicher]] gelegt. Der Zugriff darauf erfolgt über den Z-Pointer und dem Befehl '''lpm'''. Zusätzlich wird vor dem Zugriff noch der Wert des Registers '''count''' und damit der aktuelle Zählerwert zum Z-Pointer addiert.

Beachtet werden muss nur, dass der Zählerwert verdoppelt werden muss. Dies hat folgenden Grund: Wird die Tabelle so wie hier gezeigt mittels einzelnen '''.db''' Anweisungen aufgebaut, so fügt der Assembler sog. '''Padding Bytes''' zwischen die einzelnen Bytes ein, damit jede '''.db''' Anweisung auf einer geraden Speicheradresse liegt. Dies ist eine direkte Folge der Tatsache, dass der Flash-Speicher '''wortweise''' (16 Bit) und nicht '''byteweise''' (8 Bit) organisiert ist. Da aber von einem .db in der Tabelle zum nächsten .db eine Differenz von 2 Bytes vorliegt, muss dies in der Berechnung berücksichtigt werden. Im zweiten Beispiel auf dieser Seite wird dies anders gemacht. Dort wird gezeigt wie man durch eine andere Schreibweise der Tabelle das Erzeugen der Padding Bytes durch den Assembler verhindern kann.

Interessant ist auch, dass in der Berechnung ein Register benötigt wird, welches den Wert 0 enthält. Dies deshalb, da es im AVR keinen Befehl gibt der eine Konstante mit gleichzeitiger Berücksichtigung des Carry-Bits addieren kann. Daher muss diese Konstante zunächst in ein Register geladen werden und erst dann kann die Addition mithilfe dieses Registers vorgenommen werden. Das Interessante daran ist nun, dass dieser Umstand in sehr vielen Programmen vorkommt und es sich bei der Konstanten in der überwiegenden Mehrzahl der Fälle um die Konstante 0 handelt. Viele Programmierer reservieren daher von vorne herein ein Register für diesen Zweck und nennen es das Zero-Register. Sinnvollerweise legt man dieses Register in den Breich r0..r15, da diese Register etwas zweitklassig sind (ldi, cpi etc. funktionieren nicht damit).

<avrasm>
.include "m8def.inc"

.def zero = r1
.def count = r16
.def temp1 = r17

.org 0x0000
rjmp main ; Reset Handler
;
main:
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
ldi temp1, $FF ; die Anzeige hängt am Port D
out DDRD, temp1 ; alle Pins auf Ausgang
;
ldi count, 0 ; und den Zähler initialisieren
mov zero, count
;
loop:
ldi ZL, LOW(Codes*2) ; die Startadresse der Tabelle in den
ldi ZH, HIGH(Codes*2) ; Z-Pointer laden

mov temp1, count ; die wortweise Adressierung der Tabelle
add temp1, count ; berücksichtigen

add ZL, temp1 ; und ausgehend vom Tabellenanfang
adc ZH, zero ; die Adresse des Code Bytes berechnen

lpm ; dieses Code Byte in das Register r0 laden

out PORTD, r0 ; und an die Anzeige ausgeben
;
inc count ; den Zähler erhöhen, wobei der Zähler
cpi count, 10 ; immer nur von 0 bis 9 zählen soll
brne wait
ldi count, 0
;
wait: ldi r17, 10 ; und etwas warten, damit die Ziffer auf
wait0: ldi r18, 0 ; der Anzeige auch lesbar ist, bevor die
wait1: ldi r19, 0 ; nächste Ziffer gezeigt wird
wait2: dec r19
brne wait2
dec r18
brne wait1
dec r17
brne wait0
;
rjmp loop ; auf zur nächsten Ausgabe
;
Codes: ; Die Codetabelle für die Ziffern 0 bis 9
; sie regelt, welche Segmente für eine bestimmte
; Ziffer eingeschaltet werden müssen
;
.db 0b11000000 ; 0: a, b, c, d, e, f
.db 0b11111001 ; 1: b, c
.db 0b10100100 ; 2: a, b, d, e, g
.db 0b10110000 ; 3: a, b, c, d, g
.db 0b10011001 ; 4: b, c, f, g
.db 0b10010010 ; 5: a, c, d, f, g
.db 0b10000010 ; 6: a, c, d, e, f, g
.db 0b11111000 ; 7: a, b, c
.db 0b10000000 ; 8: a, b, c, d, e, f, g
.db 0b10010000 ; 9: a, b, c, d, f, g

</avrasm>

==Mehrere 7-Segment Anzeigen (Multiplexen)==

Mit dem bisherigen Vorwissen könnte man sich jetzt daran machen, auch einmal drei oder vier Anzeigen mit dem Mega8 anzusteuern. Leider gibt es da ein Problem, denn für eine Anzeige sind acht Portpins notwendig - vier Anzeigen würden demnach 32 Portpins benötigen. Die hat der Mega8 aber nicht. Dafür gibt es aber mehrere Auswege. Schieberegister sind bereits in einem anderen [[AVR-Tutorial:_Schieberegister|Tutorial]] beschrieben. Im folgenden werden wir uns daher das [[Multiplexen]] einmal näher ansehen.

Multiplexen bedeutet, dass nicht alle vier Anzeigen gleichzeitig eingeschaltet sind, sondern immer nur Eine für eine kurze Zeit. Geschieht der Wechsel zwischen den Anzeigen schneller als wir Menschen das wahrnehmen können, so erscheinen uns alle vier Anzeigen gleichzeitig in Betrieb zu sein obwohl immer nur Eine für eine kurze Zeit aufleuchtet. Dabei handelt es sich praltisch um eine [[LED-Matrix]]. Die vier Anzeigen können sich dadurch die einzelnen Segmentleitungen teilen und alles was benötigt wird sind 4 zusätzliche Steuerleitungen für die 4 Anzeigen, mit denen jeweils eine Anzeige eingeschaltet wird. Dieses Ein/Ausschalten wird mit einem pnp-Transistor in der Versorgungsspannung jeder Anzeige realisiert, die vom Mega8 am '''PortC''' angesteuert werden.

Bei genauerer Betrachtung fällt auf, dass die vier Anzeigen nicht mehr ganz so hell leuchten wie die eine einzelne Anzeige ohne Multiplexen. Bei wenigen Anzeigen ist dies praktisch kaum sichtbar, erst bei mehreren Anzeigen wird es deutlich. Um dem entgegen zu wirken lässt man pro Segment einfach mehr Strom fließen, bei LEDs dürfen dann 20mA überschritten werden. Als Faustregel gilt, dass der n-fache Strom für die (1/n)-fache Zeit fließen darf. Details finden sich im Datenblatt unter dem Punkt '''Peak-Current''' (Spitzenstrom) und '''Duty-Cycle''' ([[PWM | Tastverhältnis]]).

Ein weiter Aspekt ist die Multiplexfrequenz. Sie muss hoch genug sein, um ein Flimmern der Anzeige zu vermeiden. Das menschliche Auge ist träge, im Kino reichen 24 Bilder pro Sekunde, beim Fernseher sind es 50. Um auf der sicheren Seite zu sein, dass auch Standbilder ruhig wirken, sollen jedes Segment mit mindestens 100 Hz angesteuert werden, es also mindestens alle 10ms angeschaltet ist. In Ausnahmefällen können aber selbst 100 Hz können noch flimmern, z.B. wenn die Anzeige schnell bewegt wird.

Neben dem Flimmern gibt es aber noch ein anderes Problem wenn insgesamt zu viele Anzeigen gemultiplext werden. Die Pulsströme durch die LEDs werden einfach zu hoch. Die meisten LEDs kann man bis 8:1 multiplexen, manchmal auch bis 16:1. Hier fliesst aber schon ein Pulsstrom von 320mA (16 x 20mA), was nicht mehr ganz ungefährlich ist. '''Strom lässt sich durch Multiplexen nicht sparen''', denn die verbrauchte Leistung ändert sich beim n-fachen Strom für 1/n der Zeit nicht. Kritisch wird es aber, wenn das Multiplexen deaktiviert wird (Ausfall der Ansteuerung durch Hardware- oder Softwarefehler) und der n-fache Strom dauerhaft durch eine Segment-LED fließt. Bei 320mA werden die meisten LEDs innerhalb von Sekunden zerstört. Hier muss sichergestellt werden, dass sowohl Programm (Breakpoint im Debugger) als auch Schaltung (Reset, Power-On) diesen Fall verhindern. Prinzipiell sollte man immer den Pulsstrom und die Multiplexfrequenz einmal überschlagen, bevor der Lötkolben angeworfen wird.

===Schaltung===

[[Bild:Tut_7_Seg_03.gif | framed | left | Ansteuerung von vier 7-Segmentanzeigen per Multiplex]]
 

Sollten die Anzeigen zu schwach leuchten so können, wie bereits beschrieben, die Ströme durch die Anzeigen erhöht werden. Dazu werden die 330 Ohm Widerstände kleiner gemacht. Da hier 4 Anzeigen gemultiplext werden, würden sich Widerstände in der Größenordnung von 100 Ohm anbieten. Auch kann dann der Basiswiderstand der Transistoren verkleinert werden.

===Programm===

Das folgende Programm zeigt eine Möglichkeit zum Multiplexen. Dazu wird ein Timer benutzt, der in regelmässigen Zeitabständen einen Overflow [[Interrupt]] auslöst. Innerhalb der Overflow Interrupt Routine wird
* die momentan erleuchtete Anzeige abgeschaltet
* das Muster für die nächste Anzeige am Port D ausgegeben
* die nächste Anzeige durch eine entsprechende Ausgabe am Port C eingeschaltet

Da Interruptfunktionen kurz sein sollten, holt die Interrupt Routine das auszugebende Muster für jede Stelle direkt aus dem SRAM, wo sie die Ausgabefunktion hinterlassen hat. Dies hat 2 Vorteile:
* Zum einen braucht die Interrupt Routine die Umrechnung einer Ziffer in das entsprechende Bitmuster nicht selbst machen
* Zum anderen ist die Anzeigefunktion dadurch unabhängig von dem was angezeigt wird. Die Interrupt Routine gibt das Bitmuster so aus, wie sie es aus dem SRAM liest.

Die Funktion out_number ist in einer ähnlichen Form auch schon an anderer Stelle vorgekommen: Sie verwendet die Technik der fortgesetzten Subtraktionen um eine Zahl in einzelne Ziffern zu zerlegen. Sobald jede Stelle feststeht, wird über die Codetabelle das Bitmuster aufgesucht, welches für die Interrupt Funktion an der entsprechenden Stelle im SRAM abgelegt wird.

'''Achtung''': Anders als bei der weiter oben gezeigten Variante wurde die Codetabelle ohne Padding Bytes angelegt. Dadurch ist es auch nicht notwendig derartige Padding Bytes in der Programmierung zu berücksichtigen.

Der Rest ist wieder die übliche Portinitialisierung, Timerinitialisierung und eine einfache Anwendung, indem ein 16 Bit Zähler laufend erhöht und über die Funktion out_number ausgegeben wird. Wie schon im ersten Beispiel, wurde auch hier kein Aufwand getrieben: Zähler um 1 erhöhen und mit Warteschleifen eine gewisse Verzögerungszeit einhalten. In einer realen Applikation wird man das natürlich nicht so machen, sondern ebenfalls einen Timer für diesen Teilaspekt der Aufgabenstellung einsetzen.

Weiterhin ist auch noch interessant. Die Overflow Interrupt Funktion ist wieder so ausgelegt, dass sie völlig transparent zum restlichen Programm ablaufen kann. Dies bedeutet, dass alle verwendeten Register beim Aufruf der Interrupt Funktion gesichert und beim Verlassen wiederhergestellt werden. Dadurch ist man auf der absolut sicheren Seite, hat aber den Nachteil etwas Rechenzeit für manchmal unnötige Sicherungs- und Aufräumarbeiten zu 'verschwenden'. Stehen genug freie Register zur Verfügung, dann wird man natürlich diesen Aufwand nicht treiben, sondern ein paar Register ausschließlich für die Zwecke der Behandlung der 7-Segment Anzeige abstellen und sich damit den Aufwand der Registersicherung sparen (mit Ausnahme von '''SREG''' natürlich!).

<avrasm>
.include "m8def.inc"

.def temp = r16
.def temp1 = r17
.def temp2 = r18

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp multiplex

;
;********************************************************************
; Die Multiplexfunktion
;
; Aufgabe dieser Funktion ist es, bei jedem Durchlauf eine andere Stelle
; der 7-Segmentanzeige zu aktivieren und das dort vorgesehene Muster
; auszugeben
; Die Funktion wird regelmässig in einem Timer Interrupt aufgerufen
;
multiplex:
push temp ; Alle verwendeten Register sichern
push temp1
in temp, SREG
push temp
push ZL
push ZH

ldi temp1, 0 ; Die 7 Segment ausschalten
out PORTC, temp1

; Das Muster für die nächste Stelle ausgeben
; Dazu zunächst mal berechnen, welches Segment als
; nächstest ausgegeben werden muss
ldi ZL, LOW( Segment0 )
ldi ZH, HIGH( Segment0 )
lds temp, NextSegment
add ZL, temp
adc ZH, temp1

ld temp, Z ; das entsprechende Muster holen und ausgeben
out PORTD, temp

lds temp1, NextDigit ; Und die betreffende Stelle einschalten
out PORTC, temp1

lds temp, NextSegment
inc temp
lsl temp1 ; beim nächsten Interrupt kommt reihum die
cpi temp1, $10 ; nächste Stelle dran.
brne multi1
ldi temp, 0
ldi temp1, $01

multi1:
sts NextSegment, temp
sts NextDigit, temp1

pop ZH ; die gesicherten Register wiederherstellen
pop ZL
pop temp
out SREG, temp
pop temp1
pop temp
reti
;
;************************************************************************
; 16 Bit-Zahl aus dem Registerpaar temp (=low), temp1 (=high) ausgeben
; die Zahl muss kleiner als 10000 sein, da die Zehntausenderstelle
; nicht berücksichtigt wird.
; Werden mehr als 4 7-Segmentanzeigen eingesetzt, dann muss dies
; natürlich auch hier berücksichtigt werden
;
out_number:
push temp
push temp1

ldi temp2, -1 ; Die Tausenderstelle bestimmen
_out_tausend:
inc temp2
subi temp, low(1000) ; -1000
sbci temp1, high(1000)
brcc _out_tausend

ldi ZL, low(2*Codes) ; fuer diese Ziffer das Codemuster fuer
ldi ZH, high(2*Codes) ; die Anzeige in der Codetabelle nachschlagen
add ZL, temp2

lpm
sts Segment3, r0 ; und dieses Muster im SRAM ablegen
; die OvI Routine sorgt dann duer die Anzeige
ldi temp2, 10

_out_hundert: ; die Hunderterstelle bestimmen
dec temp2
subi temp, low(-100) ; +100
sbci temp1, high(-100)
brcs _out_hundert

ldi ZL, low(2*Codes) ; wieder in der Codetabelle das entsprechende
ldi ZH, high(2*Codes) ; Muster nachschlagen
add ZL, temp2

lpm
sts Segment2, r0 ; und im SRAM hinterlassen

ldi temp2, -1
_out_zehn: ; die Zehnerstelle bestimmen
inc temp2
subi temp, low(10) ; -10
sbci temp1, high(10)
brcc _out_zehn

ldi ZL, low(2*Codes) ; wie gehabt: Die Ziffer in der Codetabelle
ldi ZH, high(2*Codes) ; aufsuchen
add ZL, temp2

lpm
sts Segment1, r0 ; und entsprechend im SRAM ablegen

_out_einer: ; bleiben noch die Einer
subi temp, low(-10) ;-10
sbci temp1, high(-10)

ldi ZL, low(2*Codes) ; ... Codetabelle
ldi ZH, high(2*Codes)
add ZL, temp

lpm
sts Segment0, r0 ; und ans SRAm ausgeben

pop temp1
pop temp

ret
;
;**************************************************************************
;
main:
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp
; die Segmenttreiber initialisieren
ldi temp, $FF
out DDRD, temp
; die Treiber für die einzelnen Stellen
ldi temp, $0F
out DDRC, temp
; initialisieren der Steuerung für die
; Interrupt Routine
ldi temp, 1
sts NextDigit, temp

ldi temp, 0
sts NextSegment, temp

ldi temp, ( 1 << CS01 ) | ( 1 << CS00 )
out TCCR0, temp

ldi temp, 1 << TOIE0
out TIMSK, temp

sei

ldi temp, 0
ldi temp1, 0

loop:
inc temp
brne _loop
inc temp1
_loop:
call out_number

cpi temp, low( 4000 )
brne wait
cpi temp1, high( 4000 )
brne wait

ldi temp, 0
ldi temp1, 0

wait: ldi r21, 1
wait0: ldi r22, 0
wait1: ldi r23, 0
wait2: dec r23
brne wait2
dec r22
brne wait1
dec r21
brne wait0

rjmp loop

Codes:
.db 0b11000000, 0b11111001 ; 0: a, b, c, d, e, f
; 1: b, c
.db 0b10100100, 0b10110000 ; 2: a, b, d, e, g
; 3: a, b, c, d, g
.db 0b10011001, 0b10010010 ; 4: b, c, f, g
; 5: a, c, d, f, g
.db 0b10000010, 0b11111000 ; 6: a, c, d, e, f, g
; 7: a, b, c
.db 0b10000000, 0b10010000 ; 8: a, b, c, d, e, f, g
; 9: a, b, c, d, f, g

.DSEG
NextDigit: .byte 1 ; Bitmuster für die Aktivierung des nächsten Segments
NextSegment: .byte 1 ; Nummer des nächsten aktiven Segments
Segment0: .byte 1 ; Ausgabemuster für Segment 0
Segment1: .byte 1 ; Ausgabemuster für Segment 1
Segment2: .byte 1 ; Ausgabemuster für Segment 2
Segment3: .byte 1 ; Ausgabemuster für Segment 3
</avrasm>

{{Navigation_zurückhoch|
zurücktext=SRAM|
zurücklink=AVR-Tutorial: SRAM|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial}}

[[Category:AVR]][[Category:AVR-Tutorial]]

Bitmanipulation

2007-12-31T12:43:07Z

FalkB: Erweiterung für I/O Register per lds/sts

== Bits setzen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Eins gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#ODER | ODER]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden auf '1' gesetzt. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<avrasm>
sbr r16, 0b11110000 ; setzt Bits 4-7 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

ori r16, 0b11110000 ; setzt Bits 4-7 in r16, ori ist sbr
; funktioniert nur für die Arbeitsregister r16-r31

sbi PORTB, 5 ; setzt Bit 5 in PortB
sbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..0x1F

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden
in r16, TIMSK ; setzt Bit TOIE1 in TIMSK
sbr r16, (1<<TOIE1)
out UCSR0B, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; setzt Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
sbr r16, (1<<RXCIE0)
sts UCSR0B, r16
</avrasm>

Man beachte den Unterschied! Eine "5" würde von sbr als "setze Bit 2 und 0" gedeutet (=0b00000101), während sbi sie als "setzte Bit 5" versteht. Der Befehl '''sbr''' erwartet ein Bit'''muster''' für eine ODER-Verknüpfung, während der Befehlt '''sbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] (C) ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z.B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<c>
PORTB |= 0xF0; // Kurzschreibweise, entspricht PORTB = PORTB | 0xF0 also bitweises ODER.

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB |= ((1 << MEINBIT0) | (1 << MEINBIT2)); // setzt Bit 0 und 2 in PORTB auf "1"
</c>

Die letzte Zeile "entschlüsselt": 
Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2). Das Ergebnis wird bitweise ODER-verknüpft, also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101. Diese Maske wird mit dem aktuellen Inhalt von PORTB bitweise ODER-verknüpft und das Ergebnis PORTB mittels '|=' wieder zugewiesen. Ist PORTB vorher z.B. 0b01111010, dann ist der Inhalt nach der Operation 0b01111010 ''or'' 0b00000101 = 0b01111111, die gewünschten Bits sind somit gesetzt!

Anmerkung: Will man das gezeigte Beispiel der Bitmanipulation auf größere Datentypen anwenden, ist zu beachten, dass der Compiler in der Operation (1 << MEINBIT1) stillschweigend die 1 als Integer Type ansieht. Beim AVR-GCC bedeutet das 16-Bit und die folgende Operation bringt ggf. nicht das gewünschte Ergebnis. (Stichwort: "Integer Promotion").

Angenommen Bit 15 soll in einer 32-Bit weiten Variable gesetzt werden.

<c>
#define MEINBIT15 15
#define MEINBIT42 42

uint32_t reg_32;
uint64_t reg_64;

reg_32 |= (1 << MEINBIT15); /* FEHLER: Setzt die Bits 31 - 15, da ((int)1 << 15) == 0xFFFF8000 */

reg_32 |= ((uint32_t)1 << MEINBIT15); /* Hier wird nur Bit 15 gesetzt. */
reg_32 |= (1L << MEINBIT15); /* andere Schreibweise. */
reg_64 |= (1LL << MEINBIT42); /* Hier wird nur Bit 42 gesetzt,
andere Schreibweise für 64 Bit (long long). */
</c>

== Bit löschen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Null gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#UND | UND]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '0' sind, werden auf '0' gesetzt. Alle Bits, die in der Maske auf '1' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<avrasm>
cbr r16, 0b11110000 ; löscht Bits 0-3 in r16, setzt sie auf 0
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, 0b11110000 ; löscht Bits 0-3 in r16, andi ist identisch mit dem Pseudobefehl cbr
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, ~0b00001111 ; andere Schreibweise, hier wird die Bitmaske durch ~ invertiert
; dadurch kann man einfach alle zu löschenden Bit als '1' angeben
; so wie bei den Bitmasken für das setzen von Bits (positive Logik)

cbi PORTB, 5 ; löscht Bit 5 in PortB
cbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..31

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden
in r16, TIMSK ; löscht Bit TOIE1 in TIMSK
cbr r16, ~(1<<TOIE1)
out UCSR0B, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; löscht Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
cbr r16, ~(1<<RXCIE0)
sts UCSR0B, r16

</avrasm>

Auch hier gilt. Man beachte den Unterschied! Eine "5" würde von cbr als "lösche Bit 7,6,5,4,3 und 1" gedeutet, während cbi sie als "lösche Bit 5" versteht. Der Befehl '''cbr''' erwartet ein Bit'''muster''' für eine UND-Verknüpfung, während der Befehlt '''cbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] (C) ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z.B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<c>
PORTB &= 0xF0; // entspricht PORTB = PORTB & 0xF0 also bitweises UND;
// Bits 0-3 (das "niederwertige" Nibble) werden geloescht

/* uebersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB &= ~((1 << MEINBIT0) | (1 << MEINBIT2)); // löscht Bit 0 und 2 in PORTB
</c>

Die letzte Zeile "entschlüsselt": 
Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2). Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101. Durch '~' wird der Wert in der Klammer invertiert, aus 0b00000101 wird 0b11111010. Schließlich wird durch '&=' mit dem aktuellen Wert von PORTB UND-verknüpft und das Ergebnis wieder PORTB zugewiesen. Ist PORTB vorher z.B. 0b01111111, dann ist der Inhalt nach der Operation 0b011111111 ''and'' 0b11111010 = 0b01111010, die gewünschten Bits (0 und 2) sind somit gelöscht.

Die C-Ausdrücke sehen auf den ersten Blick etwas "erschreckend" aus und sind mehr "Tipparbeit", funktionieren aber universell und sind nach einiger Gewöhnung deutlicher und nachvollziehbarer als "handoptimierte" Konstanten.

=== Niederwertigstes gesetztes Bit löschen (Standard C) ===

Folgender Code löscht von allen 1-Bits in einer Integer-Variable das niederwertigste, unabhängig von der Position desselben.

Beispiel: 01101000 -> 01100000

<c>
uint8_t byte;

byte = irgendwas();

byte = byte & (byte - 1); /* Diese seltsame Operation löscht das
niederwertigste 1-Bit */
</c>

Dies kann bspw. zur schnellen Paritätsgenerierung eingesetzt werden:

<c>
uint8_t pareven(uint8_t byte) {
uint8_t par = 0;

while(byte) {
byte = byte & (byte - 1);
par = !par;
}
return par;
}
</c>

Das genannte gilt natürlich nicht nur für 8-Bit-Integers, sondern für beliebige, vom Compiler unterstützte Wortlängen.

== Bit toggeln ==

Toggeln bedeutet den Wert eines Bits invertiert. Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] invertiert (getoggelt) werden sollen, wird die durch eine [[AVR-Tutorial:_Logik#XOR_.28Exlusives_Oder.29 | XOR]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden invertiert. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR Assembler ===

Bei [[AVR]]s erlaubt dies z.B. folgender Assemblercode:

<avrasm>
sbic PortB, 0 ; skip if bit is cleared
rjmp ClrBitNow ; jump
sbi PortB, 0 ; set bit (if bit was cleared)
rjmp BitReady ; jump
ClrBitNow:
cbi PortB, 0 ; clear bit (if bit was set)
BitReady:
</avrasm>

Kürzer gehts mit folgender Variante. Zwischen der 2. und 3. Instruktion darf jedoch kein Interrupt erfolgen, sonst würde das SBIC schon den neuen Pegel des SBI auswerten (evtl. globale Interrupts ausschalten).

<avrasm>
cli ; disable global interrupts
sbis PinB, 0 ; skip if bit is set
sbi PortB, 0 ; otherwise set bit
sbic PinB, 0 ; skip if bit is cleared
cbi PortB, 0 ; otherwise clear bit
sei ; enable global interrupts
</avrasm>

Noch kürzer gehts so: 
Die zweite Zeile mit dem Befehl '''ldi''' lädt die Bitmaske, in welcher die zu den zu toggelnden Bits auf '1' gesetzt sind. In diesem Beispiel wird das dritte Bit invertiert. Der Vorteil dieser Methode ist neben der Kürze und Übersichtlichkeit auch die Möglichkeit, bis zu 8 Bit gleichzeitig zu toggeln.

<avrasm>
in R24, PORTE ; Daten lesen
ldi R25, 0x04 ; Bitmaske laden, hier Bit#2
eor R24, R25 ; Exklusiv ODER
out PORTE, R24 ; Daten zurückschreiben
</avrasm>

Eine andere Möglichkeit gibt es, wenn man nur das 8. Bit kippen will:

<avrasm>
in r16, PORTB
subi r16, 0x80
out PORTB, r16
</avrasm>

=== Standard C ===

<c>
PORTB ^= (1<<PB0); /* XOR, Kurzschreibweise, PORTB = PORTB ^ (1<<PB0) */
</c>

=== Neuere ATmegas ===

Bei den neueren ATmegas (z.B. ATmega48) kann man IO-Pins direkt ohne den Umweg über Register togglen, indem man das entsprechende Bit im PINx-Register '''setzt''':

<avrasm>
sbi PIND, 2 ; Bit 2 von Port D togglen
</avrasm>

=== 8051er ===

<avrasm>
cpl bitadresse
</avrasm>

[[Category:8051]][[Category:AVR]]

SDRAM-Timing

2007-12-31T10:10:07Z

FalkB: Links ergänzt

== Einleitung==

SDRAM ist mittlerweile ein Standardbauteil im Bereich der Mikroprozessoren. Doch wie kann man prüfen, ob das Timing des Businterface eingehalten wird?

==Timing synchroner Systeme==

Jede synchrone Logikschaltung folgt einem grundlegenden Prinzip. Viele FlipFlops speichern Bits, mit denen Daten und Zustandsvariablen von State Machines kodiert sind. Zwischen den FlipFlops gibt es im einfachsten Fall eine direkte Verbindung, z.B. in einem Schieberegister. Wenn Daten logisch verarbeitet werden sollen, befindet sich zwischen FlipFlops eine logische Verknüpfung mehrerer Signale, die je nach Komplexität eine kurze oder lange Durchlaufverzögerung aufweist. Alle FlipFlops werden über ein spezielles Netzwerk mit einem Takt versorgt. Das Netzwerk sorgt dafür, daß der Takt von einer Quelle nahezu gleichzeitig bei allen FlipFlops ankommt (typisch +/-100ps bei modernen FPGAs). Das ist auch notwendig, darauf baut die synchrone Schaltungstechnik auf.

Wie bestimmt man von so einem System die maximale Taktfrequenz? Indem man sich den zeitlichen Ablauf der Signale verdeutlicht und letztendlich in Zahlen ausdrückt.
Was passiert während einer Taktperiode? Mit dem gleichzeitigen Eintreffen der aktiven (meist steigenden) Taktflanke geben alle FlipFlops neue Daten aus, die am Eingang anliegen. Das sind die Daten, die in der vorherigen Taktperiode berechnet wurden. Das dauert eine kleine Weile. Wie lange ist von der Technologie des ICs abhängig (Bruchteile von Nanosekunden bis einige Dutzend Nanosekunden). Allgemein wird diese Zeit als Clock-to-Output-Time bezeichnet. Es ist die Zeit die ein FlipFlop braucht, um nach der Taktflanke neue Daten auszugeben. Danach müssen die Signale die kombinatorische Logik durchlaufen (wenn es welche gibt). Diese Zeit nennt man Propagation Delay Time (kombinatorische Durchlaufverzögerung). Wenn keine Logik zwischen den FlipFlops liegt kommt nur die reine Laufzeit auf den Verbindungsleitungen zum Tragen. Auf den ersten Blick scheint das komisch, schliesslich breiten sich elektrische Signale auf Leitungen mit ca. halber Lichtgeschwindigkeit aus, wie kann da die Laufzeit von ein paar μm auf einem IC bzw. ein paar cm zwischen ICs eine Rolle spielen? Nun, wenn man sich die Taktraten moderner ICs vor Augen führt, dann erscheint die Lichtgeschwindigkeit doch schon eher moderat. Ein Signal legt pro Nanosekunde ca. 15..20cm auf einer Leiterplatte oder einem Kabel zurück. Wir werden noch sehen, daß das bisweilen langsam sein kann. (In einem FPGA bestehen die Verbindungen nicht aus einfachem Metall sondern sind konfigurierbare Schalter, welche aus Transistoren aufgebaut sind. Nicht selten ist Laufzeit auf den Leitungen genauso hoch wie die Verzögerung der reinen Logikfunktionen.) Doch nachdem unsere neuen Daten ausgegeben, logisch verknüpft wurden und die Leitungen hinter sich gelassen haben, müssen sie rechtzeitig vor der nächsten Taktflanke am Ziel ankommen, sprich am FlipFlop, welches die Daten erhalten soll. Und zwar nicht "fünf vor Zwölf", sondern mindestens die sog. Setup-zeit vorher. Diese ist wieder von der IC-Technologie abhängig. Wenn all diese Dinge nacheinander passiert sind kann die nächste Taktflanke die neuen Daten in die FlipFlops übernehmen. Damit ist der Zyklus fast vollständig. Was noch fehlt ist die sog. Hold-time, also die Zeit, welche die Daten noch nach der Taktflanke stabil anliegen müssen. Bei den meisten ICs ist diese Zeit 0ns, aber einige ICs brauchen ein paar ns. Das Datenblatt sagt hier was notwendig ist.

Aus der eben dargestellten Erklärung können wir die minimale Taktperiode (=maximale Taktfrequenz) berechnen.

<math>T_{CLK}>=T_{C2O}+T_{PD}+T_{RT}+T_{S}</math>
{|
|-
|<math>T_{CLK}</math> || Periodendauer des Taktes
|-
|<math>T_{C2O}</math> || Clock to Output Time (Ausgabezeit des FlipFlops)
|-
|<math>T_{PD}</math> || Propagation Delay Time (Durchlaufzeit kombinatorischer Logik)
|-
|<math>T_{RT}</math> || Run Time (Laufzeit auf Verbindungsleitungen)
|-
|<math>T_{S}</math> || Setup Time (Stabilisierungszeit für Daten)
|-
|<math>T_{H}</math> || Hold Time (Haltezeit für Daten)
|}

Für die Hold Time kann folgende Beziehung aufgestellt werden

<math>T_H <= T_{C2O}+T_{PD}+T_{RT}</math>

Wie man sieht macht die Hold Time wahrscheinlich selten Probleme, zumal sie oft Null ist. Doch Vorsicht! Selten heißt nicht niemals! Also besser nachrechnen und messen!

Die Differenz aus minimaler Taktperiode und der realen Taktperiode, mit der die Schaltung betrieben wird, steht als Timingreserve zur Verfügung, (englisch Slack). Wieviel Reserve eine Schaltung braucht ist bisweilen gar nicht so einfach zu sagen. Ein AVR mit 20MHz (50ns) ist mit 5ns sehr gut bedient (55ns, 18 MHz). Ein DDR-RAM mit 200MHz hat gerade mal 5ns Periodendauer, da sind 500ps schon 10%!

==SDRAM Timing bei sternförmiger Taktverteilung==

Aufbauend auf dem oben beschriebenen Prinzip kann man nun das Zusammenspiel zwischen Mikrocontroller und SDRAM bei sternförmiger Taktverteilung beschreiben. Dabei wird von einer zentralen Taktquelle (meist ein Quarz) über einen Takttreiber, welcher ein Eingangssignal auf mehrere Ausgänge sehr gleichmäßig verteilt, sternförmig an alle Teilnehmer des synchronen Busses verteilt. Die einzelnen Stränge vom Takttreiber zu den einzelnen Verbrauchern sind dabei gleich lang und haben die gleiche Ausbreitungsgeschwindigkeit. Damit kommt das Taktsignal sehr synchron bei allen Verbrauchern an, +/-500ps und weniger sind hier recht problemlos machbar. Zu beachten ist, daß die Ausbreitungsgeschwindigkeit elektrischer Signale auf Leiterbahnen unterschiedlich sein kann! Aussenlagen sind schneller als Innenlagen in Multilayerplatinen (ca. 20cm/ns zu 15 cm/ns). Paßt man da nicht auf haben gleich lange Taktleitungen unterschiedliche Laufzeiten! Doch das nur am Rande.

Mit dem beschriebenen Aufbau kann man nun das Timing analysieren. Dabei muß man zwei wesentliche Fälle unterscheiden.

===Schreibzugriff===

Die Daten laufen vom Mikrocontroller zum SDRAM. Das gilt immer für den Adress- und Steuerbus sowie den Datenbus bei einem Schreibvorgang.

<math>T_{CLK}>=T_{C2O}+T_{RT}+T_{S}</math>
<math>T_H <= T_{C2O}+T_{RT}</math>

{|
|-
|<math>T_{Clk}</math> || Periodendauer des Taktes
|-
|<math>T_{C2O}</math> || maximale Ausgabezeit der Daten am Mikrocontroller, Datenblatt
|-
|<math>T_{RT}</math> || Laufzeit auf Verbindungsleitungen
|-
|<math>T_{S}</math> || minimale Stabilisierungszeit der Daten am SDRAM, Datenblatt
|-
|<math>T_H</math> || minimale Haltezeit der Daten am SDRAM, Datenblatt
|}

===Lesezugriff===

Die Daten laufen vom SDRAM zum Mikrocontroller. Das gilt für den Datenbus bei einem Lesevorgang.

<math>T_{CLK}>=T_{C2O}+T_{RT}+T_{S}</math>
<math>T_H <= T_{C2O}+T_{RT}</math>

{|
|-
|<math>T_{CLK}</math> || Periodendauer des Taktes
|-
|<math>T_{C2O}</math> || maximale Ausgabezeit der Daten am SDRAM, Datenblatt
|-
|<math>T_{RT}</math> || Laufzeit auf Verbindungsleitungen
|-
|<math>T_{S}</math> || minimale Stabilisierungszeit der Daten am Mikrocontroller, Datenblatt
|-
|<math>T_H</math> || minimale Haltezeit der Daten am Mikrocontroller, Datenblatt
|}

Das war's eigentlich schon. Für beide Fälle müssen beide Formeln für <math>T_{CLK}</math> und <math>T_H</math> erfüllt sein. <math>T_{PD}</math> ist immer Null, da hier keine weitere Logik zwischen SDRAM und Mikrocontroller liegt, nur Leiterbahnen.

==SDRAM Timing bei Taktverteilung vom Mikrocontroller==

Etwas kniffliger wird die Angelegenheit wenn der Takt vom Mikrocontroller geliefert wird. Sämtliche Timings im Datenblatt beziehen sich auf das Taktsignal direkt am Gehäuse. Wenn nun aber eine etwas längere Taktleitung gebraucht wird, verschieben sich die Zeiten. Aber wie? Das Wort zur Beschreibung von verschobenen Taktflanken in synchronen Systemen heißt Skew. Im Idealfall ist er Null, real aber leider einiges größer.
Betrachten wir zunächst die Datenrichtung vom Mikrocontroller zum SDRAM. Takt und Daten bewegen sich in die gleiche Richtung. Was hier scheinbar gut klingt kann böse ins Auge gehen. Wie? Nehmen wir an, die Taktleitung ist sehr viel länger als die Datenleitungen. Dann kann es bei schnellen ICs passieren, daß die Daten eher am nächsten FlipFlop sind (hier der SDRAM) als der Takt! Wenn dann der Takt verspätet eintrifft werden nicht die Daten des vorherigen Zyklus eingetaktet sondern die neuen! Es scheint dann so, als ob ein Taktzyklus fehlt! Demzufolge muß der Takt immer als erster ankommen. Wobei der Takt meist den Vorteil hat, daß die Daten noch von den FlipFlops ausgegeben werden müssen. Mathematisch heißt das.

<math>T_{RT-CLK}<=T_{RT-DATA}+T_{C2O}+T_H</math>

{|
|-
|<math>T_{RT-CLK}</math> || Laufzeit des Taktes
|-
|<math>T_{RT-DATA}</math> || Laufzeit der Daten
|-
|<math>T_{C2O}</math> || minimale Ausgabezeit der Daten am Mikrocontroller, Datenblatt
|-
|<math>T_H</math> || minimale Haltezeit der Daten am SDRAM, Datenblatt
|}

Es ist also ratsam, die Taktleitung so kurz wie möglich zu halten. Auf grösseren Boards mit vielen SDRAMs und hohen Taktfrequenzen ist das manchmal schwierig bis unmöglich. Abhilfe schafft hier ein sog. PLL-Takttreiber. Dieser hat zusätzlich zum normalen Takttreiber eine PLL eingebaut, mit deren Hilfe Taktsignale "gespiegelt" werden können, d.h. Leitungslängen werden komplett kompensiert und an allen Verbrauchern liegt der Takt mit sehr geringer Phasenverschiebung an. Damit ist wieder ein System mit sternförmiger Taktverteilung entstanden und die Betrachtung vereinfacht sich. In FPGAs von Xilinx verwendet man DLLs ('''D'''elay '''L'''ocked '''L'''oop) bzw. in den neueren Familien DCMs ('''D'''igital '''C'''lock '''M'''anager). Mit diesen Komponenten ist es möglich, den Takt im FPGA sowie am SDRAM in der Phase auszurichten, genauso wie es die PLL-Takttreiber auch machen. Siehe [[#Links | Links]].

===Schreibzugriff===

Doch zurück zu unserem Takt, welcher eine gewisse Laufzeit bis zum SDRAM braucht. Wenn der später am Ziel (SDRAM) ankommt, dann haben die Daten auch ein klein wenig mehr Zeit, sich bis zum Ziel "durchzuschlagen". Mathematisch heißt das

<math>T_{CLK}>=T_{C2O}+T_{RT}+T_{S}- T_{RT-CLK}</math>

{|
|-
|<math>T_{CLK}</math> || Periodendauer des Taktes
|-
|<math>T_{C2O}</math> || maximale Ausgabezeit der Daten am SDRAM, Datenblatt
|-
|<math>T_{RT}</math> || Laufzeit auf Verbindungsleitungen
|-
|<math>T_{S}</math> || minimale Stabilisierungszeit der Daten am Mikrocontroller, Datenblatt
|-
|<math>T_{RT-CLK}</math> || Laufzeit des Taktes
|}

Wer jetzt aber meint mit einer großen Laufzeit des Taktes die maximale Taktfrequenz erhöhen zu können irrt! Was hier scheinbar höhere Taktfrequenzen zuläßt, ist bei der Hold Time kontraproduktiv. Ausserdem darf man den Lesezugriff nicht vergessen.

<math> T_H <= T_{RT-DATA}+T_{C2O}- T_{RT-CLK}</math>

{|
|-
|<math>T_{RT-CLK}</math> || Laufzeit des Taktes
|-
|<math>T_{RT-DATA}</math> || Laufzeit der Daten
|-
|<math>T_{C2O}</math> || minimale Ausgabezeit der Daten am Mikrocontroller, Datenblatt
|-
|<math>T_H</math> || minimale Haltezeit der Daten am SDRAM, Datenblatt
|}

===Lesezugriff===

Zu guter Letzt müssen wir noch die Datenrichtung vom SDRAM zum Mikrocontroller prüfen. Wie wirkt sich hier eine Laufzeit des Taktes aus? Nun, wenn der Takt später am SDRAM ankommt werden die Lesedaten später "auf die Reise gehen". Das bedeutet, daß sie später am Mikrocontroller ankommen.

<math>T_{CLK}>=T_{C2O}+T_{RT}+T_{S}+T_{RT-CLK}</math>

{|
|-
|<math>T_{CLK}</math> || Periodendauer des Taktes
|-
|<math>T_{C2O}</math> || maximale Ausgabezeit der Daten am SDRAM, Datenblatt
|-
|<math>T_{RT}</math> || Laufzeit auf Verbindungsleitungen
|-
|<math>T_{S}</math> || minimale Stabilisierungszeit der Daten am Mikrocontroller, Datenblatt
|-
|<math>T_{RT-CLK}</math> || Laufzeit des Taktes vom Mikrocontroller zum SDRAM
|}

Immerhin ändern sich damit die Daten nicht so schnell wie im Normalfall, so daß die Hold Time hier keine Probleme macht, da Takt und Daten entgegengesetzt laufen.

<math> T_H <= T_{RT-DATA}+T_{C2O}+ T_{RT-CLK}</math>
{|
|-
|<math>T_{RT-CLK}</math> || Laufzeit des Taktes
|-
|<math>T_{RT-DATA}</math> || Laufzeit der Daten
|-
|<math>T_{C2O}</math> || minimale Ausgabezeit der Daten am SDRAM, Datenblatt
|-
|<math>T_H</math> || minimale Hold Time der Daten am Mikrocontroller, Datenblatt
|}

==Zusammenfassung==

*Wenn Takt und Daten in die gleiche Richtung laufen können Probleme mit der Hold Time auftreten
*Wenn Takt und Daten in die entgegengesetzte Richtung laufen können Probleme mit der Setup Time auftreten
*Eine sternförmige Taktverteilung ist einfacher zu analysieren
*Bei langen Taktleitungen und vielen Taktempfängern sind PLL-Takttreiber hilfreich

== Links ==

* [http://www.micron.com/products/dram/ DRAM bei Micron]
* [http://www.micron.com/products/dram/sdram/technotes Application Notes von Micron zu SDRAMs]
* [http://www.hynix.com/datasheet/Timing_Device/DDR_DeviceOperation.pdf Application Notes von Hynix]
* [http://www.samsung.com/global/business/semiconductor/products/dram/Products_DRAM.html DRAM bei Samsung]
* [http://www.samsung.com/global/business/semiconductor/products/dram/DRAMApplicationNote.html Application Notes von Samsung]
* [http://www.xilinx.com/bvdocs/appnotes/xapp174.pdf Application Note von Xilinx: "Using Delay-Locked Loops in Spartan-II FPGAs"]
* [http://direct.xilinx.com/bvdocs/appnotes/xapp134.pdf Application Note von Xilinx: "SDRAM Controller in Spartan-II FPGAs"]
* [http://direct.xilinx.com/bvdocs/appnotes/xapp454.pdf Application Note von Xilinx: "DDR2 SDRAM Memory Interface for Spartan-3 FPGAs"]
* [http://www.mikrocontroller.net/topic/64305#new Diskussion zum Thema SDRAM + FPGA]

Bascom AVR

2007-12-30T23:10:47Z

FalkB: /* Weblinks */

[[Category:AVR]]

Bascom AVR ist ein kommerzieller [[Basic]]-Compiler für die [[AVR]]s. Die kostenlose Demoversion kann Code bis zu einer Größe von 2kB erzeugen, womit man z.B. den Speicher des AT90S2313 vollständig ausnutzen kann. Bascom AVR beinhaltet sehr viele fertige Funktionen mit denen das Ansteuern von externen Bauteilen (wie Servos, LCDs usw.) sehr einfach zu realisieren ist.

Problematisch bei Bascom AVR ist leider die Festlegung der Werte für den Software- und Hardwarestack sowie das Festlegen der Framesize. Diese Werte beeinflussen die Variablen und das komplette Programm. Bei großen Programmen kann das zum Verhängnis werden und negative Auswirkungen haben.

== Weblinks ==
* [http://www.mcselec.com/bascom-avr.htm Seite des Herstellers]
* [http://www.mcselec.com/index.php?option=com_docman&task=doc_download&gid=140&Itemid=54 Das Handbuch aller Befehle, ein absolutes '''Muss''' für jeden BASCOMer!]

Bascom AVR

2007-12-30T23:10:15Z

FalkB: /* Weblinks */ Link auf Handbuch hinzugefügt

Festkommaarithmetik

2007-12-29T16:33:05Z

FalkB: Kauderwelsch wieder entfernt

== Das Problem ==

Ein immer wiederkehrendes Problem ist die Anzeige von Messwerten per UART/RS232 oder LCD. Die Messwerte werden praktisch immer von [[AD-Wandler]]n oder anderen Sensoren in digitaler Form geliefert. Doch wie wandelt man diese in eine "normale" Anzeige wie z.B. 4,56V um?

Der einfachste Ansatz ist der Einsatz von Gleitkommazahlen. Dabei gilt nahezu immer die Formel

<math>Eingangsspannung = \frac{ADC \hbox{-} Wert \cdot Referenzspannung}{ 2^{Bitbreite_{ADC}}}</math>

Den so errechneten Wert der Eingangsspannung kann man einfach per C-Funktion

<c>
sprintf(mein_string, "%2.4f", Eingangsspannung);
</c>

in einen String umwandeln und dann auf ein LCD oder den UART ausgeben.

Soweit so gut. Das Problem ist "nur".

* Das Rechnen mit Gleitkommazahlen ist auf den meisten Mikrocontrollern mit recht viel Rechenzeit sowie Programmspeicher verbunden, da diese keine Befehle zur direkten Verarbeitung von Gleitkommazahlen haben. Alle Rechnungen werden mit Hilfe von Bibliotheksfunktionen nachgebildet.
* Die Ausgabe von Gleitkommazahlen per sprintf und Konsorten benötigt ebenfalls sehr viel Programmspeicher, da diese Funktionen sehr mächtig und damit umfangreich sind

== Die Lösung ==

Die allerwenigsten Anwendungen benötigen die volle Leistung von Gleitkommazahlen (Dynamikbereich). Wesentlich sinnvoller ist die Anwendung von Festkommazahlen. Diese sind normale Integerzahlen (ganzzahlig ohne Kommastellen), allerdings mit "gedachten" Kommastellen. Wie geht das? Ganz einfach. Anstatt 10,45 kann man auch 1045 schreiben und die beiden letzten Stellen als Nachkommastellen betrachten. 1045 kann man in einer ganz normalen 16 Bit Integervariable speichern. Und auch damit rechnen!

Anstatt nun in Gleitkomma zu schreiben und zu rechnen

<math>U = \frac{756 \cdot 5,0}{1024}</math>

wird geschrieben

<math>U = \frac{756 \cdot 5000}{1024}</math>

Die Referenzspannung wird in 1/1000 V (mV) ausgedrückt und damit gerechnet. Das Ergebnis ist eine Spannung in mV.

Wichtig ist dabei, daß

* erst alle Multiplikationen und dann erst die Divisionen durchgeführt werden, um Rundungsfehler zu minimieren
* in sämtlichen Zwischenergebnissen keine arithmetischen Überläufe auftreten, also genügend grosse Variablen benutzen (16/32/64 Bit Integer)

Doch wie wird nun diese Zahl in einen darstellbaren String umgewandelt? Im einfachsten Fall durch Verwendung der C-Funktion itoa (Integer to ASCII). Diese ist auf vielen Mikrocontrollern als C-Bibliothek verfügbar. Wenn dies jedoch nicht so sein sollte muss man sie selber schreiben. Und da wir hier etwas lernen wollen, werden wir das auch tun.

== ITOA selbst gemacht ==

Wie funktioniert nun die Umwandlung einer Zahl in einen String? Ganz einfach. Für jede Stelle der Dezimalzahl muss ein ASCII-Zeichen erzeugt werden. Wenn z.B. die Zahl 28943 in einen String gewandelt werden soll muss am Ende der String die ASCII-Codes 0x32, 0x38, 0x39, 0x34, 0x33 und 0x00 (Stringabschlusszeichen, Stringterminator) enthalten. Wie man bei genauem Hinsehen sieht, besteht der ASCII-Code einer Zahl zwischen 0..9 immer aus 0x30 + Zahl. Das ist einfach. Und wie kommt man nun an die einzelnen Ziffern? Dazu wird eine MODULO Operation durchgeführt. Diese liefert den Rest einer ganzzahligen Division.

<pre>
28943 MOD 10 = 3
</pre>

Nun gehts an die nächste Stelle. Dazu wird die Zahl einfach durch 10 dividiert

<pre>
28943 / 10 = 2894
</pre>

Und nun das Spiel von vorn.

<pre>
2894 MOD 10 = 4
2894 / 10 = 289
289 MOD 10 = 9
289 / 10 = 28
28 MOD 10 = 8
28 / 10 = 2
2 MOD 10 = 2
</pre>

Das wars eigentlich schon. Beachtet werden muss nur, dass bei dieser Methode die einzelnen Stellen in umgekehrter Reihenfolge entstehen: Die höchstwertigen Stellen kommen erst zum Schluss.

Hier ist nun unsere erste einfache Funktion, um eine vorzeichenlose 32 Bit Zahl in einen String umzuwandeln. Diese kann maximal 10 Dezimalstellen haben (0..4294967295), also wird ein Speicher für 11 Bytes benötigt (letztes Byte für den Stringterminator). Bei dem Verfahren wird die Zahl rückwärts berechnet. Das muss bei der Ablage im Speicher berücksichtigt werden. Im Sinne der Verständlichkeit wurde bewusst auf Optimierungen und kompakt/kryptische Schreibweisen verzichtet. Der Syntax ist Standard-C und somit auf jedem Compiler nutzbar.

<c>
#include <stdint.h>
/*

Funktion zur Umwandlung einer vorzeichenlosen 32 Bit Zahl in einen String

*/

void my_uitoa(uint32_t zahl, char* string) {
int8_t i; // schleifenzähler

string[10]='\0'; // String Terminator
for(i=9; i>=0; i--) {
string[i]=(zahl % 10) +'0'; // Modulo rechnen, dann den ASCII-Code von '0' addieren
zahl /= 10;
}
}
</c>

Diese Funktion gibt auch führende Nullen aus. Das ist erstmal OK, denn so wissen wir immer wo unser gedachtes Komma ist. Bei der Ausgabe können die führenden Nullen unterdrückt werden. Wie das geht, wird weiter unten beschrieben.

Benötigt man neben der Ausgabe für vorzeichenlose (unsigned) Werte auch noch eine Funktion für vorzeichenbehaftete Werte, so ist auch dieses keine Hexerei. Dazu verwenden wir ein zusätzliches Byte im String um das Vorzeichen zu speichern. Der String muss nun also mindestens 12 Bytes Speicherplatz zur Verfügung stellen.

<c>
#include <stdint.h>
/*

Funktion zur Umwandlung einer vorzeichenbehafteten 32 Bit Zahl in einen String

*/

void my_itoa(int32_t zahl, char* string) {
uint8_t i;

string[11]='\0'; // String Terminator
if( zahl < 0 ) { // ist die Zahl negativ?
string[0] = '-';
zahl = -zahl;
}
else string[0] = ' '; // Zahl ist positiv

for(i=10; i>=1; i--) {
string[i]=(zahl % 10) +'0'; // Modulo rechnen, dann den ASCII-Code von '0' addieren
zahl /= 10;
}
}
</c>

== Beispiele ==

=== Digitaler Temperatursensor ===

Anstatt eines ADC-Wertes werden oft auch Digitalwerte von Temperatursensoren verarbeitet. Der Weg ist hier identisch. Allerdings hat man keine Referenzspannung oder Referenztemperatur. Das ist aber kein Beinbruch. Z.B. der LM74 hat eine Auflösung von 1/16°C = 0,0625°C. Um das Messergebnis ohne Verlust von Auflösung auszugeben könnte man als erstes den Digitalwert auf 1/100 °C umrechnen. Das geschieht mit der Multiplikation mit 6,25. Doch Stop, das ist ja schon wieder ne Gleitkommazahl. Doch kein Problem, wir wissen ja wie wir das Problem lösen. Wir schieben das Komma um zwei Stellen nach rechts und multiplizieren mit 625 und wissen, dass das Ergbniss nun in 1/10000°C vorliegt. Über den physikalischen Sinn dieser Auflösung müssen wir nicht nachdenken, wichtig ist für uns nur, dass jetzt die Zahl einfach per itoa() umwandelbar ist. Allgemein kann man folgenden Ablauf zur Berechnung des Korrekturfaktors angeben

* Den Korrekturfaktur K mit vollen Kommastellen berechnen, dabei ist die neue Auflösung sinnvollerweise eine Dezimalzahl ( 0,1; 0,001 etc.) und kleiner als die alte Auflösung.

<math>K = \frac{alte~Aufloesung}{neue~Aufloesung}</math>

* Den berechneten Korrekturfaktor solange mit 10 multiplizieren bis alle Nachkommastellen verschwunden sind bzw. durch Rundung ein akzeptabler Fehler entsteht. Für jede Multiplikation des Faktors mit 10 muss die neue Auflösung durch 10 dividiert werden.

<math>Temperatur = Sensorwert \cdot K</math>

Beispiel:

Alte Auflösung: 1/32°C 
Neue Auflösung: 1/100°C

<math>K = \frac{\frac{1}{32}}{\frac{1}{100}} = 3,125</math>

Der Korrekturfaktor 3,125 kann zweimal mit 10 multipliziert werden und dann auf 312 gerundet werden, das entspricht einem Rundungsfehler von gerade mal 1/624 = 0,16% ! Die neue Auflösung beträgt 1/10000°C. Wenn der Sensor nur 7 Bit Werte liefert kann das Ergebnis in einer 16 Bit Variablen gespeichert werden, darüber hinaus ist eine 32 Bit Variable notwendig.

=== ADC allgemein ===

Wenn man das obige ADC-Beispiel allgemein beschreiben will, dann gilt folgender Ablauf

* Korrekturfaktor mit vollen Kommastellen berechnen

<math>alte Aufloesung = \frac{Referenzspannung}{2^{Bitbreite_{ADC}}}</math>

<math>K = \frac{alte~Aufloesung}{neue~Aufloesung}</math>

* Den berechneten Korrekturfaktor K solange mit 10 multiplizieren bis alle Nachkommastellen verschwunden sind bzw. durch Rundung ein akzeptabler Fehler entsteht. Für jede Multiplikation des Faktors mit 10 muss die neue Auflösung durch 10 dividiert werden.

<math>Eingangsspannung = ADC \hbox{-} Wert \cdot K</math>

Beispiel:

Referenzspannung : 5V 
ADC Bitbreite : 10

<math>alte Aufloesung = \frac{5V}{2^{10}} = \frac{5}{1024} = 0,0048828125\,V</math>

neue Auflösung: 0,001 V = 1mV

<math>K = \frac{0,0048828125 V}{0,001V} = 4,8828125</math>

Der Korrekturfaktor 4,8828125 wird zweimal mit 10 multipliziert und dann auf 488 gerundet, das entspricht einem Rundungsfehler von gerade mal 0,05% ! Die neue Auflösung ist 0,00001 V = 10uV. Das Ergebnis muss in einer 32 Bit Variablen gespeichert werden, denn der grösste Messwert ergibt 1023*488 = 499224. Der Vorteil dieses allgemeinen Ansatzes ist vor allem, daß nur eine Multiplikation benötigt wird, im Gegensatz zu unserem allerersten Beispiel, welches eine Multiplikation und eine Division benötigt. Das spart einiges an Rechenzeit und Programmspeicherplatz.

== Ergebnis runden ==

Nach der Umrechung des ADC/Sensor-Wertes und dem Aufruf von my_uitoa() kann man sehr einfach eine Rundung durchführen. Dazu muss nur die erste Stelle, welche durch Rundung wegfallen soll, geprüft werden. Ist sie kleiner als der ASCII-Code von '5' (0x35) dann muss abgerundet werden, sprich alles bleibt wie es ist. Im anderen Fall muss aufgerundet werden, was bedeutet dass die letzte angezeigte Dezimalstelle um eins erhöht werden muss. Doch aufgepasst! Wenn z.B. in unserem String die Zahl 1995 steht und die letzte Stelle durch Rundung wegfallen soll, kommte es zum Übertrag. Die letzte 9 wird zur 0 + Übertrag. Die nächste linksstehende Stelle muss erhöht werden. Das ist "dummerweise" auch eine 9, also wieder ein Übertrag. Die letzte Ziffer ist 1, die wird nur auf zwei erhöht und der Übertrag endet.

Basierend auf unserer Funktion my_uitoa() soll hier eine einfache Rundungsfunktion gezeigt werden. Auch diese arbeitet mit einem 11 Byte String, welcher vorher durch my_uitoa erzeugt wurde.

<c>
#include <stdint.h>
/*

Funktion zur Rundung einer vorzeichenlosen 32 Bit Zahl im Stringformat

Parameter:

char* string: Zeiger auf String, welcher mit my_uitoa() erzeugt wurde
uint8_t digit: Offset im String, zeigt auf die Stelle welche zur Rundung ausgewertet werden soll
gültiger Wertebereich ist 1..9 !
Der Offset von 1 zeigt auf die zweite Stelle von links
Der Offset von 9 zeigt auf die letzte Stelle von links

*/

void my_round(char* string, uint8_t digit) {
uint8_t i;

if (string[digit]>='5') { // Aufrunden?
for(i=(digit-1); i>=0; i--) {
string[i] += 1; // Aufrunden
if (string[i]<='9')
break; // kein Übertrag, schleife verlassen
else
string[i]='0'; // Übertrag und Überlauf
}
}

for(i=digit; i<10; i++) string[i] ='0'; // gerundete Stellen auf Null setzen

}
</c>

Die Funktion ist auch auf einen String anwendbar, welcher mit my_itoa() erzeugt wurde (also vorzeichenbehaftete Zahlen). Allerdings muss der Funktion ein Pointer auf das zweite Byte (char) übergeben werden, da im ersten das Vorzeichen gespeichert ist. Das geschieht am einfachsten so.

<c>
my_round(my_sting+1, 5);
</c>

== Ergebnis ausgeben ==

Nun haben wir unseren Messwert in eine Zahl mit der richtigen Einheit umgewandelt und gerundet. Jetzt folgt der letzte Schritt, die Ausgabe auf einen UART oder LCD. Dazu ist es meist wünschenswert führende Nullen nicht anzuzeigen. Also anstatt 0095,89 will man 95,89 ausgeben. Bei negativen Zahlen kommt noch das Vorzeichen hinzu.

=== Ausgabe auf LCD (HD44780 & CO) ===

Zunächst wollen wir unsere Zahl auf einem LCD ausgeben. Dazu braucht man die entsprechende Funktion lcd_data(), wie sie z.B. im [[AVR-GCC-Tutorial#LCD_Ansteuerung]] zu finden ist.

<c>
#include <stdint.h>
/*

Funktion zur Anzeige einer 32 Bit Zahl im Stringformat
auf einem LCD mit HD44780 Controller

Parameter:

char* string : Zeiger auf String, welcher mit my_itoa() erzeugt wurde
uint8_t start : Offset im String, ab der die Zahl ausgegeben werden soll,
das ist notwenig wenn Zahlen mit begrenztem Zahlenbereich
ausgegeben werden sollen
Vorzeichenlose Zahlen : 0..10
Vorzeichenbehaftete zahlen : 1..11
uint8_t komma : Offset im String, zeigt auf die Stelle an welcher das virtuelle
Komma steht (erste Nachkommastelle)
komma muss immer grösser oder gleich start sein !

uint8_t frac : Anzahl der Nachkommastellen

*/

void my_print_LCD(char* string, uint8_t start, uint8_t komma, uint8_t frac) {

uint8_t i; // Zähler
uint8_t flag=0; // Merker für führende Nullen

// Vorzeichen ausgeben
if (string[0]=='-') lcd_data('-'); else lcd_data(' ');

// Vorkommastellen ohne führende Nullen ausgeben
for(i=start; i<komma; i++) {
if (flag==1 || string[i]!='0') {
lcd_data(string[i]);
flag = 1;
}
else lcd_data(' '); // Leerzeichen
}

lcd_data(','); // Komma ausgeben

// Nachkommastellen ausgeben
for(; i<(komma+frac); i++) lcd_data(string[i]);

}
</c>

Die Funktion gibt zunächst das Vorzeichen aus, das ist einfach. Danach werden die Vorkommastellen ausgegeben. Aber es wird nur dann ein Zeichen ausgegeben, wenn vorher schon mal eins ausgegeben wurde (flag ==1) oder das aktuelle Zeichen keine '0' ist. Danach werden ganz normal die Nachkommastellen ausgegeben, hier ist eine Unterdrückung führender Nullen sogar mathematisch falsch!

Genutzt wird die Funktion beispielsweise so, um dreistellige Zahlen bis 999 mit zwei Nachkommastellen auszugeben. Die Zahl selber hat sechs Nachkommastellen.

<c>
char my_string[12]="-0034567891\0";
my_print_LCD(my_string, 2, 5, 2);
</c>

Auf dem LCD erscheint dann
<pre>
- 34.56
</pre>

Diese Funktion kann auch verwendet werden, um vorzeichenlose Zahlen auszugeben, welche mit my_uitoa() erzeugt wurden. Da an der ersten Stelle nie ein '-' steht, wird auch nie ein '-' ausgegeben.

=== Ausgabe auf UART ===

Die Ausgabe auf einen UART ist nahezu identisch. Auch hier braucht man eine Funktion putc(), welche ein einzelnes Zeichen auf den UART schreiben kann wie z.B. im [[AVR-Tutorial:UART:GCC]] beschrieben ist. Der Unterschied zur LCD-Ausgabe besteht darin, dass zwischen dem Vorzeichen und der Zahl keinerlei Leerzeichen eingefügt werden.

<c>
#include <stdint.h>
/*

Funktion zur Ausgabe einer 32 Bit Zahl im Stringformat
auf den UART

Parameter:

char* string : Zeiger auf String, welcher mit my_itoa() erzeugt wurde
uint8_t start : Offset im String, ab der die Zahl ausgegeben werden soll,
das ist notwenig wenn Zahlen mit begrenztem Zahlenbereich
ausgegeben werden sollen
Vorzeichenlose Zahlen : 0..10
Vorzeichenbehaftete zahlen : 1..11
uint8_t komma : Offset im String, zeigt auf die Stelle an welcher das virtuelle
Komma steht (erste Nachkommastelle);
komma muss immer grösser oder gleich start sein !

uint8_t frac : Anzahl der Nachkommastellen

*/

void my_print_UART(char* string, uint8_t start, uint8_t komma, uint8_t frac) {

uint8_t i; // Zähler
uint8_t flag=0; // Merker für führende Nullen

// Vorkommastellen ohne führende Nullen ausgeben
for(i=start; i<komma; i++) {
if (flag==1 || string[i]!='0') {
if (flag==0 && string[0]=='-') putc('-'); // negatives Vorzeichen ausgeben
putc(string[i]);
flag = 1;
}
}

putc(','); // Komma ausgeben

// Nachkommastellen ausgeben
for(; i<(komma+frac); i++) putc(string[i]);
}
</c>

Diese Funktion kann auch verwendet werden, um vorzeichenlose Strings auszugeben, welche mit my_uitoa() erzeugt wurden. Da an der ersten Stelle nie ein '-' steht, wird auch nie ein '-' ausgegeben.

Diskussion:Festkommaarithmetik

2007-12-28T21:42:46Z

FalkB:

==Bezug zum AD=
> Wieso wird hier der AD-Wandler gebracht?

Weil das eine Standardanwendung ist! Es geht nach nicht um das Ansteuern das ADC sondern die Auswertung bzw. Darstellung des Ergebnisses.

> Ich hätte lieber eine Differenz geteilt durch ein Differenz.

???

> AD-Wandlung ist noch ein anderes Thema zumal man dort teilweise auch durch n-1 >dividieren muss und nicht pauschal druch die gesamte Wortbreite.

Das ist in der Formel enthalten. Ob man nun durch 256, 255 oder X dividiert ist egal. Es ist ein BEISPIEL und das Verfahren zu demonstrieren, keine starre Vorgabe.

==Spiegeln==
Was soll denn das mit dem Spiegeln des Strings? Das kostet nur Rechenzeit und Programmspeicher. Ich bin SEHR dafür, das KOMPLETT unter den Tisch fallen zu lassen. Ausserdem ist im Abschnitt ITOA selbst gemacht mal wieder einiges doppelt hingeschrieben worden (bitte die Artikel vorher mal in RUHE lesen). Wie z.B.

Das wars eigentlich schon.

" Beachtet werden muss nur, dass bei dieser Methode die einzelnen Stellen in umgekehrter Reihenfolge entstehen: Die höchstwertigen Stellen kommen erst zum Schluss."

Das steht doch quasi schon unten drin.

den Stringterminator). Bei dem Verfahren wird die Zahl rückwärts berechnet. Das muss bei der Ablage im Speicher berücksichtigt werden. Im Sinne der

----

Und auch hier ist der Unsinn drin. RAUS DAMIT!

Diskussion:Muluwuw

2007-12-28T21:39:42Z

FalkB:

Was soll der Unsinn? Das ist in AVR Arithmetik schon gut drin, eine Inline-ASM Version für C ist Nonsense. Ich beantrage Löschung.

AVR Checkliste

2007-12-26T22:54:58Z

FalkB: /* Sonstige Fehlerquellen bei UART/USART */

[[Category:AVR]]
Diese Seite soll als erste Anlaufstelle dienen, wenn der AVR-Mikrocontroller mal wieder nicht so will wie er soll. Es wird versucht, die Standardfehler aufzulisten und zu erklären, was man dagegen tun kann.

== Hardware ==

=== Anderen Controller benutzt als den im Schaltplan: Pinkompatibilität sichergestellt? ===

Nur wenige AVR-Controller sind pinkompatibel und damit untereinander austauschbar. Manchmal liegen gar die am dringensten benötigten Funktionen (ISP-Programmierung) bei anderen Controllern auf anderen Pins. Unbedingt vorher die Belegungen anhand der Datenblätter vergleichen!

=== Fuses richtig gesetzt? ===

Die AVR-Controller haben 'Fuses' (deutsch: 'Sicherungen'), die das Verhalten des Prozessors auf grundlegender Ebene bestimmen. Ein häufiger Fehler ist beispielsweise, dass die falsche Taktquelle gewählt wurde (Fuse "CKSEL" etc.): einige AVRs können mit dem internen Oszillator (internal R/C), mit einem externen Oszillator (external clock), mit einem Quarz (external crystal) oder mit einem Resonator (external R/C) betrieben werden. Wenn die Einstellung über die Fusebits nicht dazu passt (z. B. external clock statt external crystal), fehlt dem Controller unter Umständen der Systemtakt und er läuft nicht an, oder man bekommt auf der seriellen Schnittstelle Nonsens, oder die Timer bzw. Zeitschleifen im Programm laufen zu langsam oder zu schnell.

Eine andere Fuse (JTAGEN) schaltet auf einem Port (z.B. PORTC auf ATMega32) die JTAG-Unterstützung ein bzw. aus. Wenn sie eingeschaltet ist, funktionieren vier Bits dieses Ports nicht wie gewohnt, da sie für die JTAG-Schnittstelle reserviert werden.

In dem zum STK500 gehörenden Entwicklungstool 'AVR Studio' gibt es in der Programmer-Dialogbox einen Tab 'Fuses', der controllerabhängig den Status der Fusebits anzeigt und Änderungen ermöglicht.
Siehe auch: [[AVR Fuses]].

=== ISP-Adapter ===

Bei ISP-Programmieradaptern für den Parallelport kann es zu Inkompatibilitäten mit manchen Ports kommen. Tritt das Problem auch auf, wenn der ISP-Adapter an einem anderen Rechner angeschlossen ist? Funktioniert es vielleicht mit einer anderen Software? Siehe auch: [[AVR In System Programmer]]).

Bei seriellem Programmer mit Controller (STK500, Atmel AVRISP etc.): Programmieren dauert sehr lange, es gibt Fehler. Abhilfe: ISP Taktrate richtig einstellen (<1/4 F_CPU).

Beim Programmieren mit dem usbasp Programmieradapter muss die Geschwindigkeit richtig eingestellt werden. Bei einem AVR der auf den eingebauten 1 Mhz läuft muss mit langsamer Geschwindigkeit (Jumper zu) programmiert werden.

=== Spannungsversorgung richtig angeschlossen? ===

Der AVCC-Pin ist der Versorgungsanschluss für den AD-Wandler und den zugehörigen Port. Er ist nicht an allen AVRs vorhanden; wenn er aber vorhanden ist, so muss er auf jeden Fall angeschlossen sein, auch wenn der AD-Wandler nicht benutzt wird. Wird der AD-Wandler verwendet, sollte zur Verbesserung der Genauigkeit der AVCC-Pin über einen Lowpass-Filter angeschlossen werden (siehe Datenblatt).
Oft funktioniert die Programmierung des Controllers auch, wenn Vcc oder GND nicht richtig angeschlossen ist. Zur Sicherheit kann man mit einem Messgerät direkt an den Anschlüssen des AVRs kontrollieren (VCC-GND, AVCC-GND) prüfen, ob die Verbindungen korrekt sind. Es empfiehlt sich, vor dem Einsetzen bzw. Einlöten des Controllers die Versorgungsanschlüsse nochmals zu prüfen, um sicherzustellen, dass man den IC nicht durch eine zu hohe Spannung aufgrund eines Fehlers in der Versorgung zerstört.

=== Reset-Pin korrekt beschaltet? ===

Der Reset-Anschluss am AVR ist 'active-low', d. h. wenn man den Pin mit GND (Masse) verbindet, wird der Controller resettet. Zwar haben AVRs einen internen Pullup-Widerstand, der den Reset-Pin gegen VCC "zieht", dieser ist jedoch relativ hochohmig (ca. 50 kOhm, vgl. Datenblatt) und reicht unter Umständen nicht aus, um den Reset-Pin sicher "hochzuhalten". Als Mindestbeschaltung empfiehlt sich dringend, einen externen Pullup-Widerstand vorzusehen (typisch 10 kOhm), der den Reset-Pin mit VCC verbindet. Er sollte nicht kleiner als 4,7 kOhm sein, da der Programmieradapter sonst eventuell den Reset-Pin während des Programmiervorgangs nicht sicher auf "low" ziehen kann. Zusätzlich sollte man auch noch einen Kondensator 47 nF oder 100 nF zwischen Reset-Pin und GND anordnen. Dieses RC-Glied sorgt dafür, dass der Controller beim Einschalten der Versorgungsspannung für eine definierte Zeitspanne im Reset gehalten wird. Im laufenden Betrieb sorgt der Kondensator dafür, dass der Reseteingang unempfindlich gegenüber Spikes und Glitches wird. Er sollte deshalb unmittelbar in Pin-Nähe beim Prozessor untergebracht werden. Dieser Kondensator darf jedoch nicht verwendet werden, wenn DebugWire möglich sein soll.

Atmel empfiehlt zusätzlich noch zum Schutz vor Überspannungen eine externe Diode nach VCC ("Clamp-Diode"), da für den Reset-Pin keine interne vorhanden ist. Diese Diode bereitet jedoch bei manchen Programmieradaptern Schwierigkeiten.

=== Abblockkondensator(en) ordnungsgemäß installiert? ===

Abblockkondensatoren ("Bunker-Kondensatoren") dienen dazu, sehr kurze Versorgungsspannungseinbrüche, die durch Schaltvorgänge verursacht werden können, zu kompensieren. Diesen Zweck erfüllen sie optimal, wenn folgende Regeln eingehalten werden:

* Ein Abblockkondensator sollte möglichst dicht am IC sitzen.

* Jedes IC in einer Schaltung sollte einen Abblockkondensator besitzen.

* Bei ICs mit mehreren Anschlüssen für VCC und GND sollte jedes VCC-GND-Paar mit einem eigenen Abblockkondensator beschaltet werden (z. B. AVRs in SMD-Bauform wie dem ATmega16A also mit vier Kondensatoren).

* Es sollten keramische Kondensatoren mit einer Kapazität von 100 nF verwendet werden. Größere Kondensatoren, etwa 10 µF-Elkos, sind für diese Aufgabe ''nicht'' geeignet, weil sie "zu langsam" sind!

=== Quarz oder Quarzoszillator angeschlossen? ===

Die neueren AVRs haben einen internen [[Oszillator]], der im Auslieferungszustand über die entsprechenden Fuses eingeschaltet ist. In diesem Fall muss kein externer [[Quarz]] mehr angeschlossen werden. Man kann in den [[AVR Fuses|Fuse-Bits]] aber einstellen, dass man einen externen Taktgenerator (''external clock'', z. B. Quarzoszillator) oder externen Quarz (''external crystal'') verwenden möchte.

Dann, oder wenn der AVR keinen internen Takt hat, wird an die entsprechenden Pins des Controllers ein Quarz (''external crystal'', Bauelement mit zwei "Beinchen") oder Quarzoszillator (''external clock'', Bauelement mit vier "Beinchen") angeschlossen. Im Falle eines Quarzes werden die XTAL-Pins mit den beiden Anschlüssen des Quarzes und jeweils mit einem Kondensator (ca. 22 bis 27 pF) gegen Masse angeschlossen. Im Falle eines Quarzoszillators reicht es aus, den Taktausgang mit dem XTAL1-Pin zu verbinden, und den XTAL2-Pin unbeschaltet zu lassen. Die Fuses sind entsprechend einzustellen.

=== Alle Ground-Anschlüsse beschaltet? ===

Bei AVRs mit mehreren Ground-Anschlüssen müssen alle Anschlüsse beschaltet werden. Siehe http://www.mikrocontroller.net/forum/read-1-107259.html

=== Alle Lötstellen in Ordnung? ===

"Kalte", d.h. schlechte Lötstellen erkennt man an ihrer matten Oberfläche (bei bleihaltigem Lot). Bei beschädigten Lötstellen erkennt man oft einen Riss, der sich kreisförmig um die Mitte des Lötpunktes herum gebildet hat. Solche Stellen verursachen oft erst bei mechanischer Beanspruchung Probleme.

Bei kleinen Abständen (SMD-Bauteile) müssen besonders Verbindungen zwischen benachbarten Lötungen kontrolliert werden.

Bei Lochrasterplatinen kann man mit einem spitzen Messer (Bastelmesser) die Zwischenräume von möglichen leitenden Verbindungen befreien.

=== Eingänge ===

Taster müssen:

* entprellt werden ([[Entprellung]])

* einen [[AVR-GCC-Tutorial#Tasten_und_Schalter|Pullup-Widerstand]] besitzen, so sie ''active-low'' betrieben werden, d.h. wenn beim Tastendruck der Pin mit GND (Masse) verbunden wird (dies ist die übliche Anschaltung). Man kann einen externen Pull-Up Widerstand (typ. 10 kOhm) benutzen oder den internen aktivieren (DDR als Eingang also "0", PORT auf "1").

Will man einen Taster ''active-high'' betreiben, soll also bei Tastendruck eine "1" in PIN gelesen werden, ist ein externer Pull-Down-Widerstand (typ. 10 kOhm) gegen GND anzuschließen, denn interne Pull-Downs sind nicht verfügbar.

Symptome: Aufgrund des Prellens bekommt man bei einem Tastendruck statt eines Signals mehrere, und beim fehlenden Pullup fängt man sich Störungen (z.B. das 50 Hz-Netzbrummen) ein, da der Pin nicht auf einem "definierten Pegel" liegt, wenn der Taster nicht geschlossen ist. Soll z.B. bei einem Tastendruck eine LED angehen, dann leuchtet die LED durch das Netzbrummen plötzlich mit 50 Hz anstatt aus zu sein.

* active low: ein Anschluss des Tasters an den Port-Pin, den anderen Taster-Anschluss an GND; internen Pull-Up-Widerstand aktivieren oder externen Widerstand zwischen Port-Pin und VCC.

* active high: Taster zwischen Port-Pin und VCC; externen Widerstand zwischen Port-Pin und GND.

=== Ausgänge ===

Man sollte darauf achten, das "kritische" Ausgänge, d.h. Ausgänge, über die nicht "nur" eine LED geschaltet wird, einen definierten Zustand haben, wenn der Portpin auf "Eingang" und damit hochohmig geschaltet ist. Dadurch wird sichergestellt, dass beim Einschalten nicht kurz ein Verbraucher geschaltet wird (z.B. "Zucken" eines Motors). Dies kann man bewerkstelligen, indem man extern Widerstände (auch hier Pull-Up bzw. Pull-Down genannt, typ. 10 kOhm) an den Ausgangs-Pins vorsieht, die den Ausgang auf den gewünschten Zustand ziehen.

=== Besonderheiten bei ATmega64 / ATmega128 ===

Der ATmega64 und der ATmega128 haben zwei besondere Fallstricke, über die man bei nicht ausreichendem Datenblattstudium leicht stolpert.

* Der erste betrifft den Anschluss der ISP-Signale (MISO, MOSI, SCK, RESET). Dieser erfolgt nicht wie bei den meisten anderen AVR-Controllern an den gleichnamigen Pins, sondern an PDI, PDO, SCK und RESET. Die Pinzuordnung ist: MOSI->PE0 (Pin 2), MISO->PE1 (Pin 3), SCK->PB1 (Pin 11) und RESET->RESET (Pin 20). PEN (Pin 1) hat für normale ISP-Adapter keine Bedeutung und kann offen gelassen oder direkt mit Vcc verbunden werden. Die Benutzung der Pins PDI und PDO anstelle von MOSI und MISO gilt zusätzlich für einige ATMega128-Derivate im 64-Pin-TQFP-Gehäuse (darunter AT90CAN128, ATMega1281/2561)! Im Zweifelsfall im Datenblatt (Pin Configuration) nachsehen, ob PE0 und PE1 mit "PDI" bzw. "PDO" beschriftet sind.

* Die zweite kleine "Gemeinheit" betrifft die '''M103C-Fuse''' (Atmega103 Compatibility Mode). Diese ist bei fabrikneuen Atmega64 und Atmega128 gesetzt und sorgt dafür, dass sich diese wie ein Atmega103 verhalten.
** Andererseits hat dies zur Folge, dass ein für den Atmega64 oder Atmega128 geschriebenes Programm beim ersten "ret" abstürzt, da der SRAM an einer anderen Stelle liegt als erwartet und somit der Prozessor keine gültige Rücksprungadresse vom Stack holen kann.
** Außerdem funktionieren einige IO-Pins an PORTC, PORTF und PORTG anders.
** Für weitere Infos bzgl. [[TWI]], [[UART]], [[Timer]], [[Bootloader]] und Kalibrierung des internen RC-Oszillators unbedingt das Datenblatt lesen.

== Software ==

=== Alle Interruptvektoren definiert? ===

Wenn man irgendwelche [[Interrupt]]vektoren verwendet, sollte man alle definieren, auch die nicht benutzten. Passiert es dann aufgrund eines Fehlers, dass ein Interrupt unbeabsichtigt ausgeführt wird, so führt der Controller dann eine definierte Aktion aus. Benutzt man eine Hochsprache wie C oder Basic, nimmt einem der Compiler diese Arbeit ab.

Ausserdem sollte man immer im Datenblatt des Controllers nachsehen, wie die Interrupttabelle aufgebaut ist. Die kleinen AVRs verwenden ein '''RCALL''' zum Anspringen der Interrupts, welches 1 Wort lang ist. Die grossen AVRs mit mehr als 8 KiBi FLASH verwenden ein '''CALL''', welches 2 Worte lang ist. Verwendet man nun den falschen Befehl, verschieben sich die Einsprungadressen und das Chaos ist perfekt.

In einem komplett interruptlosen Programm kann man auf die Interrupttabelle selbstverständlich verzichten (erkennbar daran, dass nirgendwo im Code Interrupts mittels Assembler-Befehl '''sei''' eingeschaltet werden).

=== Alle Konfigurationsregister korrekt initialisiert? ===

Alle benötigten Konfigurationsregister (auch "I/O-Register" genannt) eines Mikrocontrollers müssen korrekt initialisiert werden. Bei Fehlfunktionen sollten diese Konfigurationen noch einmal mit dem Datenblatt abgeglichen werden.
Manchmal ist es auch sinnvoll, bestimmte Funktionen explizit abzuwählen. Ein Beispiel hierfür ist der [[Analog-Komparator]] des AVR: Schaltet man diesen ab, wenn man ihn nicht benötigt, kann man dadurch ein wenig Strom sparen.
Wenn man besonders "sauber" programmieren möchte, initialisiert man Konfigurationsregister immer, d.h. auch wenn sie nicht im Programm verwendet werden. Dies verhindert mögliche zufällige Fehlkonfigurationen.

=== Stackpointer initialisiert? (Nur in Assembler relevant) ===

Fehlerbeschreibung: ''Das Programm lief, bis ein "rcall" oder ein Interrupt eingefügt wurde. Danach ging plötzlich gar nichts mehr.''

Wahrscheinliche Ursache: Der Stack ist ein spezieller Bereich im RAM, der von Sprungbefehlen und Interruptaufrufen dazu verwendet wird, die Rücksprungadresse ins Hauptprogramm zu speichern. Da der Stack bei den AVRs nach "unten" wächst, d.h. in Richtung Anfang des RAMs, wird er üblicherweise ans Ende des RAMs gelegt. Der Stack muss vor der ersten Benutzung, am besten direkt am Anfang des Programms, initialisiert werden (sonst ist nach einem Sprung in ein Unterprogramm die Rücksprungadresse undefiniert und das Programm wird an einer unvorhersehbaren Stelle weiter ausgeführt, was in der Regel einen Absturz zur Folge hat). "Den Stack initialisieren" bedeutet, den Stackpointer auf den gewünschten "Startwert" zu setzen. Meistens wird dafür die letzte RAM-Adresse gewählt.

Die Initialisierung unterscheidet sich geringfügig je nach verwendetem AVR. Bei den alten AT90xxxx und den ATtinys ist sie mit zwei Zeilen erledigt:

<avrasm>
ldi r16, RAMEND ;Die Adresse der letzten Stelle im RAM in r16 laden
out SPL, r16 ;Die Adresse in das Register SPL ausgeben
</avrasm>

Da die ATmegas mehr RAM haben, reicht das 8 bit-Register SPL nicht mehr, und es ist ein zweites (SPH) dazugekommen. Die Initialisierung des Stacks erfordert hier vier Zeilen:

<avrasm>
ldi r16, LOW(RAMEND) ;Untere 8 bit des 16 bit-Wertes RAMEND laden
out SPL, r16
ldi r16, HIGH(RAMEND) ;Obere 8 bit laden
out SPH, r16
</avrasm>

=== 16bit-Register in richtiger Reihenfolge geladen/gelesen? (Nur in Assembler relevant) ===

Bei den 16-bit Registern (z.B. Timer1) genau die Hinweise im Kapitel "Accessing 16-bit Registers" beachten!

So muss z.B. das High-Byte VOR dem Low-Byte geschrieben werden, weil mit dem Schreiben des Low Byte das gesamte Register "übernommen" wird.
Beim Lesen muss zuerst das Low-Byte gelesen werden, dann das High-Byte.
Es wird dadurch garantiert, dass sich zwischen den beiden einzelnen Befehlen nicht noch das Register weiter verändert, z.B. beim 16bit Counter.
Möglich wird das durch ein "temporary Register", von dem es aber nur eines gibt - was beachtet werden muss, da zwischen diesen beiden einzelnen Lese-/Schreib-Befehlen kein Interrupt auftreten darf, der selber das temporary Rgegister benutzt.

In C oder Basic kümmert sich der Compiler um das Problem - man liest oder beschreibt dann einfach z.B. TCNT1 anstatt TCNT1H und TCNT1L einzeln.

=== Flag richtig gelöscht? ===

Ein beliebter Fehler ist, dass man überliest, dass gesetzte Flags (z.B. die Interrupt-Flags) durch beschreiben mit einer '1' und nicht mit einer '0' gelöscht werden!

Beispiel:
* das Flag ist zuerst '0'
* das Ereignis (z.B. Zählerüberlauf, also Bit TOV0 in TIFR) tritt auf und setzt das jeweilige Bit im Register auf '1'
* wir haben auf die '1' gewartet und wollen das Bit nun wieder löschen und müssen dafür eine '1' (eins!) in das Register schreiben, '''keine''' '0'. Trotzdem wird das Bit dadurch '0' z.B.:
<c>
TIFR = (1<<TOV0);
</c>

Das ganze ist kein Fehler, sondern hat seine guten Gründe.

Wenn Interrupts zugelassen sind (z.B. in TIMSK) und die Interruptroutine aufgerufen wird, werden diese Flags zumeist automatisch gelöscht.

Der UART-Empfangs-Interrupt (RXC in UCSRA) jedoch nicht! Der wird gelöscht durch Auslesen des Empfangsregisters (UDR). Hier liegt wiederum ein beliebter Stolperstein: Man prüft oft zuerst in der Interruptroutine die Fehlerflags (z.B. Parity) und macht dann manchmal den Fehler das empfangene Zeichen im Fehlerfall nicht auszulesen. Das führt dann zum Absturz (der IRQ wird immer wieder aufgerufen) - man muss also immer das UDR lesen auch wenn etwas Fehlerhaftes drinsteht.

Zusätzlich ist zu beachten, dass in C die Interrupt-Flags '''nicht''' mit einer Veroderung des Registers (z.B. TIFR |= (1 << TOV0)) gelöscht werden sollten, da bei dieser Operation alle anderen evtl. gesetzten Flags im betreffenden Register ebenfalls gelöscht werden. Es ist die Schreibweise von oben zu benutzen (also TIFR = (1 << TOV0))!

== Serielle Verbindungen ==

=== I²C/TWI ===

Sind die Leitungen SCL und SDA mit einem Pullup-Widerstand ausgestattet? Die I²C-Bus-Leitungen SCL und SDA müssen über einen Pullup-Widerstand mit einem Wert von 4,7 kOhm bis 10 kOhm mit der Versorgungsspannung (+5 V) verbunden sein.

=== UART/USART ===

==== Übertragungsprobleme durch falschen oder ungenauen Takt ====

* Der interne [[Oszillator]] ist recht ungenau und nicht temperaturstabil. Daher kann die Umgebungstemperatur auch den [[UART | USART]]-Takt verändern. Für serielle, asynchrone Kommunikation per UART sollte man deshalb immer einen Quarz(oszillator) verwenden, eagl bei welcher Baudrate (3% sind immer 3%, egal ob bei 1200 oder 9600 [[Baud]]). Falls doch der interne Oszillator verwendet wird, wurde er für die richtige Frequenz kalibriert?

* Nicht mit allen Quarzen kann man alle Baudraten genau genug erzeugen; deswegen gibt es [[Baudratenquarz]]e wie z.B. 3,6864 MHz. Näheres steht im Datenblatt.

* Geschieht die Konfiguration des U(S)ART automatisch durch die Programmiersprache (z.B. in [[Bascom AVR | BASCOM]]), dann muss dort der Takt '''genau''' angegeben werden. Setzt man z.B. einen 3,6864 MHz-Quarz ein, darf man dort nicht einfach "4 MHz" angeben, weil dann die Abweichung mit ca. 8% viel zu hoch wäre. Damit funktioniert die Übertragung nicht mehr.

* Wenn ein externer Oszillator oder Quarz angeschlossen ist: Sind die [[AVR Fuses | Fuses]] des Controllers so gesetzt, dass er auch verwendet wird?

* Um zu prüfen, ob der externe Quarz auch wirklich verwendet wird, kann man mittels _delay_ms() einfach mal eine LED im Sekundentakt blinken lassen. Den Unterschied zwischen Quarz und internem RC-Oszillator kann man bei grösseren Frequenzunterschieden leicht sehen. Allerdings muss man auch hier aufpassen. Siehe [[AVR-GCC-Tutorial#Warteschleifen_.28delay.h.29 |AVR-Tutorial]].

* Erscheinen im Terminalprogramm kryptische Zeichen anstatt ordentlichen Buchstaben (z.B. ü statt A), liegt das zu 99,9% an einer falsch eingestellten/erzeugten Baudrate im Mikrocontroller.

* In den Tutorials für [[AVR-Tutorial: UART |Assembler]] und [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Der_UART GCC] wird die Nutzung recht gut erklärt und mit Beispielen hinterlegt.

==== Sonstige Fehlerquellen bei UART/USART ====

* Funktioniert die Datenübertragung zum PC nur solange der Programmieradapter eingesteckt ist, deutet dies auf ein Problem mit der Masse hin (z.B. GND-Anschluss am RS232-Stecker nicht belegt oder dergleichen).

* Der Pegelwandler/Inverter (z.B. MAX232) muss mit Kondensatoren für die internen Ladungspumpen beschaltet werden. Beim MAX232 sind dies mindestens vier Kondensatoren >= 1 µF (Polung beachten!), beim MAX202 und MAX3232 vier Kondensatoren >= 100 nF. Hinzu kommt der obligatorische Abblockkondensator (100 nF keramisch) zwischen VCC und GND des ICs. Das jeweilige Datenblatt gibt Auskunft über die Beschaltung bei "typischer Anwendung".

* TX/RX vertauscht? Modem- oder Nullmodemkabel?

* Die Hardware und Verkabelung kann man schnell prüfen, indem man das Pin R1OUT bzw. R2OUT mit T1IN bzw. T2IN verbindet (je nachdem welches verwendet wird). Dann sollte man auf dem PC ein Terminalprogramm starten (z.B. Hyperterminal) und Zeichen eigeben können und sofort angezeigt bekommen, egal mit welcher Baudrate. Lediglich die Flusssteuerung muss auf "Kein" eingestellt werden. Man muss aber beachten, dass T1IN bzw. T2IN für diesen Test '''nicht''' mit dem Mikrocontroller verbunden sein darf, weil sonst zwei Ausgänge miteinander verbunden sind, was nicht wirklich gut ist (siehe [[Ausgangsstufen Logik-ICs]]). Wenn der uC gesockelt ist kann man ihn dafür einfach aus dem Sockel nehmen und die RX/TX Pins mit einem Stück Draht verbinden.

== Analog-Digital-Wandler ==

* Sind die Pullup-Widerstände deaktiviert?

== Web-Links ==
* [http://www.atmel.com/dyn/resources/prod_documents/doc2521.pdf Application Note AVR042: AVR Hardware Design Considerations]
* [http://www.atmel.com/dyn/resources/prod_documents/doc1619.pdf Application Note AVR040: EMC Design Considerations]

AVR-Tutorial: Uhr

2007-12-26T14:44:18Z

FalkB: Texte und Beispiele überarbeitet

Eine beliebte Übung für jeden Programmierer ist die Implementierung einer Uhr. Die meisten Uhren bestehen aus einem Taktgeber und einer Auswerte- und Anzeigevorrichtung. Wir wollen hier beides mittels eines Programmes in einem Mikrocontroller realisieren. Voraussetzung für diese Fallstudie ist das Verständnis der Kapitel über

* [[AVR-Tutorial: LCD| Ansteuerung eines LC-Displays]]
* [[AVR-Tutorial: Timer| Timer]]

== Aufbau und Funktion ==

Die Aufgabe des Taktgebers, der uns einen möglichst konstanten und genauen Takt liefert, übernimmt ein Timer. Der Timer ermöglicht einen einfachen Zugang zum Takt, die der AVR vom Quarz abgreift. Wie schon im Einführungskapitel über den [[AVR-Tutorial:_Timer|Timer]] wird dazu einen Timer Overflow Interrupt installiert und in diesem Interrupt wird die eigentliche Uhr hochgezählt. Die Uhr selbst besteht aus 4 Registern. 3 davon repräsentieren die Sekunden, Minuten und Stunden unserer Uhr. Nach jeweils einer Sekunde wird das Sekundenregister um 1 erhöht. Sind 60 Sekunden vergangen, dann wird das Sekundenregister wieder auf 0 gesetzt und dafür das Minutenregister um 1 erhöht (Überlauf). Nach 60 Minuten werden die Minuten wieder auf 0 gesetzt und für diese 60 Minuten eine Stunde mehr gezählt. Nach 24 Stunden schliesslich werden die Stunden wieder auf 0 gesetzt, ein ganzer Tag ist vergangen.

Aber wozu das 4. Register?

Der Mikrocontroller wird mit 4MHz betrieben. Bei einem Teiler von 1024 zählt der Timer also mit 4000000 / 1024 = 3906.25 Pulsen pro Sekunde. Der Timer muss einmal bis 256 zählen, bis er einen Overflow auslöst. Das heist, es ereignen sich 3906.25 / 256 = 15.2587 Overflows pro Sekunde. Die Aufgabe des 4. Registers ist es nun diese 15 Overflows zu zählen. Bei Auftreten des 15.ten Overflow ist 1 Sekunde vergangen. Dass dies nicht exakt stimmt, da ja die Division auch Nachkommastellen aufwies, wird im Moment der Einfachheit halber ignoriert. In einem späteren Abschnitt wird darauf noch eingegangen.

Im Overflow Interrupt wird also diese Kette von Zählvorgängen auf den Sekunden, Minuten und Stunden durchgeführt und anschliessend zur Anzeige gebracht. Dazu werden die in einem vorhergehenden Kapitel entwickelten [[AVR-Tutorial:_LCD|LCD Funktionen]] benutzt.

== Das erste Programm ==

<avrasm>
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18
.def flag = r19

.def SubCount = r21
.def Sekunden = r22
.def Minuten = r23
.def Stunden = r24

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp timer0_overflow ; Timer Overflow Handler

.include "lcd-routines.asm"

main:
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

rcall lcd_init
rcall lcd_clear

ldi temp1, 0b00000101 ; Teiler 1024
out TCCR0, temp1

ldi temp1, 0b00000001 ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp1

clr Minuten ; Die Uhr auf 0 setzen
clr Sekunden
clr Stunden
clr SubCount
clr Flag ; Merker löschen

sei

loop:
cpi flag,0
breq loop ; Flag im Interrupt gesetzt?
ldi flag,0 ; flag löschen

rcall lcd_clear ; das LCD löschen
mov temp1, Stunden ; und die Stunden ausgeben
rcall lcd_number
ldi temp1, ':' ; zwischen Stunden und Minuten einen ':'
rcall lcd_data
mov temp1, Minuten ; dann die Minuten ausgeben
rcall lcd_number
ldi temp1, ':' ; und noch ein ':'
rcall lcd_data
mov temp1, Sekunden ; und die Sekunden
rcall lcd_number

rjmp loop

timer0_overflow: ; Timer 0 Overflow Handler

push temp1 ; temp 1 sichern
in temp1,sreg ; SREG sichern

inc SubCount ; Wenn dies nicht der 15. Interrupt
cpi SubCount, 15 ; ist, dann passiert gar nichts
brne end_isr

; Überlauf
clr SubCount ; SubCount rücksetzen
inc Sekunden ; plus 1 Sekunde
cpi Sekunden, 60 ; sind 60 Sekunden vergangen?
brne Ausgabe ; wenn nicht kann die Ausgabe schon
; gemacht werden

; Überlauf
clr Sekunden ; Sekunden wieder auf 0 und dafür
inc Minuten ; plus 1 Minute
cpi Minuten, 60 ; sind 60 Minuten vergangen ?
brne Ausgabe ; wenn nicht, -> Ausgabe

; Überlauf
clr Minuten ; Minuten zurücksetzen und dafür
inc Stunden ; plus 1 Stunde
cpi Stunden, 24 ; nach 24 Stunden, die Stundenanzeige
brne Ausgabe ; wieder zurücksetzen

; Überlauf
clr Stunden ; Stunden rücksetzen

Ausgabe:
ldi flag,1 ; Flag setzen, LCD updaten

end_isr:

out sreg,temp1 ; sreg wieder herstellen
pop temp1
reti ; das wars. Interrupt ist fertig

; Eine Zahl aus dem Register temp1 ausgeben

lcd_number:
push temp2 ; register sichern,
; wird für Zwsichenergebnisse gebraucht
ldi temp2, '0'
lcd_number_10:
subi temp1, 10 ; abzählen wieviele Zehner in
brcs lcd_number_1 ; der Zahl enthalten sind
inc temp2
rjmp lcd_number_10
lcd_number_1:
rcall lcd_data ; die Zehnerstelle ausgeben
subi temp1, -10 ; 10 wieder dazuzählen, da die
; vorhergehende Schleife 10 zuviel
; abgezogen hat
; das Subtrahieren von -10
; = Addition von +10 ist ein Trick
; da kein addi Befehl existiert
ldi temp2, '0' ; die übrig gebliebenen Einer
add temp1, temp2 ; noch ausgeben
rcall lcd_data

pop temp2 ; Register wieder herstellen
ret
</avrasm>

In der ISR wird nur die Zeit in den Registern neu berechnet, die Ausgabe auf das LCD erfolgt in der Hauptschleife. Das ist notwendig, da die LCD-Ausgabe bisweilen sehr lange dauern kann. Wenn sie länger als ~2/15 Sekunden dauert werden Timerinterrupts "verschluckt" und unsere Uhr geht noch mehr falsch. Dadurch, dass aber die Ausgabe in der Hauptschleife durchgeführt wird, welche jederzeit durch einen Timerinterrupt unterbrochen werden kann, werden keine Timerinterrupts verschluckt. Das ist vor allem wichtig, wenn mit höheren Interruptfrequenzen geabreitet wird, z.B. 1/100s im Beispiel weiter unten. Auch wenn in diesem einfachen Beispiel die Ausgabe bei weitem nicht 2/15 Sekunden dauert, sollte man sich diesen Programmierstil allgemein angewöhnen. Siehe auch [[Interrupt]].

Im Moment gibt es keine Möglichkeit, die Uhr auf eine bestimmte Uhrzeit einzustellen. Um dies tun zu können müssten noch zusätzlich Taster an den Mikrocontroller angeschlossen werden, mit deren Hilfe die Sekunden, Minuten und Stunden händisch vergrößert bzw. verkleinert werden können. Studieren Sie mal die Bedienungsanleitung einer käuflichen Digitaluhr und versuchen sie zu beschreiben, wie dieser Stellvorgang bei dieser Uhr vor sich geht. Sicherlich werden Sie daraus eine Idee entwickeln können, wie ein derartiges Stellen mit der hier vorgestellten Digitaluhr funktionieren könnte. Als Zwischenlösung kann man im Programm die Uhr beim Start anstelle von 00:00:00 z.B. auch auf 20:00:00 stellen und exakt mit dem Start der Tagesschau starten.

== Ganggenauigkeit ==

Wird die Uhr mit einer gekauften Uhr verglichen, so stellt man schnell fest, dass die ganz schön ungenau geht. Sie geht vor! Woran liegt das? Die Berechnung sieht so aus:
* Frequenz des Quarzes: 4.0 MHz
* Vorteiler des Timers: 1024
* Überlauf alle 256 Timertakte

Daraus errechnet sich, daß in einer Sekunde 4000000 / 1024 / 256 = 15.258789 Overflow Interrupts auftreten. Im Programm wird aber bereits nach 15 Overflows eine Sekunde weitergeschaltet, daher geht die Uhr vor. Rechnen wir etwas:

:<math>F_r = (\frac {15}{15,258789}-1) \cdot 100% = -1,69%</math>

So wie bisher läuft die Uhr also rund 1.7 % zu schnell. In einer Minute ist das immerhin etwas mehr als eine Sekunde. Im Grunde ist das ein ähnliches Problem wie mit unserer Jahreslänge. Ein Jahr dauert nicht exakt 365 Tage, sondern in etwa einen viertel Tag länger. Die Lösung, die im Kalender dafür gemacht wurde - der Schalttag -, könnte man fast direkt übernehmen. Nach 3 Stück 15er Overflow Sekunden folgt eine Sekunde für die 16 Overflows ablaufen müssen. Wie sieht die Rechnung bei einem 15, 15, 15, 16 Schema aus? Für 4 Sekunden werden exakt 15.258789 * 4 = 61,035156 Overflow Interrupts benötigt. Mit einem 15, 15, 15, 16 Schema werden in 4 Sekunden genau 61 Overflow Interrupts durchgeführt. Der relative Fehler beträgt dann

:<math>F_r = (\frac {61}{61,035156}-1) \cdot 100% = -0,0575%</math>

Mit diesem Schema ist der Fehler beträchtlich gesunken. Nur noch 0.06%. Bei dieser Rate muss die Uhr immerhin etwas länger als 0,5 Stunden laufen, bis der Fehler auf eine Sekunde angewachsen ist. Das sind aber immer noch 48 Sekunden pro Tag bzw. 1488 Sekunden (=24,8 Minuten) pro Monat. So schlecht sind nicht mal billige mechanische Uhren!

Jetzt könnte man natürlich noch weiter gehen und immer kompliziertere "Schalt-Overflow"-Schemata austüfteln und damit die Genauigkeit näher an 100% bringen. Aber gibt es noch andere Möglichkeiten?

Im ersten Ansatz wurde ein Vorteiler von 1024 eingesetzt. Was passiert bei einem anderen Vorteiler? Nehmen wir mal einen Vorteiler von 64. Das heist, es müssen ( 4000000 / 64 ) / 256 = 244.140625 Overflows auflaufen bis 1 Sekunde vergangen ist. Wenn also 244 Overflows gezählt werden, dann beläuft sich der Fehler auf

:<math>F_r = (\frac {244}{244,140625}-1) \cdot 100% = -0,0576%</math>

Nicht schlecht. Nur durch Verändern von 2 Zahlenwerten im Programm (Teilerfaktor und Anzahl der Overflow Interrupts bis zu einer Sekunden) kann die Genauigkeit gegenüber dem ursprünglichen Overflow-Schema beträchtlich gesteigert werden. Aber geht das noch besser? Ja das geht. Allerdings nicht mit dem Overflow Interrupt.

== Der CTC Modus des Timers ==

Worin liegt den das eigentliche Problem, mit dem die Uhr zu kämpfen hat? Das Problem liegt darin, dass jedesmal ein kompletter Timerzyklus bis zum Overflow abgewartet werden muss, um darauf zu reagieren. Da aber nur jeweils ganzzahlige Overflowzyklen abgezählt werden können, heisst das auch, dass im ersten Fall nur in Vielfachen von 1024 * 256 = 262144 Takten operiert werden kann, während im letzten Fall immerhin schon eine Granulierung von 64 * 256 = 16384 Takten erreicht wird. Aber offensichtlich ist das nicht genau genug. Bei 4 MHz entsprechen 262144 Takte bereits einem Zeitraum von 65,5ms, während 16384 Takte einem Zeitbedarf von 4,096ms entsprechen. Beide Zahlen teilen aber 1000ms nicht ganzzahlig. Und daraus entsteht der Fehler. Angestrebt wird ein Timer der seinen Overflow so erreicht, dass sich ein ganzzahliger Teiler von 1 Sekunde einstellt. Dazu müssten man dem Timer aber vorschreiben können, bei welchem Zählerstand der Overflow erfolgen soll. Und genau dies ist im '''CTC''' Modus, allerdings nur beim Timer 1, möglich. '''CTC''' bedeutet "'''C'''lear '''T'''imer on '''C'''ompare match".

Timer 1, ein 16 Bit Timer, wird mit einem Vorteiler von 1 betrieben. Dadurch wird erreicht, dass der Timer mit höchster Zeitauflösung arbeiten kann. Bei jedem Ticken des Systemtaktes von 4 MHz wird auch der Timer um 1 erhöht. Zusätzlich wird noch das WGM12 Bit bei der Konfiguration gesetzt. Dadurch wird der Timer in den '''CTC''' Modus gesetzt. Dabei wird der Inhalt des Timers hardwaremäßig mit dem Inhalt des '''OCR1A''' Registers verglichen. Stimmen beide überein, so wird der Timer auf 0 zurückgesetzt und im nächsten Taktzyklus ein '''OCIE1A''' Interrupt ausgelöst. Dadurch ist es möglich exakt die Anzahl an Taktzyklen festzulegen, die von einem Interrupt zum nächsten vergehen sollen. Das Compare Register '''OCR1A''' wird mit dem Wert 39999 vorbelegt. Dadurch vergehen exakt 40000 Taktzyklen von einem Compare Interrupt zum nächsten. "Zufällig" ist dieser Wert so gewählt, daß bei einem Systemtakt von 4 MHz von einem Interrupt zum nächsten genau 1 hunderstel Sekunde vergeht. Bei einem möglichen Umbau der Uhr zu einer Stoppuhr könnte sich das als nützlich erweisen. Im Interrupt wird das Hilfsregister SubCount bis 100 hochgezählt und nach 100 Interrupts kommt wieder die Sekundenweiterschaltung wie oben in Gang.

<avrasm>
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18
.def Flag = r19

.def SubCount = r21
.def Sekunden = r22
.def Minuten = r23
.def Stunden = r24

.org 0x0000
rjmp main ; Reset Handler
.org OC1Aaddr
rjmp timer1_compare ; Timer Compare Handler

.include "lcd-routines.asm"

main:
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

rcall lcd_init
rcall lcd_clear

; Vergleichswert
ldi temp1, high( 40000 - 1 )
out OCR1AH, temp1
ldi temp1, low( 40000 - 1 )
out OCR1AL, temp1
; CTC Modus einschalten
; Vorteiler auf 1
ldi temp1, ( 1 << WGM12 ) | ( 1 << CS10 )
out TCCR1B, temp1

ldi temp1, 1 << OCIE1A ; OCIE1A: Interrupt bei Timer Compare
out TIMSK, temp1

clr Minuten ; Die Uhr auf 0 setzen
clr Sekunden
clr Stunden
clr SubCount
clr Flag ; Flag löschen

sei
loop:
cpi flag,0
breq loop ; Flag im Interrupt gesetzt?
ldi flag,0 ; Flag löschen

rcall lcd_clear ; das LCD löschen
mov temp1, Stunden ; und die Stunden ausgeben
rcall lcd_number
ldi temp1, ':' ; zwischen Stunden und Minuten einen ':'
rcall lcd_data
mov temp1, Minuten ; dann die Minuten ausgeben
rcall lcd_number
ldi temp1, ':' ; und noch ein ':'
rcall lcd_data
mov temp1, Sekunden ; und die Sekunden
rcall lcd_number

rjmp loop

timer1_compare: ; Timer 1 Output Compare Handler

push temp1 ; temp 1 sichern
in temp1,sreg ; SREG sichern

inc SubCount ; Wenn dies nicht der 100. Interrupt
cpi SubCount, 100 ; ist, dann passiert gar nichts
brne end_isr

; Überlauf
clr SubCount ; SubCount rücksetzen
inc Sekunden ; plus 1 Sekunde
cpi Sekunden, 60 ; sind 60 Sekunden vergangen?
brne Ausgabe ; wenn nicht kann die Ausgabe schon
; gemacht werden

; Überlauf
clr Sekunden ; Sekunden wieder auf 0 und dafür
inc Minuten ; plus 1 Minute
cpi Minuten, 60 ; sind 60 Minuten vergangen ?
brne Ausgabe ; wenn nicht, -> Ausgabe

; Überlauf
clr Minuten ; Minuten zurücksetzen und dafür
inc Stunden ; plus 1 Stunde
cpi Stunden, 24 ; nach 24 Stunden, die Stundenanzeige
brne Ausgabe ; wieder zurücksetzen

; Überlauf
clr Stunden ; Stunden rücksetzen

Ausgabe:
ldi flag,1 ; Flag setzen, LCD updaten

end_isr:

out sreg,temp1 ; sreg wieder herstellen
pop temp1
reti ; das wars. Interrupt ist fertig

; Eine Zahl aus dem Register temp1 ausgeben

lcd_number:
push temp2 ; register sichern,
; wird für Zwsichenergebnisse gebraucht
ldi temp2, '0'
lcd_number_10:
subi temp1, 10 ; abzählen wieviele Zehner in
brcs lcd_number_1 ; der Zahl enthalten sind
inc temp2
rjmp lcd_number_10
lcd_number_1:
rcall lcd_data ; die Zehnerstelle ausgeben
subi temp1, -10 ; 10 wieder dazuzählen, da die
; vorhergehende Schleife 10 zuviel
; abgezogen hat
; das Subtrahieren von -10
; = Addition von +10 ist ein Trick
; da kein addi Befehl existiert
ldi temp2, '0' ; die übrig gebliebenen Einer
add temp1, temp2 ; noch ausgeben
rcall lcd_data

pop temp2 ; Register wieder herstellen
ret
</avrasm>

In der Interrupt Routine werden wieder, genauso wie vorher, die Anzahl der Interrupt Aufrufe gezählt. Beim 100. Aufruf sind daher 40.000 * 100 = 4.000.000 Takte vergangen und da der Quarz mit 4.000.000 Schwingungen in der Sekunde arbeitet, ist daher eine Sekunde vergangen. Sie wird genauso wie vorher registriert und die Uhr entsprechend hochgezählt. Wird jetzt die Uhr mit einer kommerziellen verglichen, dann fällt nach einiger Zeit auf ... Sie geht immer noch falsch! Was ist jetzt die Ursache? Die Ursache liegt in einem Problem, das nicht direkt behebbar ist. Am Quarz! Auch wenn auf dem Quarz drauf steht, dass er eine Frequenz von 4MHz hat, so stimmt das nicht exakt. Auch Quarze haben Fertigungstoleranzen verändern ihre Frequenz mit der Temperatur. Typisch liegt die Fertigungstoleranz bei +/- 100ppm = 0,01% ('''p'''arts '''p'''er '''m'''illion, Millionstel Teile), die Temperaturdrift zwischen -40 Grad und 85 Grad liegt je nach Typ in der selben Grössenordnung. Das bedeutet, dass die Uhr pro Monat um bis zu 268 Sekunden (~4 1/2 Minuten) falsch gehen kann. Diese Einflüsse auf die Quarzfrequenz sind aber messbar und per Hardware oder Software behebbar. In Uhren kommen normalerweise genauer gefertigte Uhrenquarze zum Einsatz, die vom Uhrmacher auch noch auf die exakte Frequenz abgeglichen werden (mittels Kondensatoren und Frequenzzähler). Ein Profi verwendet einen sehr genauen Frequenzzähler, womit er innerhalb weniger Sekunden die Frequenz sehr genau messen kann. Als Hobbybastler kann man die Uhr eine zeitlang (Tage, Wochen) laufen lassen und die Abweichung feststellen (z.B. exakt 20:00 Uhr zum Start der Tagsschau). Aus dieser Abweichung lässt sich dann errechnen wie schnell der Quarz wirklich schwingt. Und da dank CTC die Messperiode taktgenau eingestellt werden kann, ist es möglich diesen Frequenzfehler auszugleichen. Der genaue Vorgang ist in dem Wikiartikel [[AVR_-_Die_genaue_Sekunde_/_RTC]] beschrieben.

{{Navigation_zurückhochvor|
zurücktext=Timer|
zurücklink=AVR-Tutorial: Timer|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=ADC|
vorlink=AVR-Tutorial: ADC}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: ADC

2007-12-26T11:22:26Z

FalkB: Zweites Beispiel angefügt

== Was macht der ADC? ==

Wenn es darum geht Spannungen zu messen, wird der [[ADC | '''A'''nalog '''D'''igital '''C'''onverter]] benutzt. Er konvertiert eine elektrische Spannung in eine Digitalzahl. Diese kann dann in gewohnter Weise von einem [[Mikrocontroller]] weiterverarbeitet werden.

== Elektronische Grundlagen ==

Natürlich kann der ADC nicht beliebig hohe Spannungen verarbeiten. Die Grenze, bis zu der der ADC arbeitet ohne Schaden zu nehmen, liegt bei der analogen Versorgungsspannung (AVcc). Die ADC-Eingangsspannung darf diese maximal um 0.5 Volt überschreiten. Wird der Mikrocontroller also mit 5 Volt betrieben, so liegt die maximale Eingangsspannung bei ca. 5.5 Volt.

Der Eingangswiderstand des ADC liegt in der Größenordnung von einigen Megaohm, so dass der ADC die Sgnalquelle praktisch nicht belastet. Desweiteren enthält der Mikrocontroller eine sog. '''Sample&Hold''' Schaltung. Dies ist wichtig, wenn sich während des Wandlungsvorgangs die Eingangsspannung verändert, da die AD-Wandlung eine bestimmte Zeit dauert. Die Sample&Hold-Stufe speichert zum Beginn der Wandlung die anliegende Spannung und hält sie während des Wandlungsvorgangs konstant.

=== Beschaltung des ADC-Eingangs ===

Um den ADC im Folgenden zu testen wird eine einfache Schaltung an den PC0-Pin des ATmega8 angeschlossen. Dies ist der ADC-Kanal 0. Bei anderen AVR-Typen liegt der entsprechende Eingang auf einem andern Pin, hier ist ein Blick ins Datenblatt angesagt.

[[Bild:Tut_ADC_01.gif]]

Der Wert des [[Potentiometer]]s ist Dank des hohen Eingangswiderstandes des ADC ziemlich unkritisch. Es kann jedes Potentiometer von 1kΩ bis 1MΩ benutzt werden.

Wenn andere Messgrößen gemessen werden sollen, so bedient man sich oft und gern des Prinzips des [[Spannungsteiler]]s. Der Sensor ist ein veränderlicher Widerstand. Zusammen mit einem zweiten, konstanten Widerstand bekannter Größe wird ein Spannungsteiler aufgebaut. Aus der Variation der durch den variablen Spannungsteiler entstehenden Spannung kann auf den Messwert zurückgerechnet werden.

Vcc ----------+ Vcc ---------+
| |
--- Sensor,
| | der seinen Widerstand
| | in Abhängigkeit der
--- Messgröße ändert
| |
+------- PC0 +-------- PC0
| |
Sensor, ---
der seinen Widerstand | |
in Abhängigkeit der | |
Messgröße ändert ---
| |
GND ---------+ GND --------+

Die Größe des zweiten Widerstandes im Spannungsteiler richtet sich nach dem Wertebereich, in dem der Sensor seinen Wert ändert. Als Daumenregel kann man sagen, dass der Widerstand so gross sein sollte wie der Widerstand des Sensors in der Mitte des Messbereichs.

Beispiel: Wenn ein Temperatursensor seinen Widerstand von 0..100 Grad von 2kΩ auf 5kΩ ändert, sollte der zweite Widerstand eine Grösse von etwa (2+5)/2 = 3,5kΩ haben.

===Referenzspannung AREF===

Der ADC benötigt für seine Arbeit eine Referenzspannung. Dabei gibt es 2 Möglichkeiten:
* interne Referenzspannung
* externe Referenzspannung

==== Interne Referenzspannung ====

Mittels Konfigurationsregister können beim ATmega8 verschiedene Referenzspannungen eingestellt werden. Dies umfasst die Versorungsspannung AVcc sowie eine vom AVR bereitgestellte Spannung von 2,56V (bzw. bei den neueren AVRs 1,1V, wie z.B. beim ATtiny13, ATmega48, 88, 168, ...). In beiden Fällen wird an den AREF-Pin des Prozessors ein Kondensator von 100nF als Minimalbeschaltung nach Masse angeschlossen, um die Spannung zu puffern/glätten.

==== Externe Referenzspannung ====

Wird eine externe Referenz verwendet, so wird diese an AREF angeschlossen. Aber aufgepasst! Wenn eine Referenz in Höhe der Versorgungsspannung benutzt werden soll, so ist es besser dies über die interne Referenz zu tun. Ausser bei anderen Spannungen als 5V bzw. 2,56V gibt es eigentlich keinen Grund an AREF eine Spannungsquelle anzuschliessen. In Standardanwendungen fährt man immer besser wenn die interne Referenzspannung mit einem Kondensator an AREF benutzt wird.

== Ein paar ADC-Grundlagen ==

Der ADC ist ein 10-Bit ADC, d.h. er liefert Messwerte im Bereich 0 bis 1023. Liegt am Eingangskanal 0V an, so liefert der ADC einen Wert von 0. Hat die Spannung am Eingangskanal die Referenzspannung erreicht (stimmt nicht ganz), so liefert der ADC einen Wert von 1023. Unterschreitet oder überschreitet die zu messende Spannung diese Grenzen, so liefert der ADC 0 bzw. 1023. Wird die Auflösung von 10 Bit nicht benötigt, so ist es möglich die Ausgabe durch ein Konfigurationsregister so einzuschränken, dass ein leichter Zugriff auf die 8 höchstwertigen Bits möglich ist.

Wie bei vielen analogen Schaltungen, unterliegt auch der ADC einem Rauschen. Das bedeutet, dass man nicht davon ausgehen sollte, dass der ADC bei konstanter Eingangsspannung auch immer denselben konstanten Wert ausgibt. Ein "Zittern" der niederwertigsten 2 Bits ist durchaus nicht ungewöhnlich. Besonders hervorgehoben werden soll an dieser Stelle nochmals die Qualität der Referenzspannung. Diese Qualität geht in erheblichem Maße in die Qualität der Wandelergebnisse ein. Die Beschaltung von AREF mit einem Kondensator ist die absolut notwendige Mindestbeschaltung, um eine einigermaßen akzeptable Referenzspannung zu erhalten. Reicht dies nicht aus, so kann die Qualität einer Messung durch Oversampling erhöht werden. Dazu werden mehrere Messungen gemacht und deren Mittelwert gebildet.

Oft interessiert auch der absolute Spannungspegel nicht. Im Beschaltungsbeispiel oben ist man normalerweise nicht direkt an der am Poti entstehenden Spannung interessiert. Viel mehr ist diese Spannung nur ein notwendiges Übel, um die Stellung des Potis zu bestimmen. In solchen Fällen kann die Poti-Beschaltung wie folgt abgewandelt werden:

[[Bild:Tut_ADC_03.gif]]

Hier wird AREF (bei interner Referenz) als vom µC gelieferte Spannung benutzt und vom Spannungsteiler bearbeitet wieder an den µC zur Messung zurückgegeben. Dies hat den Vorteil, dass der Spannungsteiler automatisch Spannungen bis zur Höhe der Referenzspannung ausgibt, ohne dass eine externe Spannung mit AREF abgeglichen werden müsste. Selbst Schwankungen in AREF wirken sich hier nicht mehr aus, da ja das Verhältnis der Spannungsteilerspannung zu AREF immer konstant bleibt (ratiometrische Messung). Und im Grunde bestimmt der ADC ja nur dieses Verhältnis. Wird diese Variante gewählt, so muss berücksichtigt werden, dass die Ausgangsspannung an AREF nicht allzusehr belastet wird. Der Spannungsteiler muss einen Gesamtwiderstamd von deutlich über 10kΩ besitzen. Werte von 100kΩ oder höher sind anzustreben. Verwendet man anstatt AREF AVCC und schaltet auch die Referenzspannung auf AVCC um, ist die Belastung durch den Poti unkritisch, weil hier die Stromversorgung direkt zur Speisung verwendet wird.

Ist hingegen die absolute Spannung von Interesse, so muss man darauf achten, dass ein ADC in [[Digital | digitalen]] Bereichen arbeitet ([[Quantisierung]]). An einem einfacheren Beispiel soll demonstriert werden was damit gemeint ist.

Angenommen der ADC würde nur 5 Stufen auflösen können und AREF sei 5V:

Volt Wert vom ADC

0 -+
| 0
1 -+
| 1
2 -+
| 2
3 -+
| 3
4 -+
| 4
5 -+

Ein ADC Wert von 0 bedeutet also keineswegs, dass die zu messende Spannung exakt den Wert 0 hat. Es bedeutet lediglich, dass die Messspannung irgendwo im Bereich von 0V bis 1V liegt. Sinngemäß bedeutet daher auch das Auftreten des Maximalwertes nicht, dass die Spannung exakt AREF beträgt, sondern lediglich, dass die Messspannung sich irgendwo im Bereich der letzten Stufe (also von 4V bis 5V) bewegt.

== Umrechnung des ADC Wertes in eine Spannung ==

Die Größe eines "Bereiches" bestimmt sich also zu

<math>
Bereichsbreite = \frac {Referenzspannung}{Maximalwert + 1}
</math>

Der Messwert vom ADC rechnet sich dann wie folgt in eine Spannung um:

<math>
Spannung = ADCwert \cdot \frac {Referenzspannung} {Maximalwert + 1}
</math>

Wird der ADC also mit 10 Bit an 5 V betrieben, so lauten die Umrechnungen:

<math>
Spannung = ADCwert \cdot \frac{5}{1024}
</math>

<math>
Bereichsbreite = \frac{5}{1024} = 0,004883V = 4,883mV
</math>

Wenn man genau hinsieht stellt man fest, daß sowohl die Referenzspannung als auch der Maximalwert Konstanten sind. D.h. der Quotient aus Referenzspannung und Maximalwert+1 ist konstant. Somit muss nicht immer eine Multiplikation und Division ausgeführt werden, sondern nur eine Multiplikation! Das spart viel Aufwand und Rechenzeit! Dabei kommt [[Festkommaarithmetik]] zum Einsatz.

== Die Steuerregister des ADC ==

=== ADMUX ===

+-------+-------+-------+-------+-------+-------+-------+-------+
| REFS1 | REFS0 | ADLAR | | MUX3 | MUX2 | MUX1 | MUX0 |
+-------+-------+-------+-------+-------+-------+-------+-------+

* Referenzspannung REFS1, REFS0

<table border="0">
<tr>
<th align="left">REFS1</th><th align="left">REFS0</th><th align="left">Referenz</th>
</tr>
<tr>
<td>0</td><td>0</td><td>externe Referenz</td>
</tr>
<tr>
<td>0</td><td>1</td><td>interne Referenz: Avcc</td>
</tr>
<tr>
<td>1</td><td>0</td><td>wird beim Mega8 nicht benutzt</td>
</tr>
<tr>
<td>1</td><td>1</td><td>interne Referenz: 2.56 Volt</td>
</tr>
</table>

* Ausrichtung ADLAR
<table border="0">
<tr>
<th align="left">ADLAR</th><th align="left"></th>
</tr>
<tr>
<td>0</td><td>Das Ergebnis wird in den Registern ADCH/ADCL rechtsbündig ausgerichtet. Die 8 niederwertigsten Bits des Ergebnisses werden in ADCL abgelegt. Die verbleibenden 2 Bits des Ergebnisses werden im Register ADCH in den Bits 0 und 1 abgelegt.</td>
</tr>
<tr>
<td>1</td><td>Das Ergebnis wird in den Registern ADCH/ADCL linksbündig ausgerichtet. Die 8 höchstwertigen Bits des Ergebnisses werden in ADCH abgelegt. Die verbleibenden 2 niederwertigen Bits werden im Register ADCL in den Bits 6 und 7 abgelegt.</td>
</tr>
</table>

* Kanalwahl MUX3, MUX2, MUX1, MUX0
<table border="0">
<tr>
<th align="left">MUX3</th><th align="left">MUX2</th><th align="left">MUX1</th><th align="left">MUX0</th><th align="left">Kanal</th>
</tr>
<tr>
<td>0</td><td>0</td><td>0</td><td>0</td><td>Kanal 0, Pin PC0</td>
</tr>
<tr>
<td>0</td><td>0</td><td>0</td><td>1</td><td>Kanal 1, Pin PC1</td>
</tr>
<tr>
<td>0</td><td>0</td><td>1</td><td>0</td><td>Kanal 2, Pin PC2</td>
</tr>
<tr>
<td>0</td><td>0</td><td>1</td><td>1</td><td>Kanal 3, Pin PC3</td>
</tr>
<tr>
<td>0</td><td>1</td><td>0</td><td>0</td><td>Kanal 4, Pin PC4</td>
</tr>
<tr>
<td>0</td><td>1</td><td>0</td><td>1</td><td>Kanal 5, Pin PC5</td>
</tr>
<tr>
<td>0</td><td>1</td><td>1</td><td>0</td><td>Kanal 6, Pin ADC7 (*)</td>
</tr>
<tr>
<td>0</td><td>1</td><td>1</td><td>1</td><td>Kanal 7, Pin ADC8 (*)</td>
</tr>
<tr>
<td>1</td><td>1</td><td>1</td><td>0</td><td>1.23V, Vbg</td>
</tr>
<tr>
<td>1</td><td>1</td><td>1</td><td>1</td><td>0V, GND</td>
</tr>
</table>

(*) nur in der Gehäusebauform TQFP und MLF verfügbar

===ADCSRA===

+-------+-------+-------+-------+-------+-------+-------+-------+
| ADEN | ADSC | ADFR | ADIF | ADIE | ADPS2 | ADPS1 | ADPS0 |
+-------+-------+-------+-------+-------+-------+-------+-------+

* ADEN (ADC Enable): Mittels ADEN wird der ADC ein und ausgeschaltet. Eine 1 an dieser Bitposition schaltet den ADC ein.
* ADSC (ADC Start Conversion): Wird eine 1 an diese Bitposition geschrieben, so beginnt der ADC mit der Wandlung. Das Bit bleibt auf 1, solange die Wandlung im Gange ist. Wenn die Wandlung beendet ist, wird dieses Bit von der ADC Hardware wieder auf 0 gesetzt.
* ADFR (ADC Free Running): Wird eine 1 an ADFR geschrieben, so wird der ADC im Free Running Modus betrieben. Dabei startet der '''ADC''' nach dem Abschluss einer Messung automatisch die nächste Messung. Die erste Messung wird ganz normal über das Setzen des '''ADSC''' Bits gestartet.
* ADIF (ADC Interrupt Flag): Wenn eine Messung abgeschlossen ist, wird das ADIF Bit gesetzt. Ist zusätzlich noch das ADIE Bit gesetzt, so wird ein Interrupt ausgelöst und der entsprechende Interrupt Handler angesprungen.
* ADIE (ADC Interrupt Enable): Wird eine 1 an ADIE geschrieben, so löst der '''ADC''' nach Beendigung einer Messung einen Interrupt aus.
* ADPS2, ADPS1, ADPS0 (ADC Prescaler): Mit dem Prescaler kann die ADC-Frequenz gewählt werden. Laut Datenblatt sollte diese für die optimale Auflösung zwischen 50KHz und 200kHz liegen. Ist die Wandlerfrequenz langsamer eingestellt, kann es passieren dass die eingebaute Sample & Hold Schaltung die Eingangsspannung nicht lange genug konstant halten kann. Ist die Frequenz aber zu schnell eingestellt, dann kann es passieren dass sich die Sample & Hold Schaltung nicht schnell genug an die Eingangsspannung anpassen kann.

<table border="0">
<tr>
<th align="left">ADPS2</th><th align="left">ADPS1</th><th align="left">ADPS0</th><th align="left">Vorteiler</th>
</tr>
<tr>
<td>0</td><td>0</td><td>0</td><td>2</td>
</tr>
<tr>
<td>0</td><td>0</td><td>1</td><td>2</td>
</tr>
<tr>
<td>0</td><td>1</td><td>0</td><td>4</td>
</tr>
<tr>
<td>0</td><td>1</td><td>1</td><td>8</td>
</tr>
<tr>
<td>1</td><td>0</td><td>0</td><td>16</td>
</tr>
<tr>
<td>1</td><td>0</td><td>1</td><td>32</td>
</tr>
<tr>
<td>1</td><td>1</td><td>0</td><td>64</td>
</tr>
<tr>
<td>1</td><td>1</td><td>1</td><td>128</td>
</tr>
</table>

== Die Ergebnisregister ADCL und ADCH ==

Da das Ergebnis des ADC ein 10 Bit Wert ist, passt dieser Wert naturgemäß nicht in ein einzelnes Register, das je bekanntlich nur 8 Bit breit ist. Daher wird das Ergebnis in 2 Register '''ADCL''' und '''ADCH''' abgelegt. Von den 10 Ergebnisbits sind die niederwertigsten 8 im Register '''ADCL''' abgelegt und die noch fehlenden 2 Bits werden im Register '''ADCH''' an den niederwertigsten Bitpositionen gespeichert.

ADCH ADCL
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | | | | | | | | | | | | | | | |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
9 8 7 6 5 4 3 2 1 0

Diese Zuordnung kann aber auch geändert werden: Durch setzen des '''ADLAR''' Bits im '''ADMUX''' Register wird die Ausgabe geändert zu:

ADCH ADCL
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | | | | | | | | | | | | | | | |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
9 8 7 6 5 4 3 2 1 0

Dies ist besonders dann interessant, wenn das ADC Ergebnis als 8 Bit Zahl weiterverarbeitet werden soll. In diesem Fall stehen die 8 höchstwertigen Bits bereits verarbeitungsfertig im Register '''ADCH''' zur Verfügung.

Beim Auslesen der ADC-Register ist zu beachten:
Immer zuerst '''ADCL''' und erst dann '''ADCH''' auslesen. Beim Zugriff auf '''ADCL''' wird das '''ADCH''' Register gegenüber Veränderungen vom '''ADC''' gesperrt. Erst beim nächsten Auslesen des '''ADCH'''-Registers wird diese Sperre wieder aufgehoben. Dadurch ist sichergestellt, daß die Inhalte von '''ADCL''' und '''ADCH''' immer aus demselben Wandlungsergebnis stammen, selbst wenn der '''ADC''' im Hintergrund selbsttätig weiterwandelt. Das '''ADCH''' Register '''muss''' ausgelesen werden!

== Beispiele ==

=== Ausgabe als ADC-Wert ===

Das folgende Programm liest in einer Schleife ständig den ADC aus und verschickt des Ergebnis im Klartext (ASCII) über die [[AVR-Tutorial: UART|UART]]. Zur Verringerung des unvermeidlichen Rauschens werden 256 Messwerte herangezogen und deren Mittelwert als endgültiges Messergebnis gewertet. Dazu werden die einzelnen Messungen in den Registern temp2, temp3, temp4 als 24 Bit Zahl aufaddiert. Die Division durch 256 erfolgt dann ganz einfach dadurch, dass das Register temp2 verworfen wird und die Register temp3 und temp4 als 16 Bit Zahl aufgefasst werden. Eine Besonderheit ist noch, dass je nach dem Wert in temp2 die 16 Bit Zahl in temp3 und temp4 noch aufgerundet wird: Enthält temp2 einen Wert größer als 128, dann wird zur 16 Bit Zahl in temp3/temp4 noch 1 dazu addiert.

<avrasm>
.include "m8def.inc"

.def temp1 = r16 ; allgemeines temp Register, zur krufristigen Verwendung
.def temp2 = r17 ; Register für 24 Bit Addition, Lowest Byte
.def temp3 = r18 ; Register für 24 Bit Addition, Middle Byte
.def temp4 = r19 ; Register für 24 Bit Addition, Highest Byte
.def adlow = r20 ; Ergebnis vom ADC / Mittelwert der 256 Messungen
.def adhigh = r21 ; Ergebnis vom ADC / Mittelwert der 256 Messungen
.def messungen = r22 ; Schleifenzähler für die Messungen
.def ztausend = r23 ; Zehntausenderstelle des ADC Wertes
.def tausend = r24 ; Tausenderstelle des ADC Wertes
.def hundert = r25 ; Hunderterstelle des ADC Wertes
.def zehner = r26 ; Zehnerstelle des ADC Wertes
.def zeichen = r27 ; Zeichen zur Ausgabe auf den UART

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

; hier geht das Programm los

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;UART Initalisierung

ldi temp1, LOW(UBRR_VAL) ; Baudrate einstellen
out UBRRL, temp1
ldi temp1, HIGH(UBRR_VAL)
out UBRRH, temp1

sbi UCSRB, TXEN ; TX einschalten

; ADC initialisieren: Single Conversion, Vorteiler 128

ldi temp1, (1<<REFS0) ; Kanal 0, interne Referenzspannung 5V
out ADMUX, temp1
ldi temp1, (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)
out ADCSRA, temp1

Main:
clr temp1
clr temp2
clr temp3
clr temp4

ldi messungen, 0 ; 256 Schleifendurchläufe

; neuen ADC-Wert lesen (Schleife - 256 mal)

sample_adc:
sbi ADCSRA, ADSC ; den ADC starten

wait_adc:
sbic ADCSRA, ADSC ; wenn der ADC fertig ist, wird dieses Bit gelöscht
rjmp wait_adc

; ADC einlesen:

in adlow, ADCL ; immer zuerst LOW Byte lesen
in adhigh, ADCH ; danach das mittlerweile gesperrte High Byte

; alle 256 ADC-Werte addieren
; dazu wird mit den Registern temp4, temp3 und temp2 ein
; 24-Bit breites Akkumulationsregister gebildet, in dem
; die 10 Bit Werte aus adhigh, adlow aufsummiert werden

add temp2, adlow ; addieren
adc temp3, adhigh ; addieren über Carry
adc temp4, temp1 ; addieren über Carry, temp1 enthält 0
dec messungen ; Schleifenzähler MINUS 1
brne sample_adc ; wenn noch keine 256 ADC Werte -> nächsten Wert einlesen

; Aus den 256 Werten den Mittelwert berechnen
; Bei 256 Werten ist das ganz einfach: Das niederwertigste Byte
; (im Register temp2) fällt einfach weg
;
; allerdings wird der Wert noch gerundet

cpi temp2,128 ; "Kommastelle" kleiner als 128 ?
brlo no_round ; ist kleiner ==> Sprung

; Aufrunden
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry

no_round:

; Ergebnis nach adlow und adhigh kopieren
; damit die temp Register frei werden

mov adlow, temp3
mov adhigh, temp4

;in ASCII umwandeln

ldi ztausend, -1 + '0'
_a6ser:
inc ztausend
subi adlow, low(10000) ; -10,000
sbci adhigh, high(10000)
brcc _a6ser

ldi tausend, 10 + '0'
_a7ser:
dec tausend
subi adlow, low(-1000) ; +1000
sbci adhigh, high(-1000)
brcs _a7ser

ldi hundert, -1 + '0'
_a8ser:
inc hundert
subi adlow, low(100) ; -100
sbci adhigh, high(100)
brcc _a8ser

ldi zehner, 10 + '0'
_a9ser:
dec zehner
subi adlow, -10 ; +10
brcs _a9ser
subi adlow,-'0'

;an UART Senden

mov zeichen, ztausend ; Zehntausender Stelle
rcall transmit
mov zeichen, tausend ; Tausender Stelle ausgeben
rcall transmit
mov zeichen, hundert ; Hunderter Stelle ausgeben
rcall transmit
mov zeichen, zehner ; Zehner Stelle ausgeben
rcall transmit
mov zeichen, adlow ; Einer Stelle ausgeben
rcall transmit
ldi zeichen, 13 ; CR
rcall transmit
ldi zeichen, 10 ; LF
rcall transmit

rjmp Main

transmit:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp transmit
out UDR, zeichen ; und Zeichen ausgeben
ret
</avrasm>

=== Ausgabe als Spannungswert ===

Das zweite Beispiel ist schon um einiges größer. Hier wird der gemittelte ADC-Wert in eine Spannung umgerechnet. Dazu wird [[Festkommaarithmetik]] verwendet. Die Daten sind in diesem Fall

* Referenzspannung : 5V
* alte Auflösung : 5V / 1024 = 4,8828125mV
* neue Auflösung : 1mV

-> Faktor = 4,8828125mV / 1mV = 4,8828125

Der Faktor wird dreimal mit 10 multipliziert und das Ergebnis auf 4883 gerundet. Die neue Auflösung wird dreimal durch 10 dividiert und beträgt 1μV. Der relative Fehler beträgt

:<math> F_r = \frac {4883}{4882,8125}-1 = 0,00384% = \frac {1}{26042}</math>

Diese Fehler ist absolut vernachlässigbar. Nach der Multiplikation des ADC-Wertes mit 4883 liegt die gemessene Spannung in der Einheit μV vor. Vorsicht! Das ist '''nicht''' die reale [[Auflösung und Genauigkeit]], nur rein mathematisch bedingt. Für maximale Genauigkeit sollte man die Versorgungsspannung AVCC, welche hier gleichzeitig als Referenzspannung dient, exakt messen, die Rechnung nachvollziehen und den Wert im Quelltext eintragen. Damit führt man eine einfach Einpunktkalibrierung durch.

Da das Programm schon um einiges größer und komplexer ist, wurde es im Vergleich zur Vorgängerversion geändert. Die Multiplikation sowie die Umwandung der Zahl in einen ASCII-String sind als Unterprogramme geschrieben, dadurch erhält man wesentlich mehr Überblick im Hauptprogramm und die Wiederverwendung in anderen Programmen vereinfacht sich. Ausserdem wird der String im RAM gespeichert und nicht mehr in CPU-Registern.

<avrasm>
.include "m8def.inc"

.def temp1 = r16 ; allgemeines temp Register, zur kurzfristige Verwendung
.def temp2 = r17 ; Register für 24 Bit Addition, Lowest Byte
.def temp3 = r18 ; Register für 24 Bit Addition, Middle Byte
.def temp4 = r19 ; Register für 24 Bit Addition, Highest Byte
.def adlow = r20 ; Ergebnis vom ADC / Mittelwert der 256 Messungen
.def adhigh = r21 ; Ergebnis vom ADC / Mittelwert der 256 Messungen
.def messungen = r22 ; Schleifenzähler für die Messungen
.def zeichen = r23 ; Zeichen zur Ausgabe auf den UART
.def temp5 = r24
.def temp6 = r25

; Faktor für Umrechung des ADC-Wertes in Spannung
; = (Referenzspannung / 1024 ) * 100000
; = 5V / 1024 * 1.000.000
.equ Faktor = 4883

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

; RAM
.dseg
.org 0x60
Puffer: .byte 10

; hier geht das Programm los
.cseg
.org 0

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;UART Initalisierung

ldi temp1, LOW(UBRR_VAL) ; Baudrate einstellen
out UBRRL, temp1
ldi temp1, HIGH(UBRR_VAL)
out UBRRH, temp1

sbi UCSRB, TXEN ; TX einschalten

; ADC initialisieren: Single Conversion, Vorteiler 128
; Kanal 0, interne Referenzspannung AVCC

ldi temp1, (1<<REFS0)
out ADMUX, temp1
ldi temp1, (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)
out ADCSRA, temp1

Hauptschleife:
clr temp1
clr temp2
clr temp3
clr temp4

ldi messungen, 0 ; 256 Schleifendurchläufe

; neuen ADC-Wert lesen (Schleife - 256 mal)

adc_messung:
sbi ADCSRA, ADSC ; den ADC starten

adc_warten:
sbic ADCSRA, ADSC ; wenn der ADC fertig ist, wird dieses Bit gelöscht
rjmp adc_warten

; ADC einlesen:

in adlow, ADCL ; immer zuerst LOW Byte lesen
in adhigh, ADCH ; danach das mittlerweile gesperrte High Byte

; alle 256 ADC-Werte addieren
; dazu wird mit den Registern temp4, temp3 und temp2 ein
; 24-Bit breites Akkumulationsregister gebildet, in dem
; die 10 Bit Werte aus adhigh, adlow aufsummiert werden

add temp2, adlow ; addieren
adc temp3, adhigh ; addieren über Carry
adc temp4, temp1 ; addieren über Carry, temp1 enthält 0
dec messungen ; Schleifenzähler MINUS 1
brne adc_messung ; wenn noch keine 256 ADC Werte -> nächsten Wert einlesen

; Aus den 256 Werten den Mittelwert berechnen
; Bei 256 Werten ist das ganz einfach: Das niederwertigste Byte
; (im Register temp2) fällt einfach weg
;
; allerdings wird der Wert noch gerundet

cpi temp2,128 ; "Kommastelle" kleiner als 128 ?
brlo nicht_runden ; ist kleiner ==> Sprung

; Aufrunden
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry

nicht_runden:

; Ergebnis nach adlow und adhigh kopieren
; damit die temp Register frei werden

mov adlow, temp3
mov adhigh, temp4

; in Spannung umrechnen

ldi temp5,low(Faktor)
ldi temp6,high(Faktor)
rcall mul16x16

; in ASCII umwandeln

ldi ZL, low(Puffer)
ldi ZH, high(Puffer)
rcall Int_to_ASCII

;an UART Senden

ldi ZL, low(Puffer+3)
ldi ZH, high(Puffer+3)
ldi temp1, 1
rcall sende_zeichen ; eine Vorkommastelle ausgeben

ldi zeichen, ',' ; Komma ausgeben
rcall sende_einzelzeichen

ldi temp1, 3 ; Drei Nachkommastellen ausgeben
rcall sende_zeichen

ldi zeichen, 'V' ; Volt Zeichen ausgeben
rcall sende_einzelzeichen

ldi zeichen, 10 ; New Line Steuerzeichen
rcall sende_einzelzeichen

ldi zeichen, 13 ; Carrige Return Steuerzeichen
rcall sende_einzelzeichen

rjmp Hauptschleife

; Ende des Hauptprogramms

; Unterprogramme

; ein Zeichen per UART senden

sende_einzelzeichen:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp sende_einzelzeichen
out UDR, zeichen ; und Zeichen ausgeben
ret

; mehrere Zeichen ausgeben, welche durch Z adressiert werden
; Anzahl in temp1

sende_zeichen:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp sende_zeichen
ld zeichen, Z+ ; Zeichen laden
out UDR, zeichen ; und Zeichen ausgeben
dec temp1
brne sende_zeichen
ret

; 32 Bit Zahl in ASCII umwandeln
; Zahl liegt in temp1..4
; Ergebnis ist ein 10stelliger ASCII String, welcher im SRAM abgelegt wird
; Adressierung über Z Pointer

Int_to_ASCII:
ldi temp5, -1 + '0'
_a1ser:
inc temp5
subi temp1,BYTE1(1000000000) ; - 1.000.000.000
sbci temp2,BYTE2(1000000000)
sbci temp3,BYTE3(1000000000)
sbci temp4,BYTE4(1000000000)
brcc _a1ser

st Z+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a2ser:
dec temp5
subi temp1,BYTE1(-100000000) ; + 100.000.000
sbci temp2,BYTE2(-100000000)
sbci temp3,BYTE3(-100000000)
sbci temp4,BYTE4(-100000000)
brcs _a2ser

st Z+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a3ser:
inc temp5
subi temp1,low(10000000) ; - 10.000.000
sbci temp2,high(10000000)
sbci temp3,BYTE3(10000000)
brcc _a3ser

st Z+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a4ser:
dec temp5
subi temp1,low(-1000000) ; + 1.000.000
sbci temp2,high(-1000000)
sbci temp3,BYTE3(-1000000)
brcs _a4ser

st Z+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a5ser:
inc temp5
subi temp1,low(100000) ; -100.000
sbci temp2,high(100000)
sbci temp3,BYTE3(100000)
brcc _a5ser

st Z+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a6ser:
dec temp5
subi temp1,low(-10000) ; +10,000
sbci temp2,high(-10000)
sbci temp3,BYTE3(-10000)
brcs _a6ser

st Z+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a7ser:
inc temp5
subi temp1,low(1000) ; -1000
sbci temp2,high(1000)
brcc _a7ser

st Z+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a8ser:
dec temp5
subi temp1,low(-100) ; +100
sbci temp2,high(-100)
brcs _a8ser

st Z+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a9ser:
inc temp5
subi temp1, 10 ; -10
brcc _a9ser

st Z+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a10ser:
dec temp5
subi temp1, -1 ; +1
brcs _a10ser

st Z+,temp5 ; im Puffer speichern
ret

; 16 Bit Wert in Spannung umrechnen
;
; = 16Bitx16Bit=32 Bit Multiplikation
; = vier 8x8 Bit Multiplikationen
;
; adlow/adhigh * temp5/temp6

mul16x16:
push zeichen
clr temp1 ; 32 Bit Akku löschen
clr temp2
clr temp3
clr temp4
clr zeichen ; Null, für Carry-Addition

mul adlow, temp5 ; erste Multiplikation
add temp1, r0 ; und akkumulieren
adc temp2, r1

mul adhigh, temp5 ; zweite Multiplikation
add temp2, r0 ; und gewichtet akkumlieren
adc temp3, r1

mul adlow, temp6 ; dritte Multiplikation
add temp2, r0 ; und gewichtet akkumlieren
adc temp3, r1
adc temp4, zeichen ; carry addieren

mul adhigh, temp6 ; vierte Multiplikation
add temp3, r0 ; und gewichtet akkumlieren
adc temp4, r1

pop zeichen
ret
</avrasm>

{{Navigation_zurückhochvor|
zurücktext=Uhr|
zurücklink=AVR-Tutorial: Uhr|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Tasten|
vorlink=AVR-Tutorial: Tasten}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: ADC

2007-12-25T22:37:22Z

FalkB: Kleine Korrekturen

AVR-Tutorial: UART

2007-12-25T21:19:06Z

FalkB: Fehler in Beispielen korrigiert, Beispiele verbessert, Formatierung vereinheitlicht

Wie viele andere Controller besitzen die meisten AVRs einen '''[[UART]]''' ('''U'''niversal '''A'''synchronous '''R'''eceiver and '''T'''ransmitter). Das ist eine serielle Schnittstelle, die meistens zur Datenübertragung zwischen Mikrocontroller und PC genutzt wird. Zur Übertragung werden zwei Pins am Controller benötigt: '''TXD''' und '''RXD'''. Über '''TXD''' ("Transmit Data") werden Daten gesendet, '''RXD''' ("Receive Data") dient zum Empfang von Daten.

== Hardware ==

Um den UART des Mikrocontrollers zu verwenden, muss der Versuchsaufbau um folgende Bauteile erweitert werden:

[[Bild:AVR-RS232.png|640px]]

Auf dem Board vom [http://shop.mikrocontroller.net/ Shop] sind diese Bauteile bereits enthalten, man muss nur noch die Verbindungen zwischen MAX232 und AVR herstellen wie im [http://shop.mikrocontroller.net/images/avrplat28-app.jpg Bild] zu sehen.

* Der MAX232 ist ein [[Pegelwandler]], der die -12V/+12V Signale an der seriellen Schnittstelle des PCs zu den 5V/0V des AVRs kompatibel macht.
* C1 ist ein kleiner Keramikkondensator, wie er immer wieder zur Entkopplung der Versorgungsspannungen an digitalen ICs verwendet wird.
* Die vier Kondensatoren C2..C5 sind Elektrolytkondensatoren (Elkos). Auf die richtige Polung achten! Minus ist der Strich auf dem Gehäuse. Der exakte Wert ist hier relativ unkritisch, in der Praxis sollte alles von ca. 1µF bis 47µF mit einer Spannungsfestigkeit von 16V und höher funktionieren.
* X1 ist ein weiblicher 9-poliger SUB-D-Verbinder.
* Die Verbindung zwischen PC und Mikrocontroller erfolgt über ein 9-poliges Modem-Kabel (nicht [http://de.wikipedia.org/wiki/Nullmodem-Kabel Nullmodem]-Kabel!), das an den seriellen Port des PCs angeschlossen wird. Bei einem Modem-Kabel sind die Pins 2 und 3 des einen Kabelendes mit den Pins 2 und 3 des anderen Kabelendes durchverbunden. Bei einem Nullmodem Kabel sind die Leitungen gekreuzt, sodass Pin 2 von der einen Seite mit Pin 3 auf der anderen Seite verbunden ist und umgekehrt.
* Als Faustregel kann man annehmen: Befinden sich an den beiden Enden des Kabels die gleiche Art von Anschlüssen (Männchen = Stecker; Weibchen = Buchse), dann benötigt man ein gekreuztes Kabel, also ein Nullmodem-Kabel. Am PC-Anschluss selbst befindet sich ein Stecker, also ein Männchen, sodaß am Kabel auf dieser Seite eine Buchse (also ein Weibchen) sitzen muss. Da am AVR laut obigem Schaltbild eine Buchse (also ein Weibchen) verbaut wird, muss daher an diesem Ende des Kabels ein Stecker sitzen. Das Kabel hat daher an einem Ende einen Stecker und am anderen Ende eine Buchse und ist daher ein normales Modem-Kabel ( = nicht gekreuzt).

[[Bild:USART_Kabel.gif]]

== Software ==

=== UART konfigurieren ===

Als erstes muss die gewünschte Baudrate im Register '''UBRR''' festgelegt werden. Der in dieses Register zu schreibende Wert errechnet sich nach der folgenden Formel:

<math>UBRR = \frac {Taktfrequenz} { 16 \cdot Baudrate } - 1</math>

Beim AT90S4433 kann man den Wert direkt in das Register '''UBRR''' laden, beim ATmega8 gibt es für '''UBRR''' zwei Register: '''UBRRL''' (Low-Byte) und '''UBRRH''' (High-Byte). Im Normalfall steht in '''UBRRH''' 0, da der berechnete Wert kleiner als 256 ist und somit in '''UBRRL''' alleine passt. Beachtet werden muss, dass das Register '''UBRRH''' vor dem Register '''UBRRL''' beschrieben werden muss. Der Schreibzugriff auf '''UBRRL''' löst das Neusetzen des internen Taktteilers aus.

----

'''WICHTIGER HINWEIS!'''

Auf Grund permanent wiederkehrender Nachfrage sei hier '''AUSDRÜCKLICH''' darauf hingewiesen, dass bei Verwendung des UART unbedingt ein Quarz oder Ouarzoszillator verwendet werden muss! Der interne RC-Oszillator der AVRs ist zu ungenau! Damit kann es in Ausnahmefällen funktionieren, muss es aber nicht! Auch ist der interne Oszillator temperaturempfindlich. Damit hat man dann den schönen Effekt, dass eine UART-Schaltung die im Winter noch funktionierte, im Sommer den Dienst verweigert.

Außerdem muss bei der Berechnung von '''UBRR''' geprüft werden, ob mit der verwendeten Quarzfrequenz die gewünschte Baudrate mit einem Fehler von <1% generiert werden kann. Das Datenblatt bietet hier sowohl die Formel als auch Tabellen unter der Überschrift des U(S)ART an.

<math> Fehler_{Baudrate}[%] = (\frac{UBRR_{gerundet}+1}{UBRR_{genau}+1} -1 ) \cdot 100</math>

Siehe auch [[Baudratenquarz]]

Wer es ganz einfach haben will, nimmt die folgenden Macros. Die rechnen sogar den Fehler aus und brechen die Assemblierung ggf. ab. Das ist dann praktisch idiotensicher.

<avrasm>
.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif
</avrasm>
----

Um den Sendekanal des UART zu aktivieren, muss das Bit '''TXEN''' im UART Control Register '''UCSRB''' auf 1 gesetzt werden.

Danach kann das zu sendende Byte in das Register '''UDR''' eingeschrieben werden - vorher muss jedoch sichergestellt werden, dass das Register leer ist, die vorhergehende Übertragung also schon abgeschlossen wurde. Dazu wird getestet, ob das Bit '''UDRE''' ("UART Data Register Empty") im Register '''UCSRA''' auf 1 ist.

Genaueres über die UART-Register findet man im Datenblatt des Controllers.

Der ATmega8 bietet noch viele weitere Optionen zur Konfiguration des UARTs, aber für die Datenübertragung zum PC sind im Normalfall keine anderen Einstellungen notwendig.

=== Senden von Zeichen ===

Das Beispielprogramm überträgt die Zeichenkette "Test!" in einer Endlosschleife an den PC. Die folgenden Beispiele sind für den ATmega8 geschrieben.

<avrasm>
.include "m8def.inc"

.def temp = r16 ; Register für kleinere Arbeiten
.def zeichen = r17 ; in diesem Register wird das Zeichen an die
; Ausgabefunktion übergeben

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

; Stackpointer initialisieren

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

; Baudrate einstellen

ldi temp, HIGH(UBRR_VAL)
out UBRRH, temp
ldi temp, LOW(UBRR_VAL)
out UBRRL, temp

; Frame-Format: 8 Bit

ldi temp, (1<<URSEL)|(3<<UCSZ0)
out UCSRC, temp

sbi UCSRB,TXEN ; TX aktivieren

loop:
ldi zeichen, 'T'
rcall serout ; Unterprogramm aufrufen
ldi zeichen, 'e'
rcall serout ; Unterprogramm aufrufen
ldi zeichen, 's'
rcall serout ; ...
ldi zeichen, 't'
rcall serout
ldi zeichen, '!'
rcall serout
ldi zeichen, 10
rcall serout
ldi zeichen, 13
rcall serout
rjmp loop

serout:
sbis UCSRA,UDRE ; Warten bis UDR für das nächste
; Byte bereit ist
rjmp serout
out UDR, zeichen
ret ; zurück zum Hauptprogramm
</avrasm>

Der Befehl '''rcall serout''' ruft ein kleines Unterprogramm auf, das zuerst wartet bis das Datenregister '''UDR''' von der vorhergehenden Übertragung frei ist, und anschließend das in zeichen (=r17) gespeicherte Byte an '''UDR''' ausgibt.

Bevor serout aufgerufen wird, wird zeichen jedesmal mit dem ASCII-Code des zu übertragenden Zeichens geladen (so wie in Teil 4 bei der LCD-Ansteuerung). Der Assembler wandelt Zeichen in einfachen Anführungsstrichen automatisch in den entsprechenden ASCII-Wert um. Nach dem Wort "Test!" werden noch die Codes 10 (New Line) und 13 (Carriage Return) gesendet, um dem Terminalprogramm mitzuteilen, dass eine neue Zeile beginnt.

Eine Übersicht aller ASCII-Codes gibt es auf [http://www.asciitable.com/ www.asciitable.com].

Die Berechnung der Baudrate wird übrigens nicht im Controller während der Programmausführung durchgeführt, sondern schon beim Assemblieren, wie man beim Betrachten der Listingdatei feststellen kann.

Zum Empfang muss auf dem PC ein Terminal-Programm wie z.B. HyperTerminal gestartet werden. Der folgende Screenshot zeigt, welche Einstellungen im Programm vorgenommen werden müssen:

http://www.mikrocontroller.net/images/hyperterminal.gif

Linux-Benutzer können das entsprechende Device (z.B. /dev/ttyS0) mit stty konfigurieren und mit cat die empfangenen Daten anzeigen oder ein Terminalprogramm wie minicom nutzen.

=== Senden von Zeichenketten ===

Eine bequemere Methode um längere Zeichenketten (Strings) zu übertragen ist hier zu sehen. Dabei werden die Zeichenketten im Flash gespeichert. Als Abschluss des Strings wird der Wert 0x00 genutzt, so wie auch in der Programmiersprache C.

<avrasm>
.include "m8def.inc"

.def temp = r16 ; Register für kleinere Arbeiten
.def zeichen = r17 ; in diesem Register wird das Zeichen an die
; Ausgabefunktion übergeben

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

; hier geht unser Programm los

; Stackpointer initialisieren

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

; Baudrate einstellen

ldi temp, HIGH(UBRR_VAL)
out UBRRH, temp
ldi temp, LOW(UBRR_VAL)
out UBRRL, temp

; Frame-Format: 8 Bit

ldi temp, (1<<URSEL)|(3<<UCSZ0)
out UCSRC, temp

sbi UCSRB,TXEN ; TX aktivieren

loop:
ldi zl,low(my_string*2); ; Z Pointer laden
ldi zh,high(my_string*2);
rcall serout_string
rjmp loop

; Ausgabe eines Strings aus dem Flash

serout_string:
lpm ; nächstes Byte aus dem Flash laden
and r0,r0 ; = Null?
breq serout_string_ende ; wenn ja, -> Ende
serout_string_wait:
sbis UCSRA,UDRE ; Warten bis UDR für das nächste
; Byte bereit ist
rjmp serout_string_wait
out UDR, r0
adiw zl:zh,1 ; Zeiger erhöhen
rjmp serout_string ; nächstes Zeichen bearbeiten
serout_string_ende:
ret ; zurück zum Hauptprogramm

; Hier wird jetzt der String definiert und im Flash gespeichert

my_string: .db "Test!",10,13,0
</avrasm>

=== Empfangen von Zeichen per Polling===

Der AVR kann nicht nur Daten seriell senden, sondern auch empfangen. Dazu muss man, nachdem die Baudrate wie oben beschrieben eingestellt wurde, das Bit '''RXEN''' setzen.

Sobald der UART ein Byte über die serielle Verbindung empfangen hat, wird das Bit '''RXC''' im Register '''UCSRA''' gesetzt, um anzuzeigen, dass ein Byte im Register '''UDR''' zur Weiterverarbeitung bereitsteht. Sobald es aus '''UDR''' gelesen wurde, wird '''RXC''' automatisch wieder gelöscht, bis das nächste Byte angekommen ist.

Das erste einfache Testprogramm soll das empfangene Byte auf den an Port D angeschlossenen LEDs ausgeben. Dabei sollte man daran denken, dass PD0 (RXD) bereits für die Datenübertragung zuständig ist, so dass das entsprechende Bit im Register PORTD keine Funktion hat und damit auch nicht für die Datenanzeige verwendet werden kann.

Nachdem der UART konfiguriert ist, wartet das Programm einfach in der Hauptschleife darauf, dass ein Byte über den UART ankommt (z.B. indem man im Terminalprogramm ein Zeichen eingibt), also '''RXC''' gesetzt wird. Sobald das passiert, wird das Register '''UDR''', in dem die empfangenen Daten stehen, nach temp eingelesen und an den Port D ausgegeben.

<avrasm>
.include "m8def.inc"

.def temp = R16

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

; Stackpointer initialisieren

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

; Port D = Ausgang

ldi temp, 0xFF
out DDRD, temp

; Baudrate einstellen

ldi temp, HIGH(UBRR_VAL)
out UBRRH, temp
ldi temp, LOW(UBRR_VAL)
out UBRRL, temp

; Frame-Format: 8 Bit

ldi temp, (1<<URSEL)|(3<<UCSZ0)
out UCSRC, temp

sbi UCSRB, RXEN ; RX (Empfang) aktivieren

receive_loop:
sbis UCSRA, RXC ; warten bis ein Byte angekommen ist
rjmp receive_loop
in temp, UDR ; empfangenes Byte nach temp kopieren
out PORTD, temp ; und an Port D ausgeben.
rjmp receive_loop ; zurück zum Hauptprogramm
</avrasm>

=== Empfangen von Zeichen per Interrupt ===

Dieses Programm lässt sich allerdings noch verfeinern. Statt in der Hauptschleife auf die Daten zu warten, kann man auch veranlassen dass ein Interrupt ausgelöst wird, sobald ein Byte angekommen ist. Das sieht in der einfachsten Form so aus:

<avrasm>
.include "m8def.inc"

.def temp = R16

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

.org 0x00
rjmp main

.org URXCaddr ; Interruptvektor für UART-Empfang
rjmp int_rxc

; Hauptprogramm

main:

; Stackpointer initialisieren

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

; Port D = Ausgang

ldi temp, 0xFF
out DDRD, temp

; Baudrate einstellen

ldi temp, HIGH(UBRR_VAL)
out UBRRH, temp
ldi temp, LOW(UBRR_VAL)
out UBRRL, temp

; Frame-Format: 8 Bit

ldi temp, (1<<URSEL)|(3<<UCSZ0)
out UCSRC, temp

sbi UCSRB, RXCIE ; Interrupt bei Empfang
sbi UCSRB, RXEN ; RX (Empfang) aktivieren

sei ; Interrupts global aktivieren

loop:
rjmp loop ; Endlosschleife

; Interruptroutine: wird ausgeführt sobald ein Byte über das UART empfangen wurde

int_rxc:
push temp ; temp auf dem Stack sichern
in temp, UDR ; epfangendes Byte lesen,
; dadurch wird auch der Interrupt gelöscht
out PORTD, temp ; Daten ausgeben
pop temp ; temp wiederherstellen
reti ; Interrupt beenden
</avrasm>

Diese Methode hat den großen Vorteil, dass das Hauptprogramm (hier nur eine leere Endlosschleife) andere Dinge erledigen kann, während der Controller Daten empfängt. Auf diese Weise kann man mehrere Aktionen quasi gleichzeitig ausführen, da das Hauptprogramm nur kurz unterbrochen wird, um die empfangenen Daten zu verarbeiten.

Probleme können allerdings auftreten, wenn in der Interruptroutine die gleichen Register verwendet werden wie im Hauptprogramm, da dieses ja an beliebigen Stellen durch den Interrupt unterbrochen werden kann. Damit sich aus der Sicht der Hauptschleife durch den Interruptaufruf nichts ändert, müssen alle in der Interruptroutine geänderten Register am Anfang der Routine gesichert und am Ende wiederhergestellt werden. Das gilt vor allem für das CPU-Statusregister ('''SREG''')! Sobald ein einziger Befehl im Interrupt ein einziges Bit im SREG beeinflusst, muss das SREG gesichert werden. Das ist praktisch fast immer der Fall, nur in dem ganz einfachen Beispiel oben ist es überflüssig, weil die verwendeten Befehle das SREG nicht beeinflussen. In diesem Zusammenhang wird der [[Stack]] wieder interessant. Um die Register zu sichern, kann man sie mit '''push''' oben auf den Stapel legen und am Ende wieder in der umgekehrten Reihenfolge(!) mit '''pop''' vom Stapel herunternehmen.

Im folgenden Beispielprogramm werden die empfangenen Daten nun nicht mehr komplett angezeigt. Stattdessen kann man durch Eingabe einer 1 oder einer 0 im Terminalprogramm eine LED (an PB0) an- oder ausschalten. Dazu wird das empfangene Byte in der Interruptroutine mit den entsprechenden ASCII-Codes der Zeichen 1 und 0 (siehe [http://www.asciitable.com/ www.asciitable.com]) verglichen.

Für den [[AVR-Tutorial:_Vergleiche|Vergleich]] eines Registers mit einer Konstanten gibt es den Befehl '''cpi register, konstante'''. Das Ergebnis dieses Vergleichs kann man mit den Befehlen '''breq label''' (springe zu label, wenn gleich) und '''brne label''' (springe zu label, wenn ungleich) auswerten.

<avrasm>
.include "m8def.inc"

.def temp = R16

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

.org 0x00
rjmp main

.org URXCaddr
rjmp int_rxc

; Hauptprogramm
main:

; Stackpointer initialisieren

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

; Port B = Ausgang

ldi temp, 0xFF
out DDRB, temp

; Baudrate einstellen

ldi temp, HIGH(UBRR_VAL)
out UBRRH, temp
ldi temp, LOW(UBRR_VAL)
out UBRRL, temp

; Frame-Format: 8 Bit

ldi temp, (1<<URSEL)|(3<<UCSZ0)
out UCSRC, temp

sbi UCSRB, RXCIE ; Interrupt bei Empfang
sbi UCSRB, RXEN ; RX (Empfang) aktivieren

sei ; Interrupts global aktivieren

loop:
rjmp loop ; Endlosschleife

; Interruptroutine: wird ausgeführt sobald ein Byte über das UART empfangen wurde

int_rxc:
push temp ; temp auf dem Stack sichern
in temp, sreg ; SREG sichern
push temp

in temp, UDR ; UART Daten lesen
cpi temp, '1' ; empfangenes Byte mit '1' vergleichen
brne int_rxc_1 ; wenn nicht gleich, dann zu int_rxc_1
cbi PORTB, 0 ; LED einschalten, low aktiv
rjmp int_rxc_2 ; Zu int_rxc_2 springen
int_rxc_1:
cpi temp, '0' ; empfangenes Byte mit '0' vergleichen
brne int_rxc_2 ; wenn nicht gleich, dann zu int_rxc_2
sbi PORTB, 0 ; LED ausschalten, low aktiv
int_rxc_2:

pop temp
out sreg, temp ; SREG wiederherstellen
pop temp ; temp wiederherstellen
reti
</avrasm>

{{Navigation_zurückhochvor|
zurücktext=Mehrfachverzweigung|
zurücklink=AVR-Tutorial: Mehrfachverzweigung|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Speicher|
vorlink=AVR-Tutorial: Speicher}}

[[Category:AVR]][[Category:AVR-Tutorial]]

Interrupt

2007-12-25T19:14:36Z

FalkB: Abschnitt eingefügt

== Einleitung ==

Bei bestimmten Ereignissen in Prozessoren wird ein '''Interrupt''' ausgelöst. Dabei wird das Programm unterbrochen und ein Unterprogramm, die sogenannte '''I'''nterrupt '''S'''ervice '''R'''outine ('''ISR'''), aufgerufen. Wenn dieses beendet ist läuft das Hauptprogramm ganz normal weiter.

Bei [[Mikrocontroller]]n werden Interrupts z.B. ausgelöst wenn:
* sich der an einem bestimmten Eingangs-Pin anliegende Pegel ändert
* eine vorher festgelegte Zeitspanne abgelaufen ist ([[Timer]])
* eine [[Seriell|serielle]] Übertragung abgeschlossen ist
* eine Messung des [[ADC |Analog-Digital-Wandlers]] abgeschlossen ist

== Wichtige Eigenschaften von ISRs ==

ISRs reagieren auf ein bestimmtes Ereignis, welches relativ oft oder selten passiert. Prinzipiell sollte man ISRs möglichst kurz halten und schnell beenden. '''Im Mittel muss die Interruptroutine kürzer sein als die Periodendauer des Ereignises, anderenfalls wird es passieren, dass Interrupts "verschluckt" werden''', d.h. beim UART gehen Daten verloren, beim Timer gehen Zählzyklen verloren, beim AD-Wandler gehen Daten verloren etc. '''Solche verschluckten Interrupts sind bisweilen schwer zu finden, weil es bisweilen nur sehr wenige in ganz bestimmten Konstellationen sind.''' Wenn dann eine per Timer realisierte Uhr in der Stunde um 1s falsch geht, merkt man das oft nicht. '''Langwierige Berechnungen, Auswertungen, Ausgaben oder gar Warteschleifen haben in ISRs nichts zu suchen.''' Typische C-Funktionen wie printf(), scanf(), längere Ausgaben auf ein [[LCD]] etc. sollte man nicht in ISRs vornehmen. Hier kommt sinnvollerweise eine andere Programmiertechnik zu Einsatz, nämlich die Übergabe von Parametern bzw. Steuersignalen an das Hauptprogramm.

=== Interruptsteuerung ===

Interrupts müssen wie alle anderen Module und Funktionen eines Mikrocontrollers gesteuert werden. Dazu wird auf praktisch allen Mikrocontrollern ein zweistufiges System verwendet.
* Globale Interruptsteuerung über ein CPU-Statusbit: Beim [[AVR]] ist das das I-Bit (Interrupt) im Statusregister (SREG). Dieses Bit wirkt wie ein Hauptschalter und kann global die Ausführung aller Interrupts ein - und ausschalten. Das heisst aber nicht, dass während der Zeit der inaktiven Interrupts diese verloren gehen. Vielmehr wird das jeweilige Interruptbit gesetzt, und wenn die Interrupts wieder freigegeben werden wird der Interrupt ausgeführt. Verloren gehen Interrupts erst dann, wenn die Sperrzeit zu gross ist und währenddessen mehr als ein Interrupt vom selben Typ eintrifft. Siehe [[# Zeitverhalten eines Timerinterrupts]] und [[#Zeitverhalten des UART Empfangsinterrupt]]
* Lokale Interruptsteuerung für jede einzelne Interruptquelle über Maskenbits in mehreren Interruptmaskenregistern. Hier kann jede einzelne Interruptquelle individuell ein- und ausgeschaltet werden.

Dieses System hat eine Reihe von Vorteilen. So können sehr schnell und einfach alle Interrupts kurzzeitig gesperrt werden, wenn beispielsweise [[#Atomarer Datenzugriff | atomare]] Operationen durchgeführt werden sollen, oder besonders zeitkritische Abläufe ausgeführt werden. Danach können alle konfigurierten Interrupts einfach wieder freigeschaltet werden, ohne dass die CPU viele verschiedene Interruptmaskenbits verwalten müsste.

Eine ISR wird demnach nur dann ausgeführt, wenn
* die Interrupts global freigeschaltet sind
* das individuelle Maskenbit gesetzt ist
* der Interrupt eintritt

=== Verschachtelte Interrupts ===

Einige Mikrocontroller, wie z.B. der [[AVR]] kennen nur zwei CPU-Zustände. Normale Programmausführung und Interruptausführung, gesteuert durch das I-Bit der CPU. Die normale Programmausführung kann jederzeit durch Interrupts unterbrochen werden. Die Interruptausführung kann nicht durch neue Interrupts unterbrochen werden. Die ISR wird erst zu Ende bearbeitet, zurück in die normale Programmausführung gesprungen und erst dann werden neue, wartende (engl. pending) Interrupts bearbeitet.

Etwas komplexere Mikrocontroller oder grosse Prozessoren bieten verschiedene Interruptlevel (Stufen) an . Dabei gilt meist je niedriger die Zahl des Levels, um so höher die Priorität. Ein Interrupt mit höherer Priorität kann einen Interrupt mit niedriger Priorität unterbrechen. Ein Interrupt mit gleicher Priorität wie der gerade bearbeitete Interrupt kann das im allgemeinen nicht. Das nennt man verschachtelte Interrupts (engl. nested interrupts). Klassische Vertreter hierfür sind [[8051]], PowerPC, [[X86]] und Motorola 68000.

Auf dem AVR kann man [[AVR-GCC-Tutorial#Unterbrechbare_Interruptroutinen | verschachtelte Interrupts]] sowohl in Assembler als auch in C nachbilden, allerdings mit einigen Einschränkungen und Tücken. Das ist jedoch Leuten vorbehalten, die schon viel Erfahrung auf diesem Gebiet haben. Zu 99,9% braucht man sie nicht.

=== Zeitverhalten eines Timerinterrupts ===

Ein Timerinterrupt wird im allgemeinen dazu genutzt, in konstanten, periodischen Abständen bestimmte Funktionen aufzurufen. Es ist möglich, dass während eines Timerinterrupts derselbe Interrupt wieder aktiv wird, weil die Routine sehr verzweigt ist und dieses Mal sehr lange dauert.

Wenn zum Beispiel der Timerinterrupt mit einer Periodendauer von 100ms aufgerufen wird, er aber unter bestimmten Umständen 180ms benötigt, dann wird nach 100ms nach Eintritt in die ISR der Interrupt wieder aktiv, das Timer Interrupt Flag wird gesetzt. Da aber gerade ein Interrupt bearbeitet wird, wird er nicht sofort angesprungen, weil währenddessen die Interruptfunktion global gesperrt ist (beim AVR ist das I-Bit in der CPU gelöscht). Der Interrupt wird zu Ende bearbeitet, die CPU springt zurück zum Hauptprogramm. Dabei werden die Interrupts wieder global eingeschaltet. Der zwischenzeitlich eingetroffene und zwischengespeicherte Interrupt wird nun sofort ausgeführt, sodass das Hauptprogramm praktisch gar nicht weiter kommt, bestenfalls einen Maschinenbefehl. Nun sind aber nur noch 20ms bis zum nächsten Timerinterrupt übrig. Wenn dieser nun wieder 180 ms benötigt werden in dieser Zeit aber '''zwei''' Interrupts ausgelöst, nach 20ms und 120ms. Da diese aber nicht gezählt oder andersweitig einzeln gespeichert werden können, geht ein Interrupt verloren. Das ist ein Programmfehler.

=== Zeitverhalten des UART Empfangsinterrupts ===

Ein [[UART]] Interrupt zum Empfang von Daten per [[RS232]] mit 115200 [[Baud]] ist ein recht häufiges Ereignis (1 Zeichen = 10 Bits = 86,8μs). Wenn kontinuierlich Daten empfangen werden, wird nach jeweils 86,8μs ein neuer Interrupt ausgelöst. Dabei wird das empfangene Datenbyte vom UART aus dem Empfangsschiebegregister in einem Puffer kopiert. Während das neue Zeichen Bit für Bit empfangen wird, wird es zunächst im Schieberegister des UART gespeichert. Die Daten im Puffer bleiben davon unberührt. Die CPU muss nun schnell das empfangene Datenbyte aus dem Empfangsbuffer auslesen. Die maximale Verzögerung, die sich die CPU erlauben kann von der Aktivierung des Interrupts bis zum tatsächlichen Auslesen des Datenregisters beträgt ziemlich genau die Übertragungszeit von einem Zeichen. Wenn bis dahin nicht das Zeichen von der CPU ausgelesen wurde, wird es vom UART überschrieben und ein Fehler im Statusregister des UART signalisiert (Overrun, Überlauf des Datenpuffers). Die UARTs in heutigen Mikrocontrollern haben mindestens ein Byte Puffer wie hier beschrieben. Die neueren [[AVR]]s haben sogar effektiv 3 Byte Puffer im UART, praktisch ein kleines [[FIFO]], womit der Datenempfang besser gepuffert werden kann, wenn die CPU gerade mit anderen sehr wichtigen Dingen beschäftigt ist. D.h. kurzzeitig kann sich die CPU erlauben, die Übertragungszeit von bis zu drei Zeichen zu warten, ehe sie die Daten ausliest. Dann müssen sie aber sehr schnell hintereinander gelesen werden. Im Mittel hat die CPU aber nur die Übertragungszeit eines Zeichens zur Verfügung, um es abzuholen.

=== Zusammenfassung ===

Interruptserviceroutinen:
* sollten so kurz wie möglich gehalten werden
* können im Einzelfall nahezu doppelt so lange dauern wie die kürzeste Periodendauer des Ereignisses, ohne dass Interrupts verloren gehen (z.B. Timerinterrupt).
* dürfen im Mittel maximal solange dauern wie die kürzeste Periodendauer des Ereignisses
* dürfen maximal solange dauern, wie die kürzeste Periodendauer des Ereignisses, wenn man auf Nummer sicher gehen will, dass keine Interrupts verschluckt werden
* Die Interruptzeit versteht sich immer abzüglich einer kleinen Reserve für das Anspringen und Verlassen des Interrupt minus Panikreserve

== Beispiele für die praktische Programmierung ==

Die Beispiele sind mit WINAVR 20060421 compiliert und getestet worden. Als Mikrocontroller wird ein AVR vom Typ ATmega32 verwendet. Alle Programme wurden mit Optimierungsstufe -Os compiliert.

=== Steuersignale zwischen ISR und Hauptprogramm ===

In vielen Anwendungen wird ein Timer verwendet, um in regelmässigen Abständen bestimmte Aktionen auszuführen, wie z.B. Tasten abfragen, ADC-auslesen, ein LCD auffrischen etc. Wenn viele Dinge zu erledigen sind, nebenbei aber noch andere Interrupts verwendet werden, dann ist es notwendig die Funktionsaufrufe aus dem Timerinterrupt in die Hauptschleife zu verlagern. Der Interrupt signalisiert über eine Steuervariable (engl. Flag, Flagge), das ein neuer Timerzyklus begonnen hat. Dadurch wird der Timerinterrupt sehr kurz und die langwierigen, aber meist nicht zeitkritischen Funktionen werden als normales Programm ausgeführt. Damit kann die CPU auf andere Interrupts schnell reagieren.

Wichtig ist auf jeden Fall, dass die Steuervariable, welche in der ISR und in der Hauptschleife verwendet wird, mit [http://www.netrino.com/Embedded-Systems/How-To/C-Volatile-Keyword '''volatile'''] deklariert wird. Ausserdem muss sowohl der Lese- als auch Schreibzugriff auf die Steuersignale [[#Atomarer Datenzugriff | '''atomar''']] sein. Auf dem AVR ist das mit 8 Bit Variablen direkt möglich, für grössere Variablen müssen die Interrupts kurzzeitig gesperrt werden.

Das Beispiel ist sehr einfach gehalten um das Prinzip zu veranschaulichen. Ein Timer mit einer Überlaufperiodendauer von ca. 65ms stösst periodisch eine Funktion zum Togglen einer LED an, welche dadurch mit ca. 7 Hz blinkt.

<c>
/*
*******************************************************************************
*
* Timer Interrupt Demo
*
* ATmega32 mit internem 1 MHz Oszillator
*
* LOW Fuse Byte = 0xE1
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
*
*******************************************************************************
*/

#define F_CPU 1000000

#include <avr/io.h>
#include <avr/interrupt.h>

// globale Variablen

volatile uint8_t flag;

int main() {

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFF;

// Timer2 konfigurieren

TCCR2 = 6; // Vorteiler 256 -> ~65ms Überlaufperiode
TIMSK |= (1<<TOIE2); // Timer Overflow Interrupt freischalten

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {
if (flag == 1) { // Neuer Timerzyklus ?
flag = 0;

// hier steht jetzt in Normalfall ein grosser Programmblock ;-)
PORTD ^= (1 << PD5); // LED toggeln
}
}
}

// Timer2 overflow Interrupt
// hier wird der Hauptschleife ein neuer Timerinterrupt signalisiert

ISR( TIMER2_OVF_vect ) {
flag = 1;
}
</c>

=== UART mit Interrupts ===

Der UART ist ein oft benutztes Modul eines Mikrocontrollers. Anfänger nutzen ihn meist im sogenannten Polling Betrieb (engl. to poll, abfragen). D.h. wenn ein Zeichen empfangen werden soll, fragt eine Funktion den UART in einer Schleife ununterbrochen ab, ob Daten empfangen wurden. In dieser Zeit macht die CPU nichts anderes! Und wenn lange kein Zeichen eintrifft tut sie sehr lange nichts, sie ist praktisch blockiert! Senden verläuft ähnlich, nur dass hier die CPU vor dem Senden prüft, ob der UART ein neues Byte aufnehmen kann. D.h. während der UART selbsttätig das Zeichen sendet ist die CPU zum Warten verdammt. All diese Nachteile haben nur einen Vorteil. Die Funktionen und Mechanismen zur UART-Nutzung sind sehr einfach, klein und leicht anwendbar.

Will man aber die CPU nicht sinnlos warten lassen, was vor allem bei niedrigeren Baudraten ziemlich lange sein kann, muss man die Interrupts nutzen. Der AVR hat gleich drei davon.

* '''RXC''' (Receive Complete): Ein Zeichen wurde empfangen.
* '''UDRE''' (UART Data Register Empty): Der Zwischenpuffer des Senders ist leer und kann ein neues Zeichen aufnehmen. Dieser Zwischenpuffer ist wichtig, um lückenlos auch bei hohen Baudraten senden zu können.
* '''TXC''' (Transmit Complete): Das aktuelle Zeichen wurde vollständig inclusive Stopbit gesendet und es liegt kein neues Datenbyte im Sendepuffer. Dieser Interrupt ist extrem nützlich für eine Halbduplexkommunikation, z.B. auf einem RS485-[[Bus]]. Hier kann man nach dem vollständigen Senden aller Bytes den Bustranceiver (z.B. MAX485) von Senden auf Empfangen umschalten, um den Bus freizugeben.

Bei Nutzung der Interrupts kann die CPU andere Dinge bearbeiten und muss nur kurz einen Interrupt ausführen, wenn ein Zeichen empfangen oder gesendet wurde.

Die Kommunikation zwischen ISRs und Hauptschleife erfolgt wieder durch Flags und zwei Pufferarrays (uart_rx_buffer und uart_tx_buffer). Es gibt zwei Funktionen, eine zum Senden von Strings, eine zum Empfangen. Das Senden sowie Empfangen kann parallel erfolgen und läuft vollkommen unabhängig vom Hauptprogramm. Die Daten werden in spezielle Puffer kopiert, sodass das Hauptprogramm mit seinen Strings sofort weiterarbeiten kann. Im Beispiel ist die CPU nicht wirklich mit sinnvollen Dingen beschäftigt, zur Demonstration des Prinzips aber ausreichend.

Um das das Programm real zu nutzen braucht man ein Terminalprogramm, z.B. Hyperterminal von Windows. Dort muss nur die richtige Baudrate eingestellt werden (9600 8N1, 9600 Baud, 8 Bits, keine Parität, 1 Stopbit, keine Flusskontrolle). Ausserdem muss man im Menu Datei -> Eigenschaften -> Einstellungen -> ASCII Konfiguration den Punkt "Eingegebene Zeichen lokal ausgeben (lokales Echo)" aktivieren. Nun kann man beliebige Texte eintippen. Mit RETURN wird die Eingabe abgeschlossen und der AVR vermittelt den empfangenen String an das Hauptprogramm. Diese sendet ihn einfach zurück, paralle dazu wird der String gemorst per LED angezeigt. Sollte es Probleme bei der Inbetriebnahme des UART geben, so findet man hier wichtige Hinweise zur [[AVR_Checkliste#UART.2FUSART | Fehlersuche]].

<c>
/*
*******************************************************************************
*
* UART Interrupt Demo
*
* ATmega32 mit 3,6864 MHz Quarz an XTAL1/XTAL2
*
* LOW Fuse Byte = 0xFF
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
* An PD0/PD1 ist ein MAX232 angeschlosssen, um Daten vom PC zu empfangen/senden
*
*******************************************************************************
*/

// Systemtakt in Hz, das L am Ende ist wichtig, NICHT UL verwenden!
#define F_CPU 3686400L
// "Morsedauer" für ein Bit in Millisekunden
#define BITZEIT 100

#include <string.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Baudrate, das L am Ende ist wichtig, NICHT UL verwenden!
#define BAUD 9600L

// Berechnungen
// clever runden
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)
// Reale Baudrate
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))
// Fehler in Promille
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000)

#if ((BAUD_ERROR>10) || (BAUD_ERROR<-10))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif

// globale Variablen für den UART

// Puffergrösse in Bytes, RX und TX sind gleich gross
#define uart_buffer_size 32

volatile uint8_t uart_rx_flag=0; // Flag, String komplett empfangen
volatile uint8_t uart_tx_flag=1; // Flag, String komplett gesendet
char uart_rx_buffer[uart_buffer_size]; // Empfangspuffer
char uart_tx_buffer[uart_buffer_size]; // Sendepuffer

// lange, variable Wartezeit, Einheit in Millisekunden
void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

// einen String senden
// vor Aufruf der Funktion muss man prüfen, ob uart_t_flag==1 ist
// nur dann kann ein neuer String gesendet werden

void put_string(char *daten) {

if (uart_tx_flag==1) {
// String daten ind en Sendepuffer kopieren
strcpy(uart_tx_buffer, daten);
// Flag für 'Senden ist komplett' löschen,
uart_tx_flag = 0;
// UDRE Interrupt einschalten, los gehts
UCSRB |= (1<<UDRIE);
}
}

// einen empfangenen String kopieren
// vor Aufruf der Funktion muss man prüfen, ob uart_rx_flag==1 ist
// anderenfalls ist der RX Buffer noch ungültig

void get_string(char *daten) {

if (uart_rx_flag==1) {
// String kopieren
strcpy(daten, uart_rx_buffer);
// Flag löschen
uart_rx_flag = 0;
}
}

// Ein Byte im RS232 Format auf eine LED ausgeben

void morse(uint8_t data) {
uint8_t i;

// Startbit, immer 0
PORTD &= ~(1 << PD5); // LED aus
long_delay(BITZEIT);

for(i=0; i<8; i++) {
if (data & 0x01) // Prüfe Bit #0
PORTD |= (1 << PD5); // LED an
else
PORTD &= ~(1 << PD5); // LED aus
long_delay(BITZEIT);
data >>= 1; // nächstes Bit auf Bit #0 schieben
}
// Stopbit, immer 1
PORTD |= (1 << PD5); // LED an
long_delay(BITZEIT);
}

// Hauptprogramm

int main (void) {

char stringbuffer[64]; // Allgemeiner Puffer für Strings
uint8_t buffer_full=0; // noch ein Flag, aber nur in der Hauptschleife
char * charpointer; // Hilfszeiger

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFF;

// UART konfigurieren

UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
UCSRB = (1<<RXCIE) | (1<<RXEN) | (1<<TXEN);

// Stringpuffer initialisieren

stringbuffer[0] = '\n';
stringbuffer[1] = '\r';

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {

// "Sinnvolle" CPU Tätigkeit
PORTD &= ~(1<<PD5);
long_delay(300);
PORTD |= (1<<PD5);
long_delay(300);

// Wurde ein kompletter String empfangen
// und der Buffer ist leer?
if (uart_rx_flag==1 && buffer_full==0) {
// ja, dann String lesen,
// die ersten zwei Zeichen
// aber nicht überschreiben
get_string(stringbuffer+2);
buffer_full=1;
}

// Ist letzte Stringsendung abgeschlossen
// und ein neuer String verfügbar?
if (uart_tx_flag==1 && buffer_full==1) {
// Newline + Carrige return anfügen
strcat(stringbuffer, "\n\r");
put_string(stringbuffer); // zurücksenden
buffer_full=0; // Buffer ist wieder verfügbar
// Alle Zeichen per LED morsen
charpointer = stringbuffer;
while(*charpointer) morse(*charpointer++);
}
}
}

// UART RX complete interrupt

// hier werden Daten vom PC empfangen und in einem String zwischengespeichert
// Wird ein Stringterminator empfangen, wird ein Flag gesetzt, welches dem
// Hauptprogramm den kompletten Empfang signalisiert

ISR(USART_RXC_vect) {

static uint8_t uart_rx_cnt; // Zähler für empfangene Zeichen
uint8_t data;

// Daten auslesen, dadurch wird das Interruptflag gelöscht
data = UDR;

// Ist Puffer frei für neue Daten?
if (!uart_rx_flag) {
// ja, ist Ende des Strings (RETURN) erreicht?
if (data=='\r') {
// ja, dann String terminieren
uart_rx_buffer[uart_rx_cnt]=0;
// Flag für 'Empfangspuffer voll' setzen
uart_rx_flag=1;
// Zähler zurücksetzen
uart_rx_cnt=0;
}
else if (uart_rx_cnt<(uart_buffer_size-1)) {
// Daten in Puffer speichern
// aber durch if() Pufferüberlauf vermeiden
uart_rx_buffer[uart_rx_cnt]=data;
uart_rx_cnt++; // Zähler erhöhen
}
}
}

// UART TX data register empty interrupt
// hier werden neue Daten in das UART Senderegister geladen

ISR(USART_UDRE_vect) {
// Zeiger auf Sendepuffer
static char* uart_tx_p = uart_tx_buffer;
uint8_t data;

// zu sendendes Zeichen lesen,
// Zeiger auf Sendepuffer erhöhen
data = *uart_tx_p++;

// Ende des nullterminierten Strings erreicht?
if (data==0 ) {
UCSRB &= ~(1<<UDRIE); // ja, dann UDRE Interrupt ausschalten
uart_tx_p = uart_tx_buffer; // Pointer zurücksetzen
uart_tx_flag = 1; // Flag setzen, Übertragung beeendet
}
else UDR = data; // nein, Daten senden
}
</c>

=== Wie lange dauert meine Interruptroutine ? ===

Diese Frage sollte man beantworten können, zumindest sollte eine Worst Case Abschätzung gemacht werden. Das geht auf zwei Wegen.

* Simulation, dabei muss in einer verzweigten ISR der längste Pfad simuliert werden. Dazu müssen alle beteiligten Variablen auf den ensprechenden Wert gesetzt werden.
* Messung mit dem [[Oszilloskop]], dabei wird zum Beginn der ISR ein Pin auf HIGH gesetzt und am Ende auf LOW. Damit kann man in Echtzeit die Dauer der ISR messen. Die zusätzlichen Taktzyklen zum Aufruf und verlassen der ISR sind konstant und im wesentlichen bekannt. Mit einem modernen Digitaloszilloskop und dem "Infinite Persistence Mode" kann man eine Worst Case Messung vornehmen

Als Hilfmittel zur Fehlersuche kann man auch am Ende der ISR prüfen, ob das jeweilige Interrupt-Request Bit schon wieder gesetzt ist. Wenn ja, dann ist die ISR in den meisten Fällen zu lang. Auch hier kann man einen Ausgang auf HIGH setzen und somit den Fehler anzeigen.

==Interruptfeste Programmierung==

=== Atomarer Datenzugriff ===

Von einem atomaren (engl. atomic) Datenzugriff spricht man, wenn der Zugriff innerhalb einer nicht unterbrechbaren Maschinenanweisung abgearbeitet wird.

Alle Variablen, Steuerregister und I/O-Ports, die sowohl im Hauptprogramm als auch in Interrupts verwendet werden, sind mit viel Sorgfalt zu behandeln.

Beispiel:
<c>
port |= 0x03;
</c>
übersetzt sich auf AVR Prozessoren in
<avrasm>
IN r16,port
ORI r16,0x03
OUT port,r16
</avrasm>
Wenn nun zwischen IN und OUT ein Interrupt auftritt, der beispielsweise Bit 7 verändert, dann geht mit dem OUT-Befehl diese Änderung verloren, da der OUT Befehl den alten Zustand vor dem Interrupt wiederherstellt.

'''Gefährlich ist das insbesondere deshalb, weil der Fall nur selten auftritt und dies Verhalten sehr schlecht reproduzierbar ist.'''

Bei verschiedenen Prozessor-Architekturen tritt das Problem verschieden häufig auf. So übersetzt sich obiger Code bei MSP430 Prozessoren in einen einzelnen Befehl
<pre>
OR #0x03,port
</pre>
und stellt somit kein Problem dar. Im Zweifel hilft nur ein Blick in den erzeugten Assembler-Code. Bei der Übernahme fremden Codes ist dies zu beachten. Was bei i51 kein Problem war, kann bei AVR zu einem Problem werden, unter Umständen sogar abhängig von verwendeten Port sein.

Ein ähnliches Problem entsteht bei Variablen, deren Grösse die Wortbreite der Maschine übersteigt. Bei 8-Bit-Prozessoren wie AVR oder i51 also bereits bei normalen "int" Variablen. Diese Variablen werden zwangsläufig byteweise verarbeitet. Wenn genau dazwischen ein Interrupt erfolgt, wird ein falscher Wert gelesen. Wenn beispielsweise eine Interrupt-Routine einen 16-Bit-Zähler verwendet und von 0x00FF auf 0x0100 hochzählt, dann kann das Hauptprogramm auch schon mal versehentlich die Werte 0x01FF oder 0x0000 lesen.

Dies ist auch ein Grund, weshalb für Programmierung auf derart "niedriger" Ebene Kenntnisse in Prozessorarchitektur und Assembler-Programmierung sehr hilfreich sind.

'''Abhilfe''': Wenn man sich nicht wirklich ganz sicher ist, sollten um kritische Aktivitäten herum jedesmal die Interrupts abgeschaltet werden.

Beispiel ([[AVR-GCC]]):
<c>
cli(); // Interrupts abschalten
port |= 0x03;
sei(); // Interrupts wieder einschalten
</c>

Wenn man ein globales Einschalten der Interrupts mit sei() vermeiden will, kann man die folgende Methode benutzen. Hierbei werden die Interrupts nur eingeschaltet, wenn sie vorher bereits eingeschaltet waren (Hinweis aus der FAQ von avr-libc):

<c>
{
// ...
{
uint8_t sreg; // Lokale Sicherungskopie von SREG
sreg = SREG;
cli();
// hierhin kommt der Code mit atomarem Zugriff
SREG = sreg;
}
// ...
}
</c>

Je nach Prozessor kann man das Problem manchmal auch ohne Abschalten von Interrupts durch geeignete Programmierung lösen. So führt
<c>
port = (port & ~0x0F) | lcd_data;
</c>
immer zum beschriebenen Problem,
<c>
port &= ~0x0F;
port |= lcd_data;
</c>
jedoch nicht, wenn die beiden Zeilen zu jeweils einem Assembler-Befehl übersetzt werden. Was dann aber abhängig von den Optimierungs-Einstellungen des Compilers werden kann. Eine Interrupt-feste Variante für AVR-Prozessoren der neuesten Generation, wie beispielsweise Tiny2313 und Mega88 (alle ab 2004):
<c>
PINx = (PORTx & 0x0F) ^ lcd_data;
</c>

=== Reentrante Funktionen ===

Eine Funktion ist reentrant (wiedereintrittsfest), wenn sie mehrmals gleichzeitig aktiv sein kann, ohne dass sich diese Aufrufe gegenseitig beeinflussen. Betrifft beispielsweise Funktionen, die sowohl im Hauptprogramm als auch in Interrupts aufgerufen werden. Manche C Compiler erfordern eine besondere Kennzeichnung solcher Funktionen. Wenn möglich sollte man es jedoch vermeiden, eine Funktion aus dem Hauptprogramm '''und''' aus einem Interrupt aus aufzurufen. Das ist meist problemlos machbar.

== Siehe auch ==
* [[Timer]]
* [[AVR-Tutorial: Interrupts | AVR-Tutorial - Interrupts in Assembler]]
* [[AVR-GCC-Tutorial#Programmieren_mit_Interrupts | AVR-GCC-Tutorial - Interrupts in C]]
* [[ADC]]

AVR-Tutorial: Vergleiche

2007-12-25T18:52:43Z

FalkB: /* CPC - Compare with Carry */

Vergleiche und Entscheidungen sind in jeder Programmiersprache ein zentrales Mittel um den Programmfluss abhängig von Bedingungen zu kontrollieren. In einem [[AVR]] spielen dazu 3 Komponenten zusammen:
* Vergleichsbefehle
* die Flags im Statusregister
* bedingte Sprungbefehle

Der Zusammenhang ist dabei folgender: Die Vergleichsbefehle führen einen Vergleich durch, zum Beispiel zwischen zwei Registern oder zwischen einem Register und einer Konstante. Das Ergebnis des Vergleiches wird in den Flags abgelegt. Die bedingten Sprungbefehle werten die Flags aus und führen bei einem positiven Ergebnis den Sprung aus. Besonders der erste Satzteil ist wichtig! Den bedingten Sprungbefehlen ist es nämlich völlig egal, ob die Flags über Vergleichsbefehle oder über sonstige Befehle gesetzt wurden. Die Sprungbefehle werten einfach nur die Flags aus, wie auch immer diese zu ihrem Zustand kommen.

==Flags==

Die Flags residieren im Statusregister '''SREG'''. Ihre Aufgabe ist es, das Auftreten bestimmter Ereignisse, die während Berechnungen eintreten können festzuhalten.

+---+---+---+---+---+---+---+---+
| I | T | H | S | V | N | Z | C |
+---+---+---+---+---+---+---+---+

===Carry (C)===
Das Carry Flag hält fest, ob ein Überlauf oder Unterlauf bei einer 8-Bit Berechnung statt gefunden hat.

===Zero (Z)===
Das Zero Flag hält fest, ob das Ergebnis der letzten 8-Bit Berechnung 0 war oder nicht.

===Negative (N)===
Spiegelt den Zustand des höchstwertigen Bits der letzten 8-Bit Berechnung wieder. In 2-Komplement Arithmetik bedeutet ein gesetztes 7. Bit eine negative Zahl, daher der Name.

===Overflow (V)===
Dieses Bit wird gesetzt, wenn bei einer Berechnung mit 2-Komplement Arithmetik ein Überlauf (Unterlauf) stattgefunden hat. Dies entspricht einem Überlauf von Bit 6 ins Bit 7

===Signed (S)===
Das Signed Bit ist eine Verknüpfung aus dem N und dem V Flag. Es wird hauptsächlich für 'Signed' Tests benötigt. Daher auch der Name.

===Half Carry (H)===
Das Half Carry Flag hat die gleiche Aufgabe wie das Carry Flag, nur beschäftigt es sich mit einem Überlauf von Bit 3 nach Bit 4. Das Haupteinsatzgebiet ist der Bereich der BCD Arithmetik.

=== Transfer (T)===
Das T-Flag wird von keiner Berechnung gesetzt, sondern steht zur ausschliesslichen Verwendung des Programmierers zur Verfügung. Damit können Bits von einer Stelle schnell an eine andere kopiert oder getestet werden.

===Interrupt (I)===
Das Interrupt Flag hat ebenfalls nichts mit Vergleichen zu tun, sondern steuert ob Interrupts systemweit zugelassen sind (siehe [[AVR-Tutorial: Interrupts]]).

==Vergleiche==
Um einen Vergleich durchzuführen, wird intern eine Subtraktion der beiden Operanden durchgeführt. Das eigentliche Ergebnis der Subtraktion wird allerdings verworfen, es bleibt nur die neue Belegung der Flags übrig, die in weiterer Folge ausgewertet werden kann

===CP - Compare===
Vergleicht den Inhalt zweier Register miteinander. Prozessorintern wird dabei eine Subtraktion der beiden Register durchgeführt. Das eigentliche Subtraktionsergebnis wird allerdings verworfen, das Subtraktionsergebnis beeinflusst lediglich die Flags.

===CPC - Compare with Carry===
Vergleicht den Inhalt zweier Register, wobei das Carry Flag in den Vergleich mit einbezogen wird. Dieser Befehl wird für Arithmetik mit grossen Variablen (16/32 Bit) benötigt. Siehe [[AVR-Tutorial: Arithmetik]].

===CPI - Compare Immediate===
Vergleicht den Inhalt eines Registers mit einer direkt angegebenen Konstanten. Der Befehl ist nur auf die Register r16..r31 anwendbar.

==Bedingte Sprünge==

Die bedingten Sprünge werten immer bestimmte Flags im Statusregister '''SREG''' aus. Es spielt dabei keine Rolle, ob dies nach einem Vergleichsbefehl oder einem sonstigen Befehl gemacht wird. Entscheidend ist einzig und alleine der Zustand des abgefragten Flags. Die Namen der Sprungbefehle wurden allerdings so gewählt, daß sich im Befehlsnamen die Beziehung der Operanden direkt nach einem Compare Befehl wiederspiegelt. Zu beachten ist auch, daß die Flags nicht nur durch Vergleichsbefehle verändert werden, sondern auch durch arithmetische Operationen, Schiebebefehle und logische [[Bitmanipulation | Verknüpfungen]]. Da dieses Information wichtig ist, ist auch in der bei Atmel erhältlichen [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf Übersicht über alle Assemblerbefehle] bei jedem Befehl angegeben, ob und wie er Flags beeinflusst. Ebenso ist dort eine kompakte Übersicht aller bedingten Sprünge zu finden. Beachten muss man jedoch, dass die bedingten Sprünge maximal 64 Worte weit springen können.

=== Bedingte Sprünge für vorzeichenlose Zahlen ===

====BRSH - Branch if Same or Higher ====

Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' nicht gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann statt, wenn der erste Operand größer oder gleich dem zweiten Operanden ist.

====BRLO - Branch if Lower ====

Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann statt, wenn der erste Operand kleiner dem zweiten Operanden ist.

=== Bedingte Sprünge für vorzeichenbehaftete Zahlen ===

====BRGE - Branch if Greater or Equal ====
Der Sprung wird durchgeführt, wenn das '''Signed Flag (S)''' nicht gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' eingesetzt, so findet der Sprung dann und nur dann statt, wenn der zweite Operand größer oder gleich dem ersten Operanden ist.

====BRLT - Branch if Less Than ====
Der Sprung wird durchgeführt, wenn das '''Signed Flag (S)''' gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann und nur dann statt, wenn der zweite Operand kleiner als der erste Operand ist.

====BRMI - Branch if Minus====
Der Sprung wird durchgeführt, wenn das '''Negativ Flag (N)''' gesetzt ist, das Ergbnis der letzen Operation also negativ war.

====BRPL - Branch if Plus====
Der Sprung wird durchgeführt, wenn das '''Negativ Flag (N)''' nicht gesetzt ist, das Ergbnis der letzen Operation also positiv war (einschiesslich Null).

=== Sonstige bedingte Sprünge ===

====BREQ - Branch if Equal====
Der Sprung wird durchgeführt, wenn das '''Zero Flag (Z)''' gesetzt ist. Ist nach einem Vergleich das Zero Flag gesetzt, lieferte die interne Subtraktion also 0, so waren beide Operanden gleich.

====BRNE - Branch if Not Equal====
Der Sprung wird durchgeführt, wenn das '''Zero Flag (Z)''' nicht gesetzt ist. Ist nach einem Vergleich das Zero Flag nicht gesetzt, lieferte die interne Subtraktion also nicht 0, so waren beide Operanden verschieden.

====BRCC - Branch if Carry Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' nicht gesetzt ist. Dieser Befehl wird oft für Arithmetik mit grossen Variablen (16/32 Bit) bzw. im Zusammenhang mit Schiebeoperatioen verwendet.

====BRCS - Branch if Carry Flag is Set====
Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' gesetzt ist. Die Verwendung ist sehr ähnlich zu BRCC.

=== Selten verwendete bedingte Sprünge ===

====BRHC - Branch if Half Carry Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''Half Carry Flag (H)''' nicht gesetzt ist.

====BRHS - Branch if Half Carry Flag is Set====
Der Sprung wird durchgeführt, wenn das '''Half Carry Flag (H)''' gesetzt ist.

====BRID - Branch if Global Interrupt is Disabled (Cleared)====
Der Sprung wird durchgeführt, wenn das '''Interrupt Flag (I)''' nicht gesetzt ist.

====BRIS - Branch if Global Interrupt is Enabled (Set)====
Der Sprung wird durchgeführt, wenn das '''Interrupt Flag (I)''' gesetzt ist.

====BRTC - Branch if T Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''(T)''' nicht gesetzt ist.

====BRTS - Branch if T Flag is Set====
Der Sprung wird durchgeführt, wenn das '''(T)''' gesetzt ist.

====BRVC - Branch if Overflow Cleared====
Der Sprung wird durchgeführt, wenn das '''Overflow Flag (V)''' nicht gesetzt ist.

====BRVS - Branch if Overflow Set====
Der Sprung wird durchgeführt, wenn das '''Overflow Flag (V)''' gesetzt ist.

==Beispiele==

=== Entscheidungen ===

In jedem Programm kommt früher oder später das Problem, die Ausführung von Codeteilen von irgendwelchen Zahlenwerten, die sich in anderen Registern befinden abhängig zu machen. Sieht beispielweise die Aufgabe vor, daß Register r18 auf 0 gesetzt werden soll, wenn im Register r17 der Zahlenwert 25 enthalten ist, dann lautet der Code

<avrasm>
cpi r17, 25 ; vergleiche r17 mit der Konstante 25
brne nicht_gleich ; wenn nicht gleich, dann mach bei nicht_gleich weiter
ldi r18, 0 ; hier stehen nun Anweisungen für den Fall
; dass R17 gleich 25 ist
rjmp weiter ; meist will man den anderen Zeig nicht durchlaufen, darum der Sprung
nicht_gleich:
ldi r18,123 ; hier stehen nun Anweisungen für den Fall
; dass R17 ungleich 25 ist
weiter: ; hier geht das Programm weiter
</avrasm>

In ähnlicher Weise können die anderen bedingten Sprungbefehle eingesetzt werden, um die üblicherweise vorkommenden Vergleiche auf Gleichheit, Ungleichheit, Größer, Kleiner zu realisieren.

===Schleifenkonstrukte===

Ein immer wiederkehrendes Muster in der Programmierung ist eine '''Schleife'''. Die einfachste Form einer Schleife ist die '''Zählschleife'''. Dabei wird ein Register von einem Startwert ausgehend eine gewisse Anzahl erhöht, bis ein Endwert erreicht wird.

<avrasm>
ldi r17, 10 ; der Startwert sei in diesem Beispiel 10
loop:
; an dieser Stelle stehen die Befehle, welche innerhalb der Schleife
; mehrfach ausgeführt werden sollen

inc r17 ; erhöhe das Zaehlregister
cpi r17, 134 ; mit dem Endwert vergleichen
brne loop ; und wenn der Endwert noch nicht erricht ist
; wird bei der Marke loop ein weiterer Schleifendurchlauf ausgeführt
</avrasm>

Sehr oft ist es auch möglich das Konstrukt umzudrehen. Anstatt von einem Startwert aus zu inkrementieren genügt es die Anzahl der gewünschten Schleifendurchläufe in ein Register zu laden und dieses Register zu dekrementieren. Dabei kann man von der Eigenschaft der Dekrementieranweisung gebrauch machen, das '''Zero Flag (Z)''' zu beeinflussen. Ist das Ergebnis des Dekrements 0, so wird das '''Zero Flag (Z)''' gesetzt, welches wiederum in der nachfolgenden '''BRNE''' Anweisung für einen bedingen Sprung benutzt werden kann. Das vereinfacht die Schleife und spart eine Anweisung sowie einen Takt Ausführungzeit.

<avrasm>
ldi r17, 124 ; Die Anzahl der Wiederholungen in ein Register laden
loop:
; an dieser Stelle stehen die Befehle, welche innerhalb der Schleife
; mehrfach ausgeführt werden sollen

dec r17 ; Schleifenzähler um 1 verringern, dabei wird das Zero Flag beeinflusst
brne loop ; wenn r17 noch nicht 0 geworden ist -> Schleife wiederholen
</avrasm>

{{Navigation_zurückhochvor|
zurücktext=Interrupts|
zurücklink=AVR-Tutorial: Interrupts|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Mehrfachverzweigungen|
vorlink=AVR-Tutorial: Mehrfachverzweigung}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Mehrfachverzweigung

2007-12-25T17:46:44Z

FalkB: /* Einfacher Ansatz */

== Einleitung ==

Oft ist es in einem Programm notwendig, eine Variable auf mehrere Werte zu prüfen und abhängig vom Ergebniss verschiedene Aktionen auszuösen. Diese Konstruktion nennt man Mehrfachverzweigung. In einem Struktogramm sieht das so aus.

[[bild:mv_struktogramm.png]]

In C gibt es direkt dafür eine Konstruktion namens '''switch'''.

<c>
switch (variable) {
case 1: // Anweisungen für diesen Zeig, wenn variable == 1
break;
case 17: // Anweisungen für diesen Zeig, wenn variable == 17
break;
case 33: // Anweisungen für diesen Zeig, wenn variable == 33
break;
case 9: // Anweisungen für diesen Zeig, wenn variable == 9
break;
case 22: // Anweisungen für diesen Zeig, wenn variable == 22
break;
default: // Anweisungen wenn keine der oben definierten Bedingungen erfüllt ist
break;
}
</c>

In Assembler muss man so etwas "zu Fuß" programmieren. Die verschiedenen Lösungen sollen hier betrachtet werden.

== Einfacher Ansatz ==

Im einfachsten Fall verwendet man eine lange Kette von '''cpi''' und '''breq''' Befehlen. Für jeden Zweig benötigt man zwei Befehle.

<avrasm>
; Mehrfachverzeigung Version A

; Einfacher Ansatz, mit vielen CPI

start_vergleich:

cpi r16,1
brne zweig_0

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=1

rjmp ende_vergleich
zweig_0:
cpi r16,17
brne zweig_1

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=17

rjmp ende_vergleich
zweig_1:
cpi r16,33
brne zweig_2

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=33

rjmp ende_vergleich
zweig_2:
cpi r16,9
brne zweig_3

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=9

rjmp ende_vergleich
zweig_3:
cpi r16,22
brne kein_Treffer

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=22

rjmp ende_vergleich
kein_Treffer:

; hier stehen jetzt alle Anweisungen für den Fall, dass keiner der Vergleiche erfolgreich war

ende_vergleich:

rjmp ende_vergleich ; nur für Simulationszwecke! ENTFERNEN!
</avrasm>
'''Eigenschaften'''
* Programmspeicherbedarf: 6*N Bytes (N = Anzahl der Zweige)

'''Vorteile'''
* leicht verständlich
* Es können beliebige Vergleichswerte geprüft werden

'''Nachteile'''
* relativ hoher Programmspeicherbedarf
* die Größe der Zweige ist stark begrenzt, weil der Befehl '''breq''' maximal 63 Worte weit springen kann!
* die einzelnen Zweige haben unterschiedliche Durchlaufzeiten, der letzte Zweig ist am langsamsten
* nur bedingt übersichtlicher Quellcode

== Sprungtabelle ==

Oft liegen die einzelnen Vergleichswerte nebeneinander (z.B. 7..15), z.B. bei der Übergabe von Parametern, Zustandsautomaten, Menueinträgen etc. . In so einem Fall kann man mittels einer '''Sprungtabelle''' das Programm verkürzen, beschleunigen und übersichtlicher gestalten.

<avrasm>
.include "m8def.inc"

; Mehrfachverzweigung Version B

; Clevere Version mit Sprungtabelle
; minimum und maximum sind auf 0..255 begrenzt!

.equ minimum = 3
.equ maximum = 7

start_vergleich:

subi r16,minimum ; Nullpunkt verschieben
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
ldi ZL,low(Sprungtabelle) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle)
add ZL,r16 ; Index addieren, 16 Bit
ldi r16,0
adc ZH,r16
ijmp ; indirekter Sprung in Sprungtabelle

kein_treffer:

; hier stehen jetzt alle Anweisungen für den Fall, dass keiner der Vergleiche erfolgreich war

rjmp ende_vergleich

Sprungtabelle:
rjmp zweig_0
rjmp zweig_1
rjmp zweig_2
rjmp zweig_3
rjmp zweig_4

zweig_0:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

zweig_1:

; hier stehen jetzt alle Awneisungen für diesen Zweig

rjmp ende_vergleich

zweig_2:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

zweig_3:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

zweig_4:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

ende_vergleich:

; hier geht das Programm weiter

rjmp ende_vergleich ; nur für Simulationszwecke! ENTFERNEN!
</avrasm>

''' Programmbeschreibung ''' 
Wie ist dieses Programm nun zu verstehen? Das Prinzip beruht darauf, daß in einer gleichmässigen Tabelle Sprungbefehle auf einzelne Programmzweige abgelegt werden. Das ist praktisch genauso wie der AVR [[AVR-Tutorial: Interrupts | Interrupts]] verarbeitet. Über einen Index (0...N) wird ein Sprungbefehl ausgewählt und ausgeführt.Der entscheidende Befehl dazu ist '''ijmp'''.

Zunächst muss der Wertebereich, auf welchen die Variable geprüft werden soll (minimum bis maximum), normiert werden (0 bis (Maximum-Minimum)). Dazu wird einfach das Minimum subtrahiert.

<avrasm>
subi r16,minimum ; Nullpunkt verschieben
</avrasm>

Danach muss geprüft werden, ob der maximale Index nicht überschritten wird. Denn ein Sprung auf nichtexistierende Einträge oberhalb der Sprungtabelle wäre fatal!

<avrasm>
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
</avrasm>

Danach muss der indirekte Sprung vorbereitet werden. Dazu wird die Adresse der Sprungtabelle in das Z-Register geladen, welches ein 16 Bit Register ist und gleichbedeutend mit r30 und r31.

<avrasm>
ldi ZL,low(Sprungtabelle) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle)
</avrasm>

Danach muss der Index addiert werden, dies ist eine 16-Bit Addition.

<avrasm>
add ZL,r16 ; Index addieren, 16 Bit
ldi r16,0
adc ZH,r16
</avrasm>

Zu guter Letzt wird der indirekte Sprung in die Sprungtabelle ausgeführt.

<avrasm>
ijmp ; indirekter Sprung in Sprungtabelle
</avrasm>

In der Sprungtabelle wird dann zum jeweiligen Zweig verzweigt.
<avrasm>
Sprungtabelle:
rjmp zweig_0
rjmp zweig_1
rjmp zweig_2
rjmp zweig_3
rjmp zweig_4
</avrasm>

Der Zweig für einen ungültigen Index folgt direkt nach dem '''ijmp''', weil der Befehl '''brsh''' nur maximal 63 Worte weit springen kann.

'''Eigenschaften'''
* Programmspeicherbedarf: 2*N +18 Bytes (N = Anzahl der Zweige)
* maximale Gesamtgröße der Zweige wird durch den Befehl rjmp begrenzt (+/-4kB). Das sollte aber nur in sehr wenigen Fällen ein Problem sein (Man wird kaum einen AVR mit 8 kB FLASH mit einer einzigen Mehrfachverzweigung füllen!)

'''Vorteile'''
* relativ niedriger Programmspeicherbedarf
* die einzelnen Zweige haben unabhängig von der Grösse der Sprungtabelle eine konstante und kurze Durchlaufzeit von 12 Takten.
* übersichtlicher Quellcode

'''Nachteile'''
* Die Vergleichswerte müssen lückenlos aufeinander folgen

== Lange Sprungtabelle ==
Wenn man doch mal eine GIGA-Mehrfachverzeigung braucht, dann hilft die Version C.

<avrasm>
.include "m16def.inc"

; Mehrfachverzweigung Version C

; Clevere Version mit langer Sprungtabelle
; funktioniert nur mit AVRs mit mehr als 8KB FLASH
; minimum und maximum sind auf 0..127 begrenzt!

.equ minimum = 3
.equ maximum = 7

start_vergleich:

subi r16,minimum ; Nullpunkt verschieben
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
ldi ZL,low(Sprungtabelle*2) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle*2)
lsl r16 ; Index mit 2 multiplizieren
add zl,r16 ; Index addieren, 16 Bit
ldi r16,0
adc zh,r16
lpm r16,Z+ ; Low Byte laden und Pointer erhöhen
lpm ZH,Z ; zweites Byte laden
mov ZL,r16 ; erstes Byte in Z-Pointer kopieren
ijmp ; indirekter Sprung

kein_treffer:

; hier stehen jetzt alle Anweisungen für den Fall, dass keiner der Vergleiche erfolgreich war

jmp ende_vergleich

Sprungtabelle:
.dw zweig_0
.dw zweig_1
.dw zweig_2
.dw zweig_3
.dw zweig_4

zweig_0:

; hier stehen jetzt alle Anweisungen für diesen Zweig

jmp ende_vergleich

zweig_1:

; hier stehen jetzt alle Awneisungen für diesen Zweig

jmp ende_vergleich

zweig_2:

; hier stehen jetzt alle Anweisungen für diesen Zweig

jmp ende_vergleich

zweig_3:

; hier stehen jetzt alle Anweisungen für diesen Zweig

jmp ende_vergleich

zweig_4:

; hier stehen jetzt alle Anweisungen für diesen Zweig

ende_vergleich:

; hier geht das Programm weiter

jmp ende_vergleich ; nur für Simulationszwecke! ENTFERNEN!
</avrasm>

''' Programmbeschreibung ''' 
Diese Version ist der Version B sehr ähnlich. Der Unterschied besteht darin, daß in Version B die Sprungtabelle mit Sprungbefehlen gefüllt ist (rjmp) während in Version C die Startadressen der Funktionen ablegt sind. D.H. man kann nicht in die Sprungtabelle springen, sondern muss sich mit Hilfe des Index die richtige Adresse aus der Sprungtabelle lesen und mit '''ijmp''' anspringen. Klingt sehr ähnlich, ist aber dennoch verschieden.

Die ersten drei Befehle sind identisch, es wird der Index normiert und auf das Maximum geprüft.
<avrasm>
subi r16,minimum ; Nullpunkt verschieben
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
</avrasm>
Die nächsten zwei Befehle laden wieder die Anfangsadresse der Sprungtabelle. Doch halt, hier wird die Adresse der Sprungtabelle mit zwei multipliziert. Des Rätsels Lösung gibt es weiter unten.
<avrasm>
ldi ZL,low(Sprungtabelle*2) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle*2)
</avrasm>
Der Index wird ebenfalls mit zwei multipliziert.
<avrasm>
lsl r16 ; Index mit 2 multiplizieren
</avrasm>
Danach erfolgt eine 16-Bit Addition.
<avrasm>
add zl,r16 ; Index addieren, 16 Bit
ldi r16,0
adc zh,r16
</avrasm>
Nun zeigt unser Z-Zeiger auf den richtigen Tabelleneintrag. Jetzt müssen zwei Bytes aus dem FLASH geladen werden. Das geschieht mit Hilfe des '''lpm'''-Befehls ('''L'''oad '''P'''rogram '''M'''emory). Hier wird die erweiterte Version des lpm-Befehls verwendet, wie sie nur auf grösseren AVRs verfügbar ist. Dabei wird ein Byte in Register r16 geladen und gleichzeitig der Z-Pointer um eins erhöht. Damit zeigt er wunderbar auf das nächste Byte, welches auch geladen werden muss.
<avrasm>
lpm r16,Z+ ; Low Byte laden und Zeiger erhöhen
</avrasm>
Der zweite lpm-Befehl ist etwas ungewöhnlich, denn er überschreibt einen Teil des Z-Pointers! In den meisten Programmen wäre das ein Schuss ins Knie (Programmierfehler!), da wir aber den Z-Pointer danach sowieso mit neuen Daten laden ist das OK.
<avrasm>
lpm ZH,Z ; zweites Byte laden
</avrasm>
Das zuerst gelesene Byte wird in den Z-Pointer kopiert. Nun steht die Startadresse des gewählten Zweigs im Z-Pointer.
<avrasm>
mov ZL,r16 ; erstes Byte in Z-zeiger kopieren
</avrasm>
Zu guter Letzt wird der indirekte Sprung ausgeführt und bringt uns direkt in den Programmzweig.
<avrasm>
ijmp ; indirekter Sprung direkt in den Programmzweig
</avrasm>

Der Zweig für einen ungültigen Index folgt direkt nach dem '''ijmp''', weil der Befehl '''brsh''' nur maximal 63 Worte weit springen kann.

'''Eigenschaften'''
* Programmspeicherbedarf: 2*N +26 Bytes (N = Anzahl der Zweige)
* unbegrenzte Sprungweite

'''Vorteile'''
* relativ niedriger Programmspeicherbedarf
* die einzelnen Zweige haben unabhängig von der Grösse der Sprungtabelle eine konstante und kurze Durchlaufzeit von 18 Takten
* übersichtlicher Quellcode

'''Nachteile'''
* Die Vergleichswerte müssen lückenlos aufeinander folgen
* geringfügig höherer Programmspeicherbedarf (8 Byte mehr) und grössere Durchlaufzeit (6 Takte mehr)als Version B

== Z-Pointer leicht verständlich ==

Auf den ersten Blick scheint es sonderbar, daß Version B die Adresse der Sprungtabelle direkt lädt, während Version C sowohl Anfangsadresse als auch Index mit zwei multipliziert. Warum ist das so?

Version B verwendet nur den Befehl '''ijmp'''. Dieser erwartet im Z-Register eine Adresse zur Programmausführung, eine '''Wort-Adresse'''. Da der Programmspeicher des AVR 16 Bit breit ist (=1 Wort = 2 Bytes), werden nur Worte adressiert, nicht jedoch Bytes! Genauso arbeitet der Assembler. Jedes Label entspricht einer Wort-Adresse. Damit kann man mit einer 12 Bit-Adresse 4096 Worte adressieren (=8192 Bytes). Wenn man sich die Befehle der einzelnen AVRs anschaut wird klar, daß alle AVRs mit 8KB und weniger FLASH nur die Befehle rjmp und rcall besitzen. Denn sie brauchen nicht mehr! Mit 12 Adressbits, welche direkt in einem Wort im Befehl rjmp bzw. rcall kodiert sind, kann der gesamte Programmspeicher erreicht werden. Größere AVRs besitzen call und jmp, dort ist die Adresse als 22 bzw. 16 Bit Zahl kodiert, deshalb brauchen diese Befehle auch 2 Worte Programmspeicher.

Der Befehl '''lpm''' dient zum laden einzelner Bytes aus dem Programmspeicher. Das ist vor allem für Tabellen mit konstanten Werten sehr nützlich (7-Segmentdekoder, Zeichensätze, Kennlinien, Parameter Texte, etc.) Doch wie kommt man nun in dem wortweise adressierten Programmspeicher an einzelne Bytes? Ganz einfach. Der AVR "mogelt" hier und erwartet im Z-Register eine '''Byte-Adresse'''. Von dieser Adresse bilden die Bits 15..1 die Wortadresse, welche zur Adressierung des Programmspeichers verwendet wird. Bit 0 entscheidet dann, ob das hoch- oder niederwertige Byte in das Zielregister kopiert werden soll (0=niederwertiges Byte; 1=höherwertiges Byte).

Darum muss bei Verwendung des Befehls lpm die Anfangsadresse immer mit zwei multipliziert werden.
<avrasm>
ldi ZL,low(Sprungtabelle*2) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle*2)
</avrasm>
In Version C muss zusätzlich der Index mit zwei multipliziert werden, weil jeder Tabelleneintrag (Adresse des Programmzweigs) ein Wort breit ist. Damit wird aus einem Index von 0,1,2,3,4 ein Offset von 0,2,4,6,8.

{{Navigation_zurückhochvor|
zurücktext=Vergleiche|
zurücklink=AVR-Tutorial: Vergleiche|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=UART|
vorlink=AVR-Tutorial: UART}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Mehrfachverzweigung

2007-12-25T17:43:53Z

FalkB: /* Einfacher Ansatz */ Beispiel verbessert

== Einleitung ==

Oft ist es in einem Programm notwendig, eine Variable auf mehrere Werte zu prüfen und abhängig vom Ergebniss verschiedene Aktionen auszuösen. Diese Konstruktion nennt man Mehrfachverzweigung. In einem Struktogramm sieht das so aus.

[[bild:mv_struktogramm.png]]

In C gibt es direkt dafür eine Konstruktion namens '''switch'''.

<c>
switch (variable) {
case 1: // Anweisungen für diesen Zeig, wenn variable == 1
break;
case 17: // Anweisungen für diesen Zeig, wenn variable == 17
break;
case 33: // Anweisungen für diesen Zeig, wenn variable == 33
break;
case 9: // Anweisungen für diesen Zeig, wenn variable == 9
break;
case 22: // Anweisungen für diesen Zeig, wenn variable == 22
break;
default: // Anweisungen wenn keine der oben definierten Bedingungen erfüllt ist
break;
}
</c>

In Assembler muss man so etwas "zu Fuß" programmieren. Die verschiedenen Lösungen sollen hier betrachtet werden.

== Einfacher Ansatz ==

Im einfachsten Fall verwendet man eine lange Kette von '''cpi''' und '''breq''' Befehlen. Für jeden Zweig benötigt man zwei Befehle.

<avrasm>
; Mehrfachverzeigung Version A

; Einfacher Ansatz, mit vielen CPI

start_vergleich:

cpi r16,7
brne zweig_0

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=7

zweig_0:
cpi r16,5
brne zweig_1

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=5

rjmp ende_vergleich
zweig_1:
cpi r16,28
brne zweig_2

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=28

rjmp ende_vergleich
zweig_2:
cpi r16,16
brne zweig_3

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=16

rjmp ende_vergleich
zweig_3:
cpi r16,1
brne kein_Treffer

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=1

rjmp ende_vergleich
kein_Treffer:

; hier stehen jetzt alle Anweisungen für den Fall, dass keiner der Vergleiche erfolgreich war

ende_vergleich:

rjmp ende_vergleich ; nur für Simulationszwecke! ENTFERNEN!
</avrasm>
'''Eigenschaften'''
* Programmspeicherbedarf: 6*N Bytes (N = Anzahl der Zweige)

'''Vorteile'''
* leicht verständlich
* Es können beliebige Vergleichswerte geprüft werden

'''Nachteile'''
* relativ hoher Programmspeicherbedarf
* die Größe der Zweige ist stark begrenzt, weil der Befehl '''breq''' maximal 63 Worte weit springen kann!
* die einzelnen Zweige haben unterschiedliche Durchlaufzeiten, der letzte Zweig ist am langsamsten
* nur bedingt übersichtlicher Quellcode

== Sprungtabelle ==

Oft liegen die einzelnen Vergleichswerte nebeneinander (z.B. 7..15), z.B. bei der Übergabe von Parametern, Zustandsautomaten, Menueinträgen etc. . In so einem Fall kann man mittels einer '''Sprungtabelle''' das Programm verkürzen, beschleunigen und übersichtlicher gestalten.

<avrasm>
.include "m8def.inc"

; Mehrfachverzweigung Version B

; Clevere Version mit Sprungtabelle
; minimum und maximum sind auf 0..255 begrenzt!

.equ minimum = 3
.equ maximum = 7

start_vergleich:

subi r16,minimum ; Nullpunkt verschieben
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
ldi ZL,low(Sprungtabelle) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle)
add ZL,r16 ; Index addieren, 16 Bit
ldi r16,0
adc ZH,r16
ijmp ; indirekter Sprung in Sprungtabelle

kein_treffer:

; hier stehen jetzt alle Anweisungen für den Fall, dass keiner der Vergleiche erfolgreich war

rjmp ende_vergleich

Sprungtabelle:
rjmp zweig_0
rjmp zweig_1
rjmp zweig_2
rjmp zweig_3
rjmp zweig_4

zweig_0:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

zweig_1:

; hier stehen jetzt alle Awneisungen für diesen Zweig

rjmp ende_vergleich

zweig_2:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

zweig_3:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

zweig_4:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

ende_vergleich:

; hier geht das Programm weiter

rjmp ende_vergleich ; nur für Simulationszwecke! ENTFERNEN!
</avrasm>

''' Programmbeschreibung ''' 
Wie ist dieses Programm nun zu verstehen? Das Prinzip beruht darauf, daß in einer gleichmässigen Tabelle Sprungbefehle auf einzelne Programmzweige abgelegt werden. Das ist praktisch genauso wie der AVR [[AVR-Tutorial: Interrupts | Interrupts]] verarbeitet. Über einen Index (0...N) wird ein Sprungbefehl ausgewählt und ausgeführt.Der entscheidende Befehl dazu ist '''ijmp'''.

Zunächst muss der Wertebereich, auf welchen die Variable geprüft werden soll (minimum bis maximum), normiert werden (0 bis (Maximum-Minimum)). Dazu wird einfach das Minimum subtrahiert.

<avrasm>
subi r16,minimum ; Nullpunkt verschieben
</avrasm>

Danach muss geprüft werden, ob der maximale Index nicht überschritten wird. Denn ein Sprung auf nichtexistierende Einträge oberhalb der Sprungtabelle wäre fatal!

<avrasm>
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
</avrasm>

Danach muss der indirekte Sprung vorbereitet werden. Dazu wird die Adresse der Sprungtabelle in das Z-Register geladen, welches ein 16 Bit Register ist und gleichbedeutend mit r30 und r31.

<avrasm>
ldi ZL,low(Sprungtabelle) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle)
</avrasm>

Danach muss der Index addiert werden, dies ist eine 16-Bit Addition.

<avrasm>
add ZL,r16 ; Index addieren, 16 Bit
ldi r16,0
adc ZH,r16
</avrasm>

Zu guter Letzt wird der indirekte Sprung in die Sprungtabelle ausgeführt.

<avrasm>
ijmp ; indirekter Sprung in Sprungtabelle
</avrasm>

In der Sprungtabelle wird dann zum jeweiligen Zweig verzweigt.
<avrasm>
Sprungtabelle:
rjmp zweig_0
rjmp zweig_1
rjmp zweig_2
rjmp zweig_3
rjmp zweig_4
</avrasm>

Der Zweig für einen ungültigen Index folgt direkt nach dem '''ijmp''', weil der Befehl '''brsh''' nur maximal 63 Worte weit springen kann.

'''Eigenschaften'''
* Programmspeicherbedarf: 2*N +18 Bytes (N = Anzahl der Zweige)
* maximale Gesamtgröße der Zweige wird durch den Befehl rjmp begrenzt (+/-4kB). Das sollte aber nur in sehr wenigen Fällen ein Problem sein (Man wird kaum einen AVR mit 8 kB FLASH mit einer einzigen Mehrfachverzweigung füllen!)

'''Vorteile'''
* relativ niedriger Programmspeicherbedarf
* die einzelnen Zweige haben unabhängig von der Grösse der Sprungtabelle eine konstante und kurze Durchlaufzeit von 12 Takten.
* übersichtlicher Quellcode

'''Nachteile'''
* Die Vergleichswerte müssen lückenlos aufeinander folgen

== Lange Sprungtabelle ==
Wenn man doch mal eine GIGA-Mehrfachverzeigung braucht, dann hilft die Version C.

<avrasm>
.include "m16def.inc"

; Mehrfachverzweigung Version C

; Clevere Version mit langer Sprungtabelle
; funktioniert nur mit AVRs mit mehr als 8KB FLASH
; minimum und maximum sind auf 0..127 begrenzt!

.equ minimum = 3
.equ maximum = 7

start_vergleich:

subi r16,minimum ; Nullpunkt verschieben
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
ldi ZL,low(Sprungtabelle*2) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle*2)
lsl r16 ; Index mit 2 multiplizieren
add zl,r16 ; Index addieren, 16 Bit
ldi r16,0
adc zh,r16
lpm r16,Z+ ; Low Byte laden und Pointer erhöhen
lpm ZH,Z ; zweites Byte laden
mov ZL,r16 ; erstes Byte in Z-Pointer kopieren
ijmp ; indirekter Sprung

kein_treffer:

; hier stehen jetzt alle Anweisungen für den Fall, dass keiner der Vergleiche erfolgreich war

jmp ende_vergleich

Sprungtabelle:
.dw zweig_0
.dw zweig_1
.dw zweig_2
.dw zweig_3
.dw zweig_4

zweig_0:

; hier stehen jetzt alle Anweisungen für diesen Zweig

jmp ende_vergleich

zweig_1:

; hier stehen jetzt alle Awneisungen für diesen Zweig

jmp ende_vergleich

zweig_2:

; hier stehen jetzt alle Anweisungen für diesen Zweig

jmp ende_vergleich

zweig_3:

; hier stehen jetzt alle Anweisungen für diesen Zweig

jmp ende_vergleich

zweig_4:

; hier stehen jetzt alle Anweisungen für diesen Zweig

ende_vergleich:

; hier geht das Programm weiter

jmp ende_vergleich ; nur für Simulationszwecke! ENTFERNEN!
</avrasm>

''' Programmbeschreibung ''' 
Diese Version ist der Version B sehr ähnlich. Der Unterschied besteht darin, daß in Version B die Sprungtabelle mit Sprungbefehlen gefüllt ist (rjmp) während in Version C die Startadressen der Funktionen ablegt sind. D.H. man kann nicht in die Sprungtabelle springen, sondern muss sich mit Hilfe des Index die richtige Adresse aus der Sprungtabelle lesen und mit '''ijmp''' anspringen. Klingt sehr ähnlich, ist aber dennoch verschieden.

Die ersten drei Befehle sind identisch, es wird der Index normiert und auf das Maximum geprüft.
<avrasm>
subi r16,minimum ; Nullpunkt verschieben
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
</avrasm>
Die nächsten zwei Befehle laden wieder die Anfangsadresse der Sprungtabelle. Doch halt, hier wird die Adresse der Sprungtabelle mit zwei multipliziert. Des Rätsels Lösung gibt es weiter unten.
<avrasm>
ldi ZL,low(Sprungtabelle*2) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle*2)
</avrasm>
Der Index wird ebenfalls mit zwei multipliziert.
<avrasm>
lsl r16 ; Index mit 2 multiplizieren
</avrasm>
Danach erfolgt eine 16-Bit Addition.
<avrasm>
add zl,r16 ; Index addieren, 16 Bit
ldi r16,0
adc zh,r16
</avrasm>
Nun zeigt unser Z-Zeiger auf den richtigen Tabelleneintrag. Jetzt müssen zwei Bytes aus dem FLASH geladen werden. Das geschieht mit Hilfe des '''lpm'''-Befehls ('''L'''oad '''P'''rogram '''M'''emory). Hier wird die erweiterte Version des lpm-Befehls verwendet, wie sie nur auf grösseren AVRs verfügbar ist. Dabei wird ein Byte in Register r16 geladen und gleichzeitig der Z-Pointer um eins erhöht. Damit zeigt er wunderbar auf das nächste Byte, welches auch geladen werden muss.
<avrasm>
lpm r16,Z+ ; Low Byte laden und Zeiger erhöhen
</avrasm>
Der zweite lpm-Befehl ist etwas ungewöhnlich, denn er überschreibt einen Teil des Z-Pointers! In den meisten Programmen wäre das ein Schuss ins Knie (Programmierfehler!), da wir aber den Z-Pointer danach sowieso mit neuen Daten laden ist das OK.
<avrasm>
lpm ZH,Z ; zweites Byte laden
</avrasm>
Das zuerst gelesene Byte wird in den Z-Pointer kopiert. Nun steht die Startadresse des gewählten Zweigs im Z-Pointer.
<avrasm>
mov ZL,r16 ; erstes Byte in Z-zeiger kopieren
</avrasm>
Zu guter Letzt wird der indirekte Sprung ausgeführt und bringt uns direkt in den Programmzweig.
<avrasm>
ijmp ; indirekter Sprung direkt in den Programmzweig
</avrasm>

Der Zweig für einen ungültigen Index folgt direkt nach dem '''ijmp''', weil der Befehl '''brsh''' nur maximal 63 Worte weit springen kann.

'''Eigenschaften'''
* Programmspeicherbedarf: 2*N +26 Bytes (N = Anzahl der Zweige)
* unbegrenzte Sprungweite

'''Vorteile'''
* relativ niedriger Programmspeicherbedarf
* die einzelnen Zweige haben unabhängig von der Grösse der Sprungtabelle eine konstante und kurze Durchlaufzeit von 18 Takten
* übersichtlicher Quellcode

'''Nachteile'''
* Die Vergleichswerte müssen lückenlos aufeinander folgen
* geringfügig höherer Programmspeicherbedarf (8 Byte mehr) und grössere Durchlaufzeit (6 Takte mehr)als Version B

== Z-Pointer leicht verständlich ==

Auf den ersten Blick scheint es sonderbar, daß Version B die Adresse der Sprungtabelle direkt lädt, während Version C sowohl Anfangsadresse als auch Index mit zwei multipliziert. Warum ist das so?

Version B verwendet nur den Befehl '''ijmp'''. Dieser erwartet im Z-Register eine Adresse zur Programmausführung, eine '''Wort-Adresse'''. Da der Programmspeicher des AVR 16 Bit breit ist (=1 Wort = 2 Bytes), werden nur Worte adressiert, nicht jedoch Bytes! Genauso arbeitet der Assembler. Jedes Label entspricht einer Wort-Adresse. Damit kann man mit einer 12 Bit-Adresse 4096 Worte adressieren (=8192 Bytes). Wenn man sich die Befehle der einzelnen AVRs anschaut wird klar, daß alle AVRs mit 8KB und weniger FLASH nur die Befehle rjmp und rcall besitzen. Denn sie brauchen nicht mehr! Mit 12 Adressbits, welche direkt in einem Wort im Befehl rjmp bzw. rcall kodiert sind, kann der gesamte Programmspeicher erreicht werden. Größere AVRs besitzen call und jmp, dort ist die Adresse als 22 bzw. 16 Bit Zahl kodiert, deshalb brauchen diese Befehle auch 2 Worte Programmspeicher.

Der Befehl '''lpm''' dient zum laden einzelner Bytes aus dem Programmspeicher. Das ist vor allem für Tabellen mit konstanten Werten sehr nützlich (7-Segmentdekoder, Zeichensätze, Kennlinien, Parameter Texte, etc.) Doch wie kommt man nun in dem wortweise adressierten Programmspeicher an einzelne Bytes? Ganz einfach. Der AVR "mogelt" hier und erwartet im Z-Register eine '''Byte-Adresse'''. Von dieser Adresse bilden die Bits 15..1 die Wortadresse, welche zur Adressierung des Programmspeichers verwendet wird. Bit 0 entscheidet dann, ob das hoch- oder niederwertige Byte in das Zielregister kopiert werden soll (0=niederwertiges Byte; 1=höherwertiges Byte).

Darum muss bei Verwendung des Befehls lpm die Anfangsadresse immer mit zwei multipliziert werden.
<avrasm>
ldi ZL,low(Sprungtabelle*2) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle*2)
</avrasm>
In Version C muss zusätzlich der Index mit zwei multipliziert werden, weil jeder Tabelleneintrag (Adresse des Programmzweigs) ein Wort breit ist. Damit wird aus einem Index von 0,1,2,3,4 ein Offset von 0,2,4,6,8.

{{Navigation_zurückhochvor|
zurücktext=Vergleiche|
zurücklink=AVR-Tutorial: Vergleiche|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=UART|
vorlink=AVR-Tutorial: UART}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Vergleiche

2007-12-25T17:40:49Z

FalkB: Kleine Überarbeitung

Vergleiche und Entscheidungen sind in jeder Programmiersprache ein zentrales Mittel um den Programmfluss abhängig von Bedingungen zu kontrollieren. In einem [[AVR]] spielen dazu 3 Komponenten zusammen:
* Vergleichsbefehle
* die Flags im Statusregister
* bedingte Sprungbefehle

Der Zusammenhang ist dabei folgender: Die Vergleichsbefehle führen einen Vergleich durch, zum Beispiel zwischen zwei Registern oder zwischen einem Register und einer Konstante. Das Ergebnis des Vergleiches wird in den Flags abgelegt. Die bedingten Sprungbefehle werten die Flags aus und führen bei einem positiven Ergebnis den Sprung aus. Besonders der erste Satzteil ist wichtig! Den bedingten Sprungbefehlen ist es nämlich völlig egal, ob die Flags über Vergleichsbefehle oder über sonstige Befehle gesetzt wurden. Die Sprungbefehle werten einfach nur die Flags aus, wie auch immer diese zu ihrem Zustand kommen.

==Flags==

Die Flags residieren im Statusregister '''SREG'''. Ihre Aufgabe ist es, das Auftreten bestimmter Ereignisse, die während Berechnungen eintreten können festzuhalten.

+---+---+---+---+---+---+---+---+
| I | T | H | S | V | N | Z | C |
+---+---+---+---+---+---+---+---+

===Carry (C)===
Das Carry Flag hält fest, ob ein Überlauf oder Unterlauf bei einer 8-Bit Berechnung statt gefunden hat.

===Zero (Z)===
Das Zero Flag hält fest, ob das Ergebnis der letzten 8-Bit Berechnung 0 war oder nicht.

===Negative (N)===
Spiegelt den Zustand des höchstwertigen Bits der letzten 8-Bit Berechnung wieder. In 2-Komplement Arithmetik bedeutet ein gesetztes 7. Bit eine negative Zahl, daher der Name.

===Overflow (V)===
Dieses Bit wird gesetzt, wenn bei einer Berechnung mit 2-Komplement Arithmetik ein Überlauf (Unterlauf) stattgefunden hat. Dies entspricht einem Überlauf von Bit 6 ins Bit 7

===Signed (S)===
Das Signed Bit ist eine Verknüpfung aus dem N und dem V Flag. Es wird hauptsächlich für 'Signed' Tests benötigt. Daher auch der Name.

===Half Carry (H)===
Das Half Carry Flag hat die gleiche Aufgabe wie das Carry Flag, nur beschäftigt es sich mit einem Überlauf von Bit 3 nach Bit 4. Das Haupteinsatzgebiet ist der Bereich der BCD Arithmetik.

=== Transfer (T)===
Das T-Flag wird von keiner Berechnung gesetzt, sondern steht zur ausschliesslichen Verwendung des Programmierers zur Verfügung. Damit können Bits von einer Stelle schnell an eine andere kopiert oder getestet werden.

===Interrupt (I)===
Das Interrupt Flag hat ebenfalls nichts mit Vergleichen zu tun, sondern steuert ob Interrupts systemweit zugelassen sind (siehe [[AVR-Tutorial: Interrupts]]).

==Vergleiche==
Um einen Vergleich durchzuführen, wird intern eine Subtraktion der beiden Operanden durchgeführt. Das eigentliche Ergebnis der Subtraktion wird allerdings verworfen, es bleibt nur die neue Belegung der Flags übrig, die in weiterer Folge ausgewertet werden kann

===CP - Compare===
Vergleicht den Inhalt zweier Register miteinander. Prozessorintern wird dabei eine Subtraktion der beiden Register durchgeführt. Das eigentliche Subtraktionsergebnis wird allerdings verworfen, das Subtraktionsergebnis beeinflusst lediglich die Flags.

===CPC - Compare with Carry===
Vergleicht den Inhalt zweier Register, wobei das Carry Flag in den Vergleich mit einbezogen wird. Dieser Befehl wird für Arithmetik mit grossen Variablen (16/32 Bit) benötigt. Siehe [[
AVR-Tutorial: Arithmetik]].

===CPI - Compare Immediate===
Vergleicht den Inhalt eines Registers mit einer direkt angegebenen Konstanten. Der Befehl ist nur auf die Register r16..r31 anwendbar.

==Bedingte Sprünge==

Die bedingten Sprünge werten immer bestimmte Flags im Statusregister '''SREG''' aus. Es spielt dabei keine Rolle, ob dies nach einem Vergleichsbefehl oder einem sonstigen Befehl gemacht wird. Entscheidend ist einzig und alleine der Zustand des abgefragten Flags. Die Namen der Sprungbefehle wurden allerdings so gewählt, daß sich im Befehlsnamen die Beziehung der Operanden direkt nach einem Compare Befehl wiederspiegelt. Zu beachten ist auch, daß die Flags nicht nur durch Vergleichsbefehle verändert werden, sondern auch durch arithmetische Operationen, Schiebebefehle und logische [[Bitmanipulation | Verknüpfungen]]. Da dieses Information wichtig ist, ist auch in der bei Atmel erhältlichen [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf Übersicht über alle Assemblerbefehle] bei jedem Befehl angegeben, ob und wie er Flags beeinflusst. Ebenso ist dort eine kompakte Übersicht aller bedingten Sprünge zu finden. Beachten muss man jedoch, dass die bedingten Sprünge maximal 64 Worte weit springen können.

=== Bedingte Sprünge für vorzeichenlose Zahlen ===

====BRSH - Branch if Same or Higher ====

Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' nicht gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann statt, wenn der erste Operand größer oder gleich dem zweiten Operanden ist.

====BRLO - Branch if Lower ====

Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann statt, wenn der erste Operand kleiner dem zweiten Operanden ist.

=== Bedingte Sprünge für vorzeichenbehaftete Zahlen ===

====BRGE - Branch if Greater or Equal ====
Der Sprung wird durchgeführt, wenn das '''Signed Flag (S)''' nicht gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' eingesetzt, so findet der Sprung dann und nur dann statt, wenn der zweite Operand größer oder gleich dem ersten Operanden ist.

====BRLT - Branch if Less Than ====
Der Sprung wird durchgeführt, wenn das '''Signed Flag (S)''' gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann und nur dann statt, wenn der zweite Operand kleiner als der erste Operand ist.

====BRMI - Branch if Minus====
Der Sprung wird durchgeführt, wenn das '''Negativ Flag (N)''' gesetzt ist, das Ergbnis der letzen Operation also negativ war.

====BRPL - Branch if Plus====
Der Sprung wird durchgeführt, wenn das '''Negativ Flag (N)''' nicht gesetzt ist, das Ergbnis der letzen Operation also positiv war (einschiesslich Null).

=== Sonstige bedingte Sprünge ===

====BREQ - Branch if Equal====
Der Sprung wird durchgeführt, wenn das '''Zero Flag (Z)''' gesetzt ist. Ist nach einem Vergleich das Zero Flag gesetzt, lieferte die interne Subtraktion also 0, so waren beide Operanden gleich.

====BRNE - Branch if Not Equal====
Der Sprung wird durchgeführt, wenn das '''Zero Flag (Z)''' nicht gesetzt ist. Ist nach einem Vergleich das Zero Flag nicht gesetzt, lieferte die interne Subtraktion also nicht 0, so waren beide Operanden verschieden.

====BRCC - Branch if Carry Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' nicht gesetzt ist. Dieser Befehl wird oft für Arithmetik mit grossen Variablen (16/32 Bit) bzw. im Zusammenhang mit Schiebeoperatioen verwendet.

====BRCS - Branch if Carry Flag is Set====
Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' gesetzt ist. Die Verwendung ist sehr ähnlich zu BRCC.

=== Selten verwendete bedingte Sprünge ===

====BRHC - Branch if Half Carry Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''Half Carry Flag (H)''' nicht gesetzt ist.

====BRHS - Branch if Half Carry Flag is Set====
Der Sprung wird durchgeführt, wenn das '''Half Carry Flag (H)''' gesetzt ist.

====BRID - Branch if Global Interrupt is Disabled (Cleared)====
Der Sprung wird durchgeführt, wenn das '''Interrupt Flag (I)''' nicht gesetzt ist.

====BRIS - Branch if Global Interrupt is Enabled (Set)====
Der Sprung wird durchgeführt, wenn das '''Interrupt Flag (I)''' gesetzt ist.

====BRTC - Branch if T Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''(T)''' nicht gesetzt ist.

====BRTS - Branch if T Flag is Set====
Der Sprung wird durchgeführt, wenn das '''(T)''' gesetzt ist.

====BRVC - Branch if Overflow Cleared====
Der Sprung wird durchgeführt, wenn das '''Overflow Flag (V)''' nicht gesetzt ist.

====BRVS - Branch if Overflow Set====
Der Sprung wird durchgeführt, wenn das '''Overflow Flag (V)''' gesetzt ist.

==Beispiele==

=== Entscheidungen ===

In jedem Programm kommt früher oder später das Problem, die Ausführung von Codeteilen von irgendwelchen Zahlenwerten, die sich in anderen Registern befinden abhängig zu machen. Sieht beispielweise die Aufgabe vor, daß Register r18 auf 0 gesetzt werden soll, wenn im Register r17 der Zahlenwert 25 enthalten ist, dann lautet der Code

<avrasm>
cpi r17, 25 ; vergleiche r17 mit der Konstante 25
brne nicht_gleich ; wenn nicht gleich, dann mach bei nicht_gleich weiter
ldi r18, 0 ; hier stehen nun Anweisungen für den Fall
; dass R17 gleich 25 ist
rjmp weiter ; meist will man den anderen Zeig nicht durchlaufen, darum der Sprung
nicht_gleich:
ldi r18,123 ; hier stehen nun Anweisungen für den Fall
; dass R17 ungleich 25 ist
weiter: ; hier geht das Programm weiter
</avrasm>

In ähnlicher Weise können die anderen bedingten Sprungbefehle eingesetzt werden, um die üblicherweise vorkommenden Vergleiche auf Gleichheit, Ungleichheit, Größer, Kleiner zu realisieren.

===Schleifenkonstrukte===

Ein immer wiederkehrendes Muster in der Programmierung ist eine '''Schleife'''. Die einfachste Form einer Schleife ist die '''Zählschleife'''. Dabei wird ein Register von einem Startwert ausgehend eine gewisse Anzahl erhöht, bis ein Endwert erreicht wird.

<avrasm>
ldi r17, 10 ; der Startwert sei in diesem Beispiel 10
loop:
; an dieser Stelle stehen die Befehle, welche innerhalb der Schleife
; mehrfach ausgeführt werden sollen

inc r17 ; erhöhe das Zaehlregister
cpi r17, 134 ; mit dem Endwert vergleichen
brne loop ; und wenn der Endwert noch nicht erricht ist
; wird bei der Marke loop ein weiterer Schleifendurchlauf ausgeführt
</avrasm>

Sehr oft ist es auch möglich das Konstrukt umzudrehen. Anstatt von einem Startwert aus zu inkrementieren genügt es die Anzahl der gewünschten Schleifendurchläufe in ein Register zu laden und dieses Register zu dekrementieren. Dabei kann man von der Eigenschaft der Dekrementieranweisung gebrauch machen, das '''Zero Flag (Z)''' zu beeinflussen. Ist das Ergebnis des Dekrements 0, so wird das '''Zero Flag (Z)''' gesetzt, welches wiederum in der nachfolgenden '''BRNE''' Anweisung für einen bedingen Sprung benutzt werden kann. Das vereinfacht die Schleife und spart eine Anweisung sowie einen Takt Ausführungzeit.

<avrasm>
ldi r17, 124 ; Die Anzahl der Wiederholungen in ein Register laden
loop:
; an dieser Stelle stehen die Befehle, welche innerhalb der Schleife
; mehrfach ausgeführt werden sollen

dec r17 ; Schleifenzähler um 1 verringern, dabei wird das Zero Flag beeinflusst
brne loop ; wenn r17 noch nicht 0 geworden ist -> Schleife wiederholen
</avrasm>

{{Navigation_zurückhochvor|
zurücktext=Interrupts|
zurücklink=AVR-Tutorial: Interrupts|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Mehrfachverzweigungen|
vorlink=AVR-Tutorial: Mehrfachverzweigung}}

[[Category:AVR]][[Category:AVR-Tutorial]]

Temperatursensor

2007-12-25T17:33:26Z

FalkB: Formatierung überarbeitet

Will man mit einem [[Mikrocontroller]] Temperaturen messen, dann braucht man
* einen [[Sensor]], der die Temperatur z.B. in eine Spannung oder einen Strom umwandelt
* einen [[ADC | AD-Wandler]], der das Signal digitalisiert. Der kann auf dem Sensor oder dem Mikrocontroller integriert sein.

Temperatursensoren gibt es nun in allen möglichen Varianten. Vom temperaturabhängigen [[Widerstand]] bis zum fertig abgeglichenen All-in-one-Bauteil mit digitalem Ausgang. Wie bei allen Sensoren sollte man auch hier genau hinschauen und [[Auflösung und Genauigkeit]] unterscheiden.

== Analoge Temperatursensoren ==

=== PT100 ===

Unter einem PT100 versteht man einen Platinwiderstand, der bei 0°C einen Widerstand von 100 Ohm hat.
Platinwiderstände sind temperaturabhängige Widerstände mit hoher Wiederholgenauigkeit und Konstanz. Wegen der relativ geringen Widerstandsänderung von nur ca. 0,4 Ohm pro Grad ist etwas mehr Schaltungsaufwand erforderlich als bei anderen Sensoren. Genauere Formeln zur Temperaturbestimmung gibt es u.a. bei der [http://de.wikipedia.org/wiki/Pt100 Wikipedia]. Einen Schaltplan findet sich bei der [http://www.heise.de/ct/04/22/236/ c't].

Die Sensoren gibt es auch mit anderen Widerstandswerten, z.B. mit 1000Ω und heißen dann entsprechend PT1000.

Vorteil:
* genormt
* hohe Linearität
* hohe Wiederholgenauigkeit
* einfach austauschbar

Nachteil:
* relativ teuer (bei segor.de ab 3,80€)
* brauchen aufwendigere Auswerteschaltung

=== NTC/PTC ===

NTC und PTC sind temperaturabhängige Widerstände.

* NTC (engl. '''N'''egative '''T'''emperature '''C'''oefficient, Heißleiter), hat bei hohen Temperaturen seinen niedrigsten Widerstand, z.B. Silizium
* PTC (engl. '''P'''ositive '''T'''emperature '''C'''oefficient, Kaltleiter), hat bei niedrigen Temperaturen seinen geringsten Widerstand, z.B. Glühlampe

Um den Widerstandswert zu messen schaltet man sie mit einem normalen Widerstand oder einer [[Konstantstromquelle]] in Reihe zu einem [[Spannungsteiler]] und misst den Spannungsabfall. Eine Beispielschaltung findet sich [http://www.mathar.com/msp_thermo1.html hier].

Vorteil:
* billig (Reichelt 0,29 €)

Nachteil:
* müssen abgeglichen werden
* brauchen A/D-Wandler
* sind nichtlinear

Links:
* [http://www.sprut.de/electronic/temeratur/temp.htm Temperaturabhängige Stromquelle und NTC/PTC inclusive Linearisierung]

=== LMx35 ===

Eine IC-Familie die pro Kelvin Temperaturänderung seine Ausgangsspannung um 10mV ändert. Die ICs gibt es in verschiedenen Genauigkeiten und Temperaturbereichen mit den Bezeichnungen LM135(A), LM235(A) und LM335(A). Der günstigste ist der LM335 mit einem Temperaturbereich von -40 ... +100°C.
In verschiedenen Bauformen erhältlich. Beispielschaltungen finden sich im [http://www.national.com/ds.cgi/LM/LM135.pdf Datenblatt] und [http://www.suessbrich.info/elek/elektherm1.html hier]

Vorteile:
* hat auch ohne Kalibrierung eine Genauigkeit von einem Grad (bei 25°C)
* relativ billig (LM335 bei Reichelt ab 0,87 €)

Nachteile:
* benötigt A/D-Wandler
* bei längerer Anschlussleitung störanfällig

=== LM334 ===

Ein IC ähnlich dem LM335 mit dem Unterschied, dass der durch das IC fließende Strom proportional von der Temperatur abhängt. Mit einer einfachen Schaltung aus nur zwei Widerständen kann man dann den Strom in einer Weise wandeln, dass pro Kelvin eine Sapnnungsänderung von 10mV ausgegeben wird. Da die Strom-Spannungswandlung auf der Platine (und damit nahe am AD-Wandler) stattfindet und die Übertragung des Messwerts durch einen Strom stattfindet, sind Störungen durch Netzbrumm etc. viel geringer als beim LM335

Vorteile:
* hat auch ohne Kalibrierung eine Genauigkeit von einem Grad (bei 25°C)
* relativ billig (Reichelt 0,90 €)

Nachteile:
* benötigt A/D-Wandler
* Bereich 0°C-70°C

Ähnliche ICs:
* AD592 (Ausgangsstrom 1µA pro Kelvin, absolute Temperatur) Conrad 174912 8,50€

=== SMT160-30 ===

Ist ein Zwischending zwischen Digital und Analog. Sein Ausgangssignal ist ein digitales PWM-Signal, zu dessen Messung man am besten den Input-Capture-Eingang eines Mikrocontrollers verwendet. Man kann ihn also wie einen analogen Sensor nur indirekt auslesen, anstatt über einen AD-Wandler hier über einen Timer.

Vorteile:
* Digitales PWM-Signal ist unempfindlich gegen Störeinflüsse
* gibt es in SO8, TO18, TO92 und TO220, gut befestigbar, z.B am Kühlkörper
* linear
* kein Abgleich nötig

Nachteile (viele):
* benötigt Timer
* jittert extrem, genaue Messungen nur über Mittelung / Filterung möglich
* nicht nur das PWM-Verhältnis, sondern auf die Frequenz ist temp-abhängig (1-4kHz)
* teuer (Farnell 10,90€ +16%, Conrad 9,xx€ , www.hy-line.de ??).
* TO92 Gehäuse ist günstiger, dafür weniger genau

Links:
* http://www.hy-line.de/co/sensor-tec/hersteller/smartec/smt-160-30/index.html

=== Thermoelement ===

Ein Thermoelement besteht im einfachsten Fall aus zwei ungleichen Metallendrähten, die an einem Punkt miteinander verbunden sind und bei dem die Verbindungsstelle einer anderen Temperatur ausgesetzt ist als die offenen Enden der Drähte. An den offenen Enden der Drähten entsteht eine Spannung (Thermospannung). Dieser Effekt wurde 1821 von Thomas Seebeck entdeckt ([http://de.wikipedia.org/wiki/Seebeck-Effekt Seebeck-Effekt] bei Wikipedia). Eine weitere Anwendung ist der thermoelektrische Generator ("Thermogenerator").

Vorteil:
* über einen sehr weiten Temperaturbereich einsetzbar

Nachteil:
* die sehr geringen Temperaturspannungen im Mikrovoltbereich benötigen eine sehr gute Auswertelektronik (guter Analogteil + AD-Wandler).

Links:
* [http://digital.ni.com/worldwide/germany.nsf/web/all/7A4F02BAEFEC22AC802567F6003E0D6E Temperaturmessung mit Thermoelementen] - Eine Einführung von David Potter (deutsche Überarbeitung: G.Sinkovic) (inkl. Erläuterung der Kaltstellenkompensation)
* [http://www.ipetronik.com/pdf/Newsletter/Ipetronik_NL2_2004_d.pdf Warum Thermoelemente Relativtemperaturen messen! oder Was ist eine Kaltstelle?] - Technische Information von www.ipetronik.com (PDF, 272 KB)

== Digitale Temperatursensoren ==

=== DS1621 ===

Der DS1621 ist Temperatursensor und A/D-Wandler in einem. Er gibt seine Daten per [[I²C]]-[[Bus]] aus. Ein Schaltplan für einen elektronischen Thermometer mit diesem IC findet sich [http://www.myplace.nu/avr/thermo/ hier].

Vorteile:
* bereits kalibriert
* kein A/D-Wandler nötig
* da I²C ein Bus ist, kann man mehrere DS1621 und andere I²C-Bausteine zusammen anschließen und braucht dafür trotzdem nur zwei I/O-Ports.
* Genauigkeit +-0,5°
* Auflösung besser 0,01°, wenn man die beiden Zählerregister (Count-Remain und Count-per-C) auswertet

Nachteile:
* teuer (Segor 5,80€; RS 3,95€; Conrad 4,99€)
* trotzdem die meisten Register [[Speicher#NVRAM | nichtflüchtig]] sind, kann man ihn nicht als Stand-Alone-Thermostat einsetzen, da er erst nach einem Start-Conversion-Befehl zu messen beginnt.

Nachfolger:
* DS1631, DS1631A (Auto-Start-> Stand-Alone-Thermostat), DS1731
* weitere Stand-Alone-Thermostaten: DS1821, DS1629

=== LM75 ===

Der LM75 ist so ähnlich wie der DS1621, allerdings nur in SMD erhältlich und nicht so genau. Er ist aber öfters mal auf PC-Mainboards zu finden, so dass man beim Schlachten eines solchen günstig an einen Temperatursensor kommen kann. Einen Schaltplan findet man [http://www.mcselec.com/index.php?option=com_docman&task=cat_view&gid=83&limit=1&limitstart=35 hier].

Vorteile:
* bereits kalibriert
* kein A/D-Wandler nötig
* I²C-Bus Ausgang
* billiger als DS1621 (Reichelt 2,10 €; RS 3V: 3,75€; 5V: 2,72€)

Nachteile:
* nur im SMD-Gehäuse erhältlich
* relativ ungenau (+-2°), kann man jedoch kalibrieren / kompensieren

Kompatible Typen:
* AD7415ART

=== DS18S20 / DS18B20 ===

Der DS18S20 (Nachfolger des DS1820) und DS18B20 sind scheinbar Temperatursensoren und A/D-Wandler in einem. Wenn man genauer hinschaut, stellt man fest, dass es sich um direktwandelnde Sensoren handelt. Die Temperatur wird ohne Umweg über eine analoge Zwischengröße (Spannung oder Strom) in ein digitales Signal überführt. Die Datenkommunikation erfolgt über ein 1-Wire-Interface, wodurch man am [[Mikrocontroller]] mit nur einen einzigen I/O-Pin auskommen kann. Außerdem beherrschen sie die parasitäre Stromversorgung, d.h. man braucht für Daten und Stromversorgung zusammen nur zwei Leitungen. Der DS18B20 hat 12 Bit Auflösung gegenüber 9 Bit Auflösung beim DS18S20.

Vorteile:
* bereits kalibriert
* Genauigkeit +-0,5°
* 1-Wire-Ausgang

Nachteil:
* ziemlich teuer (Reichelt 4,50€)
* bei http://shop.medhost.at/ für 3,24€ (2,70€+20%UST) + Versand EU 6€

Links:
* [http://chaokhun.kmitl.ac.th/~kswichit/avrthermo/avrthermo.html Ein Schaltplan]
* [http://www.mikrocontroller.net/forum/read-4-27035.html Code zur Ansteuerung]
* [http://pdfserv.maxim-ic.com/en/ds/DS18S20.pdf Datenblatt DS18S20]
* [http://pdfserv.maxim-ic.com/en/ds/DS18B20.pdf Datenblatt DS18B20]
* [http://www.mikrocontroller.net/forum/read-4-248219.html Webserver zur Ansteuerung von bis zu 63 Bausteinen]

=== DS1921 / DS1922 ===

Sind wie die DS1821 1-wire-Sensoren mit zusätzlicher Logging-Funktion.
Im iButton-Gehäuse befindet sich eine Lithium-Zelle, eine RTC, CMOS-RAM und der Temp-Sensor. Nach umfangreicher Progammierung startet der Button seine Mission (Aufzeichnung des Temperaturverlaufs).
Gibt es auch mit zusätzlicher Feuchtemessung (DS1923).

=== SHT1x/SHT7x ===

Der SHT1x/SHT7x (SHT10, SHT11, SHT15, STH71, SHT75) sind kombinierte Temperatur- und Feuchtesensoren von [http://www.sensirion.com Sensirion]. Sie unterscheiden sich in Bauform und Genauigkeit.

Vorteile:
* digitale Schnittstelle mit einfacher [[I²C]]-''ähnlicher'' Ansteuerung
* keine Kalibrierung notwendig
* Beispielcode (C, MC51) auf der Sensirion-Seite verfügbar (relativ leicht portierbar)
* interne Heizelemente (Funktionsprüfung, "rauhe" Umgebung)
* Spannungsmonitor ("Battery fail")

Nachteile:
* kann nicht am [[I²C]] Bus betrieben werden, theoretisch gleiche Clockleitung möglich, fixe Adresse
* relativ teuer (Farnell 18,60€)

[[Category:Bauteile]]

Adressierung

2007-12-24T22:07:38Z

FalkB:

Mikrocontroller und -prozessoren bieten in der Regel mehrere Möglichkeiten an, um auf Daten zuzugreifen. An dieser Stelle sollen die grundlegenden Adressierungsarten der [[AVR]]-Controller mit internem SRAM behandelt werden. 

==Immediate-Werte==

Eigentlich keine Adressierungsart, aber dennoch sehr wichtig, ist die Möglichkeit direkt konstante Werte in ein Register zu schreiben. Dabei ist schon zur Entwicklungszeit bekannt, welcher Wert in welches Register geladen werden soll.
<avrasm>
ldi r16, 0xA0 ; Schreibt den Wert 0xA0 in das Register r16
</avrasm>
ldi steht hierbei für load immediate.
Bei AVR-Mikrocontrollern ist das direkte Laden von Werten nur mit den Registern r16 bis r31 möglich.

==Direkte Adressierung==

Um auf Daten im Speicher zuzugreifen, muss man selbstverständlich wissen, wo sich diese Daten befinden. Will man z.B. den Inhalt eines Registers in eine Speicherzelle schreiben, so muss das Mikroprogramm die Adresse der gewünschten Speicherzelle kennen.
Eine einfache Möglichkeit der Adressierung ist es, dem Befehl die Adresse direkt mitzuteilen.
<avrasm>
.dseg
variable: .byte 1 ; Ein Byte im SRAM reservieren.
; Da davor das label "variable" steht, wird jedes Vorkommen von
; "variable" durch die eigentliche Adresse der reservierten
; Speicherzelle ersetzt
.cseg
ldi r16, 25 ; Den direkten Wert 25 in das Register r16 schreiben (immediate)
sts variable, r16 ; Den Inhalt von Register r16 (also 25) in die Speicherzelle
; mit der Adresse "variable" schreiben. Wie oben beschrieben
; ersetzt der Assembler "variable" mit der eigentlichen Adresse
</avrasm>
Die Adresse der Speicherzelle wird also schon zur Entwicklungszeit im Assembler-Befehl eingetragen, was nach sich zieht, dass so ein Befehl nur auf Speicherzellen zugreifen kann, deren Adressen schon im Vorhinein bekannt sind. Da variable in obigem Beispiel eine Adresse und somit nur eine Zahl darstellt, kann man zur Entwicklungszeit auch Konstanten addieren:
<avrasm>
.dseg
variable2: .byte 2 ; Zwei Bytes im SRAM reservieren. Dabei ist variable2 die Adresse
; der ERSTEN Speicherzelle von den beiden reservierten.

.cseg
ldi r16, 17 ; Den direkten Wert 17 in das Register r16 schreiben (immediate)
sts variable2, r16 ; Diesen Wert schreiben wir nun an die Speicheradresse variable2 (1stes Byte)
inc r16 ; Register r16 inkrementieren, also um 1 erhöhen.
sts variable2+1, r16 ; Hier schreiben wir das zweite Byte von variable2
</avrasm>
Nun steht in diesem Beispiel im ersten Byte die Zahl 17 und im zweiten Byte die Zahl 18. Dabei muss man beachten, dass die Addition im sts-Befehl bereits während der Assemblierung und nicht vom Mikrocontroller durchgeführt wird. Das ist der Fall, weil die Adresse der reservierten Speicherzelle schon zu dieser Zeit berechnet worden ist. Somit ist natürlich auch die Adresse + 1 bekannt.

== Indirekte Adressierung ==

Wenn wir nur die direkte Adressierung zur Verfügung haben, stossen wir schnell an Grenzen. Betrachten wir folgendes Beispiel:

Wir sollen Code schreiben, welcher eine variable Anzahl an Zahlen addieren soll. Die Zahlen stehen bereits hintereinander im Speicher, beginnend mit der Adresse zahlen_start, und im Register r16 steht, wie viele Zahlen es sind. Man merkt leicht, dass dies mit direkter Adressierung nur schwer möglich ist, denn es ist zur Entwicklungszeit noch nicht bekannt, wie viele Zahlen es sind.

Wir lösen diese Aufgabe, indem wir eine Schleife programmieren, die die Zahlen liest und aufaddiert, und das ganze so oft, wie im Register r16 steht. Da wir hier von einer Schleife reden, müssen wir bei jedem Lesen aus dem Speicher mit demselben Befehl auf eine andere Speicherzelle zugreifen. Wir brauchen also die Möglichkeit die Adresse dynamisch im Programmablauf zu ändern. Dieses bietet uns die indirekte Adressierung, bei der die Adresse der gewünschten Speicherstelle in einem Register steht.

Bei AVR-Mikrocontrollern gibt es dafür drei 16 Bit breite Register, die jeweils aus zwei 8-Bit-Registern bestehen. Dies rührt daher, dass ein 8-Bit-Register nur maximal 256 verschiedene Speicherzellen adressieren könnte, was für Mikrocontroller mit mehr Speicher nicht ausreicht. Die Register (r26, r27) und (r28, r29) und (r30, r31) bilden die besagten drei 16 Bit breiten Register zur indirekten Adressierung. Da diese Register auf Daten zeigen, nennt man sie logischerweise Zeigerregister (engl. Pointer). Sie tragen die Namen X, Y und Z, wobei die einzelnen 8-Bit-Register neben ihren r''xx''-Namen auch mit XL, XH, YL, YH, ZL und ZH angesprochen werden können. L(low) und H(high) bedeutet hierbei dass die unteren respektive die oberen 8 Bits der 16-Bit-Adresse gemeint ist.

{| border="1"
|+ '''Zeigerregister des AVR'''
! Register || alternativer Name || 16 Bit Zeigerregister
|-
| r26
| align="center"| XL
| align="center" rowspan="2"| X
|-
| r27
| align="center"| XH
|-
| r28
| align="center"| YL
| align="center" rowspan="2"| Y
|-
| r29
| align="center"| YH
|-
| r30
| align="center"| ZL
| align="center" rowspan="2"| Z
|-
| r31
| align="center"| ZH
|}

Wir werden beispielhalber das Z-Register für unser Problem verwenden. Dazu müssen wir zunächst die Adresse der ersten Zahl in dieses laden. Da das Z-Register 16 Bit breit ist, müssen wir ZH und ZL in zwei einzelnen ldi Operationen beschreiben. Der AVR-Assembler bietet uns hier zwei praktische Funktionen: Mit LOW(...) und HIGH(...) bekommt man die unteren respektive die oberen 8 Bit einer Speicheradresse. Das kommt uns gerade recht, da wir gerade die unteren/oberen 8 Bit der Adresse in die Register ZL/ZH schreiben wollen.

Dann können wir mit dem ld-Befehl die Zahl von der Speicherstelle lesen, auf die das Z-Register verweist. Wir schreiben den Wert in das Register r17. Zum Aufsummieren wollen wir das Register r18 verwenden, welches ganz zu Anfang mit clr auf 0 gesetzt wird.
<avrasm>
.dseg
zahlen_start: .byte 20 ; 20 Byte reservieren, das soll die Maximalanzahl sein

.cseg
; Irgendwo vorher werden die Zahlen geschrieben, das interessiert
; erstmal nicht weiter, wie das geschieht. Wir gehen jetzt davon aus,
; dass beginnend bei der Speicheradresse zahlen_start so viele Zahlen
; im Speicher stehen, wie im Register r16 steht.

ldi ZL, LOW(zahlen_start) ; ZL mit den unteren Bits der Adresse initialisieren
ldi ZH, HIGH(zahlen_start) ; ZH mit den oberen Bits der Adresse initialisieren
clr r18 ; r18 auf 0 initialisieren
schleife:
ld r17, Z ; Inhalt der von Z adressierten Speicherstelle in r17 lesen
adiw ZH:ZL, 1 ; Z inkrementieren, da wir gleich die darauffolgende
; Zahl lesen wollen. adiw eignet sich für 16-Bit-Addition
add r18, r17 ; Aufsummieren
dec r16 ; Wir erniedrigen r16 um 1
brne schleife ; Solange r16 ungleich 0, zu "schleife" springen

; An dieser Stelle ist die Schleife fertig und in r18 steht das Ergebnis.
</avrasm>
Das Programm funktioniert zwar schon, aber eine Sache ist unpraktisch: Das Z-Register muss jedes manuell inkrementiert werden, um im nächsten Schleifendurchlauf die nächste Zahl zu lesen. Da das sequenzielle Lesen oder Schreiben von Daten aus dem bzw. in das SRAM sehr oft in Programmen vorkommt, gibt es folgende Möglichkeiten:

===Postinkrement===
Die beiden Zeilen
<avrasm>
ld r17, Z ; Inhalt der von Z adressierten Speicherstelle in r17 lesen
adiw ZH:ZL, 1 ; Z inkrementieren
</avrasm>
können durch folgende Zeile ersetzt werden:
<avrasm>
ld r17, Z+ ; Inhalt der von Z adressierten Speicherstelle in r17 lesen
; und danach Z automatisch inkrementieren
</avrasm>
Das spart Ausführungszeit und macht den Code kürzer. Zu beachten ist, dass die Inkrementierung erst nach der Ausführung des eigentlichen Befehls durchgeführt wird.

===Predekrement===
Äquivalent zum Postinkrement gibt es auch die Möglichkeit des Dekrementierens. Hierbei wird der Wert jedoch vor der Ausführung des Befehls dekrementiert. Das Predekrement eignet sich, um rückwärts durch linear angeordnete Datenzu gehen.
<avrasm>
ld r17, -Z ; Z dekrementieren und DANACH Inhalt der
; von Z adressierten Speicherstelle in r17 lesen
</avrasm>
,

Adressierung

2007-12-24T22:06:08Z

FalkB: Kosmetik

HD44780

2007-12-24T21:34:40Z

FalkB: Kosmetik

Der HD44780 ist ein Steuer-IC für Textdisplays (siehe [[LCD]]). Praktisch alle Textdisplays werden mit diesem oder einem kompatiblen Controller (z.B. KS0066) angesteuert.

== Allgemeine Ansteuerung ==

=== Pinbelegung ===

Die Pinbelegung des ICs selber ist für den Anwender praktisch uninteressant. Hier ist die Pinbelegung vieler damit ausgestatteten LCD-Module angegeben.

{| border="1"
!Pin || Funktion || Beschreibung
|-
|1 || | VSS || Versorgungsspannung GND
|-
|2 || | VCC || Versorgungsspannung, meistens 5V
|-
|3 || | V0 ||Kontrastspannung, zwischen VSS und VCC, kann auf VSS gelegt oder via Poti angeschlossen werden. Bei großflächigen LCDs oder LCDs für den erweiterten Temperaturbereich kann auch eine negative Kontrastspannung nötig sein.
|-
|4 || | RS || Registerauswahl 0 = Befehlsregister, 1 = Datenregister
|-
|5 || | R/W || Lese oder Schreibzugriff, kann meistens fest auf GND gezogen werden 0 = Schreiben, 1 = Lesen,
|-
|6 || | E || Taktleitung
|-
|7 || | DB0 || Datenleitung
|-
|8 || |DB1 || Datenleitung
|-
|9 || |DB2 || Datenleitung
|-
|10 || |DB3 || Datenleitung
|-
|11 || |DB4 || Datenleitung
|-
|12 || |DB5 || Datenleitung
|-
|13 || |DB6 || Datenleitung
|-
|14 || |DB7 || Datenleitung
|-
|15 || A || Anode der LED-Hintergrundbeleuchtung
|-
|16 || K || Kathode der LED-Hintergrundbeleuchtung
|}

===Speicher===

Ein HD44780 besitzt mehrere Speicher. In ihnen wird der Inhalt des Displays sowie das Aussehen von Sonderzeichen gespeichert.

==== CGROM ====

Der '''C'''haracter '''G'''enerator '''ROM''' enthält die Zeichen in Form von 5x8 oder 5x10 Punktmatrizen. Er kann nicht geändert werden, ausser man sendet einen EEPROM zu Hitachi für eine Massenproduktion. Es sind viele verschiedene ROMs (Zeichensätze, engl. Fonts) verfügbar. Er ist für den Anwender nicht zugänglich.

==== CGRAM ====

Im '''C'''haracter '''G'''enerator '''RAM''' können acht 5x8 Pixel oder vier 5x10 Pixel grosse benutzerdefinierte Zeichen abgelegt werden. Wenn keine benutzerdefinierte Zeichen gebraucht werden kann dieser Bereich als Auslagerungsspeicher für den ansteuernden Mikrocontroller benutzt werden.

==== DDRAM ====

Im '''D'''isplay '''D'''ata '''RAM''' ist der Inhalt des LCDs gespeichert. Die Kodierung orientiert sich weitestgehend am ASCII Zeichensatz.

=== Kommandos ===

{| border="1"
|+HD44780 Befehlssatz
!Befehl
!RS
!RW
!D7
!D6
!D5
!D4
!D3
!D2
!D1
!D0
|-
|Bildschirminhalt löschen
|0
|0
|0
|0
|0
|0
|0
|0
|0
|1
|-
|Cursor auf Startpos
|0
|0
|0
|0
|0
|0
|0
|0
|1
|X
|-
|Modus festlegen
|0
|0
|0
|0
|0
|0
|0
|1
|I/D
|S
|-
|Display/Cursor
|0
|0
|0
|0
|0
|0
|1
|D
|C
|B
|-
|Cursor/Display schieben
|0
|0
|0
|0
|0
|1
|S/C
|R/L
|X
|X
|-
|Funktionen
|0
|0
|0
|0
|1
|DL
|N
|F
|X
|X
|-
|CGRAM Adresse setzen
|0
|0
|0
|1
|colspan ="6" align="center"|CGRAM-Adresse
|-
|DDRAM Adresse setzen
|0
|0
|1
|colspan="7" align="center"|DDRAM-Adresse
|-
|Adresse/Status lesen
|0
|1
|BF
|colspan="7" align="center"|CG-/DDRAM-Adresse
|-
|Daten in DDRAM/CGRAM schreiben
|1
|0
|colspan="8" align="center"|Daten
|-
|Daten aus DDRAM/CGRAM lesen
|1
|1
|colspan="8" align="center"|Daten
|}

{| border="1"
|+Kodierung der Steuerbits
!Bit
!0
!1
|-
|I/D
|Cursorposition dekrementieren
|Cursorposition inkrementieren
|-
|S
|Displayinhalt fest
|Displayinhalt weiterschieben
|-
|D
|Display aus
|Display an
|-
|C
|Cursor aus
|Cursor an
|-
|B
|Cursor blinkt nicht
|Cursor blinkt
|-
|S/C
|Cursor bewegen
|Displayinhalt schieben
|-
|R/L
|Nach links schieben
|Nach rechts schieben
|-
|DL
|4-Bit Interface
|8-Bit Interface
|-
|N
|1-zeiliges Display
|2/4-zeiliges Display
|-
|F
|5x7-Font
|5x10-Font
|-
|BF
|Kann Kommandos annehmen
|Ist beschäftigt
|}

== Ansteuerung per Microcontroller ==

Die Ansteuerung eines HD44780-basierten Displays gestaltet sich sowohl in Bezug auf den Hardware- als auch den Softwareaufwand recht einfach. Sie eignet sich somit sehr gut als Übungsprojekt für Anfänger.

Das HD44780-Interface besteht aus acht Datenleitungen (D0-D7) sowie den drei Steuerleitungen RS ('''R'''egister '''S'''elect), R/W ('''R'''ead/'''W'''rite) und E ('''E'''nable). Die Displays werden mit 5V Betriebsspannung versorgt, die Kontrastspannung V0 bekommt man, indem man ein 10kΩ-[[Potentiometer]] zwischen VCC und GND anschließt und den mittleren Anschluss als Kontrastspannung verwendet. Bei ca. 0,5 Volt werden dann die Pixel sichtbar. Optional haben viele Displays noch eine LED-Beleuchtung eingebaut, diese kann manchmal direkt an 5V angeschlossen werden, da der Vorwiderstand auf der LCD-Platine integriert ist. Oft ist aber auch ein externer Vorwiderstand nötig! Darum vorher besser im Datenblatt nachschauen. Möchte man IO-Pins am Mikrocontroller sparen, muss das Display im 4-Bit-Modus betrieben werden.

Beispielprogramme zur Ansteuerung findet man zuhauf im Internet, u.a. auch hier: [[AVR-Tutorial: LCD]]

=== Fertige Projekte oder Bibliotheken ===

* Peter Fleurys [http://homepage.hispeed.ch/peterfleury/avr-software.html LCD library for HD44870 based LCDs]
* Kai Klenovseks [http://kk.elektronik-4u.de/index.php?Sid=9 LCD library for HD44870 based LCDs]
* avr-libc [http://www.nongnu.org/avr-libc/user-manual/group__stdiodemo.html Demo-Projekt für stdio]
* [http://wwwiti.cs.uni-magdeburg.de/~buchmann/privat/lcd.htm Grundlagen und Code für 8051] von Erik Buchmann
* [http://home.iae.nl/users/pouweha/lcd/lcd.shtml ''How to control a HD44780-based Character-LCD''] von Peter Ouwehand. Beispiele für 8051, PIC16C54, AT90S2313

[[Category:Bauteile]]

AVR-Tutorial: Speicher

2007-12-24T13:04:02Z

FalkB: /* RAM */

== Speichertypen ==

Die AVR-Mikrocontroller besitzen 3 verschiedene Arten von Speicher:

<table border="1">
<tr>
<th align="left"></th>
<th align="left">Flash</th>
<th align="left">EEPROM</th>
<th align="left">RAM</th>
</tr>
<tr>
<th align="left">Schreibzyklen</th>
<td>>10.000</td>
<td>>100.000</td>
<td>unbegrenzt</td>
</tr>
<tr>
<th align="left">Lesezyklen</th>
<td>unbegrenzt</td>
<td>unbegrenzt</td>
<td>unbegrenzt</td>
</tr>
<tr>
<th align="left">flüchtig</th>
<td>nein</td>
<td>nein</td>
<td>ja</td>
</tr>
<tr>
<th align="left">Größe beim ATtiny2313</th>
<td>2 KB</td>
<td>128 Byte</td>
<td>128 Byte</td>
</tr>
<tr>
<th align="left">Größe beim ATmega8</th>
<td>8 KB</td>
<td>512 Byte</td>
<td>1 KB</td>
</tr>
<tr>
<th align="left">Größe beim ATmega32</th>
<td>32 KB</td>
<td>1 KB</td>
<td>2 KB</td>
</tr>

</table>

=== Flash-ROM ===

Das [[Speicher#Flash-ROM | '''Flash-ROM''']] der AVRs dient als Programmspeicher. Über den Programmieradapter werden die kompilierten Programme vom PC an den Controller übertragen und im Flash-ROM abgelegt. Bei der Programmausführung wird das ROM [[Digitaltechnik#Word | Wort]] für Wort ausgelesen und ausgeführt. Es lässt sich aber auch zur Speicherung von Daten nutzen (z.B. Texte für ein [[LCD]]). Vom laufenden Programm aus kann man das ROM normalerweise nur lesen, nicht beschreiben. Es kann beliebig oft ausgelesen werden, aber theoretisch nur ~10.000 mal beschrieben werden.

=== EEPROM ===

Das [[Speicher#EEPROM |'''EEPROM''']] ist wie das Flash ein nichtflüchtiger Speicher, die Daten bleiben also auch nach dem Ausschalten der Betriebsspannung erhalten. Es kann beliebig oft gelesen und mindestens 100.000 mal beschrieben werden. Bei den AVRs kann man es z.B. als Speicher für Messwerte oder Einstellungen benutzen.

=== RAM ===

Das [[Speicher#RAM |'''RAM''']] ist ein flüchtiger Speicher, d.h. die Daten gehen nach dem Ausschalten verloren. Es kann beliebig oft gelesen und beschrieben werden, weshalb es sich zur Speicherung von Variablen eignet für die die Register R0-R31 nicht ausreichen. Daneben dient es als Speicherort für den Stack, auf dem z.B. bei Unterprogrammaufrufen (rcall) die Rücksprungadresse gespeichert wird (siehe [[AVR-Tutorial:_SRAM]]).

== Anwendung ==

=== Flash-ROM ===

Die erste und wichtigste Anwendung des Flash-ROMs kennen wir bereits: Das Speichern von Programmen, die wir nach dem Assemblieren dort hineingeladen haben. Nun sollen aber auch vom laufenden Programm aus Daten ausgelesen werden.

Um die Daten wieder auszulesen, muss man die Adresse, auf die zugegriffen werden soll, in den '''Z-Pointer''' laden. Der Z-Pointer besteht aus den Registern '''R30''' (Low-Byte) und '''R31''' (High-Byte), daher kann man das Laden einer Konstante wie gewohnt mit dem Befehl '''ldi''' durchführen. Statt R30 und R31 kann man übrigens einfach '''ZL''' und '''ZH''' schreiben, da diese Synonyme bereits in der include-Datei m8def.inc definiert sind.

Wenn die richtige Adresse erstmal im Z-Pointer steht, geht das eigentliche Laden der Daten ganz einfach mit dem Befehl '''lpm'''. Dieser Befehl, der im Gegensatz zu out, ldi usw. keine Operanden hat, veranlasst das Laden des durch den Z-Pointer addressierte Byte aus dem Programmspeicher in das Register '''R0''', von wo aus man es weiterverarbeiten kann.

Jetzt muss man nur noch wissen, wie man dem Assembler überhaupt beibringt, dass er die von uns festgelegte Daten im ROM plazieren soll, und wie man dann an die Adresse kommt an der sich diese Daten befinden. Um den Programmspeicher mit Daten zu füllen, gibt es die [http://www.mikrocontroller.net/studiohelp/Assembler/directives.html Direktiven] .db und .dw. In der Regel benötigt man nur .db, was folgendermaßen funktioniert:

<avrasm>
daten:
.db 12, 20, 255, 0xFF, 0b10010000
</avrasm>

Dieser Ausschnitt sagt dem Assembler, dass er die angegebenen Bytes nacheinander im Speicher platzieren soll; wenn man die Zeile also assembliert, erhält man eine Hex-Datei, die nur diese Daten enthält.

Aber was soll das '''daten:''' am Anfang der Zeile? Bis jetzt haben wir Labels nur als Sprungmarken verwendet, um den Befehlen '''rcall''' und '''rjmp''' zu sagen, an welche Stelle im Programm gesprungen werden soll. Würden wir in diesem Fall '''rjmp daten''' im Programm stehen haben, dann würde die Programmausführung zur Stelle '''daten:''' springen, und versuchen die sinnlosen Daten als Befehle zu interpretieren - was mit Sicherheit dazu führt, dass der Controller Amok läuft.

Statt nach '''daten:''' zu springen, sollten wir die Adresse besser in den Z-Pointer laden. Da der Z-Pointer aus zwei Bytes besteht, brauchen wir dazu zweimal den Befehl '''ldi''':

<avrasm>
ldi ZL, LOW(daten*2) ; Low-Byte der Adresse in Z-Pointer
ldi ZH, HIGH(daten*2) ; High-Byte der Adresse in Z-Pointer
</avrasm>

Wie man sieht, ist das Ganze sehr einfach: Man kann die Labels im Assembler direkt wie Konstanten verwenden. Über die Multiplikation der Adresse mit zwei sollte man sich erst mal keine Gedanken machen: "Das ist einfach so." Wer es genauer wissen will schaut [[AVR-Tutorial:_Mehrfachverzweigung#Z-Pointer_leicht_verst.C3.A4ndlich | hier]] nach.

Um zu zeigen wie das alles konkret funktioniert, ist das folgende Beispiel nützlich:

<avrasm>
.include "m8def.inc"

ldi R16, 0xFF
out DDRB, R16 ; Port B: Ausgang

ldi ZL, LOW(daten*2) ; Low-Byte der Adresse in Z-Pointer
ldi ZH, HIGH(daten*2) ; High-Byte der Adresse in Z-Pointer

lpm ; durch Z-Pointer adressiertes Byte
; in R0 laden
out PORTB, R0 ; an PORTB ausgeben

ende:
rjmp ende ; Endlosschleife

daten:
.db 0b10101010
</avrasm>

Wenn man dieses Programm assembliert und in den Controller überträgt, dann kann man auf den an Port B angeschlossenen LEDs das mit '''.db 0b10101010''' im Programmspeicher abgelegte Bitmuster sehen.

Eine häufige Anwendung von '''lpm''' ist das Auslesen von Zeichenketten ("Strings") aus dem Flash-ROM und die Ausgabe an den seriellen Port oder ein LCD. Das folgende Programm gibt in einer Endlosschleife den Text "AVR-Assembler ist ganz einfach", gefolgt von einem Zeilenumbruch, an den UART aus.

<avrasm>
.include "m8def.inc"

.def temp = r16
.def temp1 = r17

.equ CLOCK = 4000000 ; Frequenz des Quarzes
.equ BAUD = 9600 ; Baudrate
.equ UBRRVAL = CLOCK/(BAUD*16)-1 ; Baudratenteiler

; hier geht das Programmsegment los

.CSEG
.org 0
ldi r16, low(RAMEND) ; Stackpointer initialisieren
out SPL, r16
ldi r16, high(RAMEND)
out SPH, r16

ldi temp, LOW(UBRRVAL) ; Baudrate einstellen
out UBRRL, temp
ldi temp, HIGH(UBRRVAL)
out UBRRH, temp

ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit
out UCSRC, temp
sbi UCSRB, TXEN ; TX (Senden) aktivieren

loop:
ldi ZL, LOW(text*2) ; Adresse des Strings in den
ldi ZH, HIGH(text*2) ; Z-Pointer laden
rcall print ; Funktion print aufrufen
rcall wait ; kleine Pause
rjmp loop ; das Ganze wiederholen

; kleine Pause
wait:
ldi temp,0
wait_1:
ldi temp1,0
wait_2:
dec temp1
brne wait_2
dec temp
brne wait_1
ret

; print: sendet die durch den Z-Pointer adressierte Zeichenkette

print:
lpm ; Erstes Byte des Strings nach R0 lesen
tst R0 ; R0 auf 0 testen
breq print_end ; wenn 0, dann zu print_end
mov r16, r0 ; Inhalt von R0 nach R16 kopieren
rcall sendbyte ; UART-Sendefunktion aufrufen
adiw ZL, 1 ; Adresse des Z-Pointers um 1 erhöhen
rjmp print ; wieder zum Anfang springen
print_end:
ret

; sendbyte: sendet das Byte aus R16 über das UART

sendbyte:
sbis UCSRA, UDRE ; warten bis das UART bereit ist
rjmp sendbyte
out UDR, r16
ret

; Konstanten werden hier im Flash abgelegt

text:
.db "AVR-Assembler ist ganz einfach",10,13,0
; Stringkonstante, durch eine 0 abgeschlossen
; die 10 bzw. 13 sind Steuerzeichen für Wagenrücklauf und neue Zeile
</avrasm>

Neuere AVR-Controller besitzen einen erweiterten Befehlssatz. Darunter befindet sich auch der folgende Befehl:

<avrasm>
lpm r16, Z+
</avrasm>

Dieser Befehl liest ein Byte aus dem Flash und speichert es in einem beliebigen Register, hier r16. Danach wird der Zeiger Z um eins erhöht. Für die neuen Controller, wie ATmegas kann das Codebeispiel also so abgeändert werden:

<avrasm>
; print: sendet die durch den Z-Pointer adressierte Zeichenkette
print:
lpm r16, Z+ ; Erstes Byte des Strings nach r16 lesen
tst r16 ; r16 auf 0 testen
breq print_end ; wenn 0, dann zu print_end
rcall sendbyte ; UART-Sendefunktion aufrufen
rjmp print ; wieder zum Anfang springen
print_end:
ret
</avrasm>

Wenn man bei .db einen Text in doppelten Anführungszeichen angibt, werden die Zeichen automatisch in die entsprechenden ASCII-Codes umgerechnet:

<avrasm>
.db "Test", 0
; ist äquivalent zu
.db 84, 101, 115, 116, 0
</avrasm>

Damit das Programm das Ende der Zeichenkette erkennen kann, wird eine 0 an den Text angehängt.

Das ist doch schonmal sehr viel praktischer, als jeden Buchstaben einzeln in ein Register zu laden und abzuschicken. Und wenn man statt '''sendbyte''' einfach die Routine '''lcd_data''' aus dem 4. Teil des Tutorials aufruft, dann funktioniert das gleiche sogar mit dem LCD!

==== Neue Assemblerbefehle ====

<avrasm>
lpm ; Liest das durch den Z-Pointer
; addressierte Byte aus dem Flash-ROM
; in das Register R0 ein.

lpm [Register], Z ; Macht das gleiche wie lpm, jedoch in
; ein beliebiges Register

lpm [Register], Z+ ; Erhöht zusätzlich den Z-Zeiger

tst [Register] ; Prüft, ob Inhalt eines Registers
; gleich 0 ist.

breq [Label] ; Springt zu [Label], wenn der
; vorhergehende Vergleich wahr ist.

adiw [Register], [Konstante] ; Addiert eine Konstante zu einem
; Registerpaar. [Register] bezeichnet das
; untere der beiden Register.
; Kann nur auf die Registerpaare
; R25:R24, R27:R26, R29:R28 und R31:R30
; angewendet werden.
</avrasm>

=== EEPROM ===

==== Lesen ====

Als erstes muss geprüft werden, ob ein vorheriger Schreibzugriff schon abgeschlossen ist. Danach wird die EEPROM-Adresse von der gelesen werden soll in das IO-Registerpaar '''EEARH/EEARL''' (EEPROM Address Register) geladen. Da der ATmega8 mehr als 256 Byte EEPROM hat, passt die Adresse nicht in ein einziges 8-Bit-Register, sondern muss in zwei Register aufgeteilt werden: EEARH bekommt das obere Byte der Adresse, EEARL das untere Byte. Dann löst man den Lesevorgang durch das Setzen des Bits '''EERE''' (EEPROM Read Enable) im IO-Register '''EECR''' (EEPROM Control Register) aus. Das gelesene Byte kann sofort aus dem IO-Register '''EEDR''' (EEPROM Data Register) in ein normales CPU-Register kopiert und dort weiterverarbeitet werden.

Wie auch das Flash-ROM kann man das EEPROM über den ISP-Programmer programmieren. Die Daten, die im EEPROM abgelegt werden sollen, werden wie gewohnt mit .db angegeben; allerdings muss man dem Assembler natürlich sagen, dass es sich hier um Daten für das EEPROM handelt. Das macht man durch die Direktive '''.eseg''', woran der Assembler erkennt, dass alle nun folgenden Daten für das EEPROM bestimmt sind.

Damit man die Bytes nicht von Hand abzählen muss um die Adresse herauszufinden, kann man auch im EEPROM-Segment wieder Labels einsetzen und diese im Assemblerprogramm wie Konstanten verwenden.

<avrasm>
.include "m8def.inc"

; hier geht die Programmsektion los
.cseg
.org 0

ldi r16, low(RAMEND) ; Stackpointer initialisieren
out SPL, r16
ldi r16, high(RAMEND)
out SPH, r16

ldi r16, 0xFF
out DDRB, r16 ; Port B Ausgang

ldi ZL,low(daten) ; Z-Zeiger laden
ldi ZH,high(daten)
rcall EEPROM_read ; Daten aus EEPROM lesen
out PORTB, r16

loop:
rjmp loop

EEPROM_read:
sbic EECR,EEWE ; prüfe ob der vorherige Schreibzugriff
; beendet ist
rjmp EEPROM_read ; nein, nochmal prüfen

out EEARH, ZH ; Adresse laden
out EEARL, ZL
sbi EECR, EERE ; Lesevorgang aktivieren
in r16, EEDR ; Daten in CPU Register kopieren
ret

; Daten im EEPROM definieren
.eseg
daten:
.db 0b10101010
</avrasm>

Wenn man dieses Programm assembliert, erhält man außer der .hex-Datei noch eine Datei mit der Endung '''.eep'''. Diese Datei enthält die Daten aus dem EEPROM-Segment (.eseg), und muss zusätzlich zu der hex-Datei in den Controller programmiert werden.

Das Programm gibt die Binärzahl 0b10101010 an den Port B aus, das heißt jetzt sollte jede zweite LED leuchten.

Natürlich kann man auch aus dem EEPROM Strings lesen und an den UART senden:

<avrasm>
.include "m8def.inc"

.def temp = r16

.equ CLOCK = 4000000 ; Frequenz des Quarzes

.equ BAUD = 9600 ; Baudrate
.equ UBRRVAL = CLOCK/(BAUD*16)-1 ; Baudratenteiler

; hier geht das Programmsegment los

.CSEG

; Hauptprogramm
main:
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

ldi temp, LOW(UBRRVAL) ; Baudrate einstellen
out UBRRL, temp
ldi temp, HIGH(UBRRVAL)
out UBRRH, temp

ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit
out UCSRC, temp
sbi UCSRB, TXEN ; TX (Senden) aktivieren

ldi ZL, low(text1) ; ersten String senden
ldi ZH, high(text1) ; Z-Pointer laden
rcall EEPROM_print

ldi ZL, low(text2) ; zweiten String senden
ldi ZH, high(text2) ; Z-Pointer laden
rcall EEPROM_print

loop:
rjmp loop ; Endlosschleife

; EEPROM Lesezugriff auf Strings + UART Ausgabe

EEPROM_print:
sbic EECR,EEWE ; prüf ob der vorherige Schreibzugriff
; beendet ist
rjmp EEPROM_print ; nein, nochmal prüfen

out EEARH, ZH ; Adresse laden
out EEARL, ZL

sbi EECR, EERE ; Lesevorgang aktivieren
in temp, EEDR ; Daten in CPU Register kopieren
tst temp ; auf 0 testen (=Stringende)
breq eep_print_end ; falls 0, Funktion beenden
rcall sendbyte ; ansonsten Byte senden...
adiw ZL,1 ; Adresse um 1 erhöhen...
rjmp EEPROM_print ; und zum Anfang der Funktion
eep_print_end:
ret

; sendbyte: sendet das Byte aus "data" über den UART

sendbyte:
sbis UCSRA, UDRE ; warten bis das UART bereit ist
rjmp sendbyte
out UDR, temp
ret

; hier wird der EEPROM-Inhalt definiert

.ESEG

text1:
.db "Strings funktionieren auch ", 0
text2:
.db "im EEPROM",10,13, 0
</avrasm>

==== Schreiben ====

Als erstes muss geprüft werden, ob ein vorheriger Schreibzugriff schon abgeschlossen ist. Danach wird die EEPROM-Adresse, auf die geschrieben wird, in das IO-Register '''EEAR''' ('''EE'''PROM '''A'''ddress '''R'''egister) geladen. Dann schreibt man die Daten, welche man auf der im Adressregister abgespeicherten Position ablegen will ins Register '''EEDR''' ('''EE'''PROM '''D'''ata '''R'''egister). Als nächstes setzt man das '''EEMWE''' Bit im EEPROM-Kontrollregister '''EECR''' ('''EE'''PROM '''C'''ontrol '''R'''egister) um den Schreibvorgang vorzubereiten. Nun wird es zeitkritisch - es darf nun keinesfalls ein Interrupt dazwischenfahren - denn man muss innerhalb von 4 Taktzyklen das '''EEWE''' Bit setzen um den Schreibvorgang auszulösen. Um das unter allen Bedingungen sicherzustellen werden die Interrupts kurz gesperrt. Danach startet der Schreibvorgang und läuft automatisch ab. Wenn er beendet ist, wird von der Hardware das '''EEWE''' Bit im Register '''EECR''' wieder gelöscht.

In diesem Beispiel werden Zeichen per UART und Interrupt empfangen und nacheinander im EEPROM gespeichert. Per Terminalprogramm kann man nun bis zu 512 Zeichen in den EEPROM schreiben. Per Programmieradapter kann man denn EEPROM wieder auslesen und seine gespeicherten Daten anschauen.

<avrasm>
.include "m8def.inc"

.def temp = r16
.def sreg_save = r17

.equ CLOCK = 4000000

.equ BAUD = 9600
.equ UBRRVAL = CLOCK/(BAUD*16)-1

; hier geht das Programmsegment los

.CSEG
.org 0x00
rjmp main

.org URXCaddr
rjmp int_rxc

; Hauptprogramm
main:
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

ldi temp, LOW(UBRRVAL) ; Baudrate einstellen
out UBRRL, temp
ldi temp, HIGH(UBRRVAL)
out UBRRH, temp

ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit
out UCSRC, temp

sbi UCSRB, RXCIE ; Interrupt bei Empfang
sbi UCSRB, RXEN ; RX (Empfang) aktivieren

ldi ZL,low(daten) ; der Z-Zeiger wird hier exclusiv
ldi ZH,high(daten) ; für die Datenadressierung verwendet

sei ; Interrupts global aktivieren

loop:
rjmp loop ; Endlosschleife (ABER Interrupts!)

; Interruptroutine wird ausgeführt,
; sobald ein Byte über den UART empfangen wurde

int_rxc:
push temp ; temp auf dem Stack sichern
in temp,sreg ; SREG sicher, muss praktisch in jeder
; Interruptroutine gemacht werden
push temp

in temp, UDR ; empfangenes Byte lesen
rcall EEPROM_write ; Byte im EEPROM speichern
adiw ZL,1 ; Zeiger erhöhen
cpi ZL,low(EEPROMEND+1) ; Vergleiche den Z Zeiger
ldi temp,high(EEPROMEND+1) ; mit der maximalen EEPROM Adresse +1
cpc ZH,temp
brne int_rxc_1 ; wenn ungleich, springen
ldi ZL,low(Daten) ; wenn gleich, Zeiger zurücksetzen
ldi ZH,high(Daten)
int_rxc_1:

pop temp
out sreg,temp
pop temp ; temp wiederherstellen
reti

; der eigentliche EEPROM Schreibzugriff
; Adresse in ZL/ZH
; Daten in temp

EEPROM_write:
sbic EECR, EEWE ; prüfe ob der letzte Schreibvorgang beendet ist
rjmp EEPROM_write ; wenn nein, nochmal prüfen

out EEARH, ZH ; Adresse schreiben
out EEARL, ZL ;
out EEDR,temp ; Daten schreiben
in sreg_save,sreg ; SREG sichern
cli ; Interrupts sperren, die nächsten
; zwei Befehle dürfen NICHT
; unterbrochen werden
sbi EECR,EEMWE ; Schreiben vorbereiten
sbi EECR,EEWE ; Und los !
out sreg, sreg_save ; SREG wieder herstellen
ret

; hier wird der EEPROM-Inhalt definiert
.ESEG

Daten:
.db 0
</avrasm>

=== SRAM ===

Die Verwendung des SRAM wird in einem anderen Kapitel erklärt: [[AVR-Tutorial: SRAM]]

== Siehe auch ==

* [[Adressierung]]

{{Navigation_zurückhochvor|
zurücktext=UART|
zurücklink=AVR-Tutorial: UART|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Timer|
vorlink=AVR-Tutorial: Timer}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Speicher

2007-12-24T13:00:59Z

FalkB: /* Flash-ROM */

== Speichertypen ==

Die AVR-Mikrocontroller besitzen 3 verschiedene Arten von Speicher:

<table border="1">
<tr>
<th align="left"></th>
<th align="left">Flash</th>
<th align="left">EEPROM</th>
<th align="left">RAM</th>
</tr>
<tr>
<th align="left">Schreibzyklen</th>
<td>>10.000</td>
<td>>100.000</td>
<td>unbegrenzt</td>
</tr>
<tr>
<th align="left">Lesezyklen</th>
<td>unbegrenzt</td>
<td>unbegrenzt</td>
<td>unbegrenzt</td>
</tr>
<tr>
<th align="left">flüchtig</th>
<td>nein</td>
<td>nein</td>
<td>ja</td>
</tr>
<tr>
<th align="left">Größe beim ATtiny2313</th>
<td>2 KB</td>
<td>128 Byte</td>
<td>128 Byte</td>
</tr>
<tr>
<th align="left">Größe beim ATmega8</th>
<td>8 KB</td>
<td>512 Byte</td>
<td>1 KB</td>
</tr>
<tr>
<th align="left">Größe beim ATmega32</th>
<td>32 KB</td>
<td>1 KB</td>
<td>2 KB</td>
</tr>

</table>

=== Flash-ROM ===

Das [[Speicher#Flash-ROM | '''Flash-ROM''']] der AVRs dient als Programmspeicher. Über den Programmieradapter werden die kompilierten Programme vom PC an den Controller übertragen und im Flash-ROM abgelegt. Bei der Programmausführung wird das ROM [[Digitaltechnik#Word | Wort]] für Wort ausgelesen und ausgeführt. Es lässt sich aber auch zur Speicherung von Daten nutzen (z.B. Texte für ein [[LCD]]). Vom laufenden Programm aus kann man das ROM normalerweise nur lesen, nicht beschreiben. Es kann beliebig oft ausgelesen werden, aber theoretisch nur ~10.000 mal beschrieben werden.

=== EEPROM ===

Das [[Speicher#EEPROM |'''EEPROM''']] ist wie das Flash ein nichtflüchtiger Speicher, die Daten bleiben also auch nach dem Ausschalten der Betriebsspannung erhalten. Es kann beliebig oft gelesen und mindestens 100.000 mal beschrieben werden. Bei den AVRs kann man es z.B. als Speicher für Messwerte oder Einstellungen benutzen.

=== RAM ===

Das [[Speicher#RAM |'''RAM''']] ist ein flüchtiger Speicher, d.h. die Daten gehen nach dem Ausschalten verloren. Es kann beliebig oft gelesen und beschrieben werden, weshalb es sich zur Speicherung von Variablen eignet für die die Register R0-R31 nicht ausreichen. Daneben dient es als Speicherort für den Stack, in dem z.B. bei Unterprogrammaufrufen (rcall) die Rücksprungadresse gespeichert wird (siehe Kapitel 3).

== Anwendung ==

=== Flash-ROM ===

Die erste und wichtigste Anwendung des Flash-ROMs kennen wir bereits: Das Speichern von Programmen, die wir nach dem Assemblieren dort hineingeladen haben. Nun sollen aber auch vom laufenden Programm aus Daten ausgelesen werden.

Um die Daten wieder auszulesen, muss man die Adresse, auf die zugegriffen werden soll, in den '''Z-Pointer''' laden. Der Z-Pointer besteht aus den Registern '''R30''' (Low-Byte) und '''R31''' (High-Byte), daher kann man das Laden einer Konstante wie gewohnt mit dem Befehl '''ldi''' durchführen. Statt R30 und R31 kann man übrigens einfach '''ZL''' und '''ZH''' schreiben, da diese Synonyme bereits in der include-Datei m8def.inc definiert sind.

Wenn die richtige Adresse erstmal im Z-Pointer steht, geht das eigentliche Laden der Daten ganz einfach mit dem Befehl '''lpm'''. Dieser Befehl, der im Gegensatz zu out, ldi usw. keine Operanden hat, veranlasst das Laden des durch den Z-Pointer addressierte Byte aus dem Programmspeicher in das Register '''R0''', von wo aus man es weiterverarbeiten kann.

Jetzt muss man nur noch wissen, wie man dem Assembler überhaupt beibringt, dass er die von uns festgelegte Daten im ROM plazieren soll, und wie man dann an die Adresse kommt an der sich diese Daten befinden. Um den Programmspeicher mit Daten zu füllen, gibt es die [http://www.mikrocontroller.net/studiohelp/Assembler/directives.html Direktiven] .db und .dw. In der Regel benötigt man nur .db, was folgendermaßen funktioniert:

<avrasm>
daten:
.db 12, 20, 255, 0xFF, 0b10010000
</avrasm>

Dieser Ausschnitt sagt dem Assembler, dass er die angegebenen Bytes nacheinander im Speicher platzieren soll; wenn man die Zeile also assembliert, erhält man eine Hex-Datei, die nur diese Daten enthält.

Aber was soll das '''daten:''' am Anfang der Zeile? Bis jetzt haben wir Labels nur als Sprungmarken verwendet, um den Befehlen '''rcall''' und '''rjmp''' zu sagen, an welche Stelle im Programm gesprungen werden soll. Würden wir in diesem Fall '''rjmp daten''' im Programm stehen haben, dann würde die Programmausführung zur Stelle '''daten:''' springen, und versuchen die sinnlosen Daten als Befehle zu interpretieren - was mit Sicherheit dazu führt, dass der Controller Amok läuft.

Statt nach '''daten:''' zu springen, sollten wir die Adresse besser in den Z-Pointer laden. Da der Z-Pointer aus zwei Bytes besteht, brauchen wir dazu zweimal den Befehl '''ldi''':

<avrasm>
ldi ZL, LOW(daten*2) ; Low-Byte der Adresse in Z-Pointer
ldi ZH, HIGH(daten*2) ; High-Byte der Adresse in Z-Pointer
</avrasm>

Wie man sieht, ist das Ganze sehr einfach: Man kann die Labels im Assembler direkt wie Konstanten verwenden. Über die Multiplikation der Adresse mit zwei sollte man sich erst mal keine Gedanken machen: "Das ist einfach so." Wer es genauer wissen will schaut [[AVR-Tutorial:_Mehrfachverzweigung#Z-Pointer_leicht_verst.C3.A4ndlich | hier]] nach.

Um zu zeigen wie das alles konkret funktioniert, ist das folgende Beispiel nützlich:

<avrasm>
.include "m8def.inc"

ldi R16, 0xFF
out DDRB, R16 ; Port B: Ausgang

ldi ZL, LOW(daten*2) ; Low-Byte der Adresse in Z-Pointer
ldi ZH, HIGH(daten*2) ; High-Byte der Adresse in Z-Pointer

lpm ; durch Z-Pointer adressiertes Byte
; in R0 laden
out PORTB, R0 ; an PORTB ausgeben

ende:
rjmp ende ; Endlosschleife

daten:
.db 0b10101010
</avrasm>

Wenn man dieses Programm assembliert und in den Controller überträgt, dann kann man auf den an Port B angeschlossenen LEDs das mit '''.db 0b10101010''' im Programmspeicher abgelegte Bitmuster sehen.

Eine häufige Anwendung von '''lpm''' ist das Auslesen von Zeichenketten ("Strings") aus dem Flash-ROM und die Ausgabe an den seriellen Port oder ein LCD. Das folgende Programm gibt in einer Endlosschleife den Text "AVR-Assembler ist ganz einfach", gefolgt von einem Zeilenumbruch, an den UART aus.

<avrasm>
.include "m8def.inc"

.def temp = r16
.def temp1 = r17

.equ CLOCK = 4000000 ; Frequenz des Quarzes
.equ BAUD = 9600 ; Baudrate
.equ UBRRVAL = CLOCK/(BAUD*16)-1 ; Baudratenteiler

; hier geht das Programmsegment los

.CSEG
.org 0
ldi r16, low(RAMEND) ; Stackpointer initialisieren
out SPL, r16
ldi r16, high(RAMEND)
out SPH, r16

ldi temp, LOW(UBRRVAL) ; Baudrate einstellen
out UBRRL, temp
ldi temp, HIGH(UBRRVAL)
out UBRRH, temp

ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit
out UCSRC, temp
sbi UCSRB, TXEN ; TX (Senden) aktivieren

loop:
ldi ZL, LOW(text*2) ; Adresse des Strings in den
ldi ZH, HIGH(text*2) ; Z-Pointer laden
rcall print ; Funktion print aufrufen
rcall wait ; kleine Pause
rjmp loop ; das Ganze wiederholen

; kleine Pause
wait:
ldi temp,0
wait_1:
ldi temp1,0
wait_2:
dec temp1
brne wait_2
dec temp
brne wait_1
ret

; print: sendet die durch den Z-Pointer adressierte Zeichenkette

print:
lpm ; Erstes Byte des Strings nach R0 lesen
tst R0 ; R0 auf 0 testen
breq print_end ; wenn 0, dann zu print_end
mov r16, r0 ; Inhalt von R0 nach R16 kopieren
rcall sendbyte ; UART-Sendefunktion aufrufen
adiw ZL, 1 ; Adresse des Z-Pointers um 1 erhöhen
rjmp print ; wieder zum Anfang springen
print_end:
ret

; sendbyte: sendet das Byte aus R16 über das UART

sendbyte:
sbis UCSRA, UDRE ; warten bis das UART bereit ist
rjmp sendbyte
out UDR, r16
ret

; Konstanten werden hier im Flash abgelegt

text:
.db "AVR-Assembler ist ganz einfach",10,13,0
; Stringkonstante, durch eine 0 abgeschlossen
; die 10 bzw. 13 sind Steuerzeichen für Wagenrücklauf und neue Zeile
</avrasm>

Neuere AVR-Controller besitzen einen erweiterten Befehlssatz. Darunter befindet sich auch der folgende Befehl:

<avrasm>
lpm r16, Z+
</avrasm>

Dieser Befehl liest ein Byte aus dem Flash und speichert es in einem beliebigen Register, hier r16. Danach wird der Zeiger Z um eins erhöht. Für die neuen Controller, wie ATmegas kann das Codebeispiel also so abgeändert werden:

<avrasm>
; print: sendet die durch den Z-Pointer adressierte Zeichenkette
print:
lpm r16, Z+ ; Erstes Byte des Strings nach r16 lesen
tst r16 ; r16 auf 0 testen
breq print_end ; wenn 0, dann zu print_end
rcall sendbyte ; UART-Sendefunktion aufrufen
rjmp print ; wieder zum Anfang springen
print_end:
ret
</avrasm>

Wenn man bei .db einen Text in doppelten Anführungszeichen angibt, werden die Zeichen automatisch in die entsprechenden ASCII-Codes umgerechnet:

<avrasm>
.db "Test", 0
; ist äquivalent zu
.db 84, 101, 115, 116, 0
</avrasm>

Damit das Programm das Ende der Zeichenkette erkennen kann, wird eine 0 an den Text angehängt.

Das ist doch schonmal sehr viel praktischer, als jeden Buchstaben einzeln in ein Register zu laden und abzuschicken. Und wenn man statt '''sendbyte''' einfach die Routine '''lcd_data''' aus dem 4. Teil des Tutorials aufruft, dann funktioniert das gleiche sogar mit dem LCD!

==== Neue Assemblerbefehle ====

<avrasm>
lpm ; Liest das durch den Z-Pointer
; addressierte Byte aus dem Flash-ROM
; in das Register R0 ein.

lpm [Register], Z ; Macht das gleiche wie lpm, jedoch in
; ein beliebiges Register

lpm [Register], Z+ ; Erhöht zusätzlich den Z-Zeiger

tst [Register] ; Prüft, ob Inhalt eines Registers
; gleich 0 ist.

breq [Label] ; Springt zu [Label], wenn der
; vorhergehende Vergleich wahr ist.

adiw [Register], [Konstante] ; Addiert eine Konstante zu einem
; Registerpaar. [Register] bezeichnet das
; untere der beiden Register.
; Kann nur auf die Registerpaare
; R25:R24, R27:R26, R29:R28 und R31:R30
; angewendet werden.
</avrasm>

=== EEPROM ===

==== Lesen ====

Als erstes muss geprüft werden, ob ein vorheriger Schreibzugriff schon abgeschlossen ist. Danach wird die EEPROM-Adresse von der gelesen werden soll in das IO-Registerpaar '''EEARH/EEARL''' (EEPROM Address Register) geladen. Da der ATmega8 mehr als 256 Byte EEPROM hat, passt die Adresse nicht in ein einziges 8-Bit-Register, sondern muss in zwei Register aufgeteilt werden: EEARH bekommt das obere Byte der Adresse, EEARL das untere Byte. Dann löst man den Lesevorgang durch das Setzen des Bits '''EERE''' (EEPROM Read Enable) im IO-Register '''EECR''' (EEPROM Control Register) aus. Das gelesene Byte kann sofort aus dem IO-Register '''EEDR''' (EEPROM Data Register) in ein normales CPU-Register kopiert und dort weiterverarbeitet werden.

Wie auch das Flash-ROM kann man das EEPROM über den ISP-Programmer programmieren. Die Daten, die im EEPROM abgelegt werden sollen, werden wie gewohnt mit .db angegeben; allerdings muss man dem Assembler natürlich sagen, dass es sich hier um Daten für das EEPROM handelt. Das macht man durch die Direktive '''.eseg''', woran der Assembler erkennt, dass alle nun folgenden Daten für das EEPROM bestimmt sind.

Damit man die Bytes nicht von Hand abzählen muss um die Adresse herauszufinden, kann man auch im EEPROM-Segment wieder Labels einsetzen und diese im Assemblerprogramm wie Konstanten verwenden.

<avrasm>
.include "m8def.inc"

; hier geht die Programmsektion los
.cseg
.org 0

ldi r16, low(RAMEND) ; Stackpointer initialisieren
out SPL, r16
ldi r16, high(RAMEND)
out SPH, r16

ldi r16, 0xFF
out DDRB, r16 ; Port B Ausgang

ldi ZL,low(daten) ; Z-Zeiger laden
ldi ZH,high(daten)
rcall EEPROM_read ; Daten aus EEPROM lesen
out PORTB, r16

loop:
rjmp loop

EEPROM_read:
sbic EECR,EEWE ; prüfe ob der vorherige Schreibzugriff
; beendet ist
rjmp EEPROM_read ; nein, nochmal prüfen

out EEARH, ZH ; Adresse laden
out EEARL, ZL
sbi EECR, EERE ; Lesevorgang aktivieren
in r16, EEDR ; Daten in CPU Register kopieren
ret

; Daten im EEPROM definieren
.eseg
daten:
.db 0b10101010
</avrasm>

Wenn man dieses Programm assembliert, erhält man außer der .hex-Datei noch eine Datei mit der Endung '''.eep'''. Diese Datei enthält die Daten aus dem EEPROM-Segment (.eseg), und muss zusätzlich zu der hex-Datei in den Controller programmiert werden.

Das Programm gibt die Binärzahl 0b10101010 an den Port B aus, das heißt jetzt sollte jede zweite LED leuchten.

Natürlich kann man auch aus dem EEPROM Strings lesen und an den UART senden:

<avrasm>
.include "m8def.inc"

.def temp = r16

.equ CLOCK = 4000000 ; Frequenz des Quarzes

.equ BAUD = 9600 ; Baudrate
.equ UBRRVAL = CLOCK/(BAUD*16)-1 ; Baudratenteiler

; hier geht das Programmsegment los

.CSEG

; Hauptprogramm
main:
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

ldi temp, LOW(UBRRVAL) ; Baudrate einstellen
out UBRRL, temp
ldi temp, HIGH(UBRRVAL)
out UBRRH, temp

ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit
out UCSRC, temp
sbi UCSRB, TXEN ; TX (Senden) aktivieren

ldi ZL, low(text1) ; ersten String senden
ldi ZH, high(text1) ; Z-Pointer laden
rcall EEPROM_print

ldi ZL, low(text2) ; zweiten String senden
ldi ZH, high(text2) ; Z-Pointer laden
rcall EEPROM_print

loop:
rjmp loop ; Endlosschleife

; EEPROM Lesezugriff auf Strings + UART Ausgabe

EEPROM_print:
sbic EECR,EEWE ; prüf ob der vorherige Schreibzugriff
; beendet ist
rjmp EEPROM_print ; nein, nochmal prüfen

out EEARH, ZH ; Adresse laden
out EEARL, ZL

sbi EECR, EERE ; Lesevorgang aktivieren
in temp, EEDR ; Daten in CPU Register kopieren
tst temp ; auf 0 testen (=Stringende)
breq eep_print_end ; falls 0, Funktion beenden
rcall sendbyte ; ansonsten Byte senden...
adiw ZL,1 ; Adresse um 1 erhöhen...
rjmp EEPROM_print ; und zum Anfang der Funktion
eep_print_end:
ret

; sendbyte: sendet das Byte aus "data" über den UART

sendbyte:
sbis UCSRA, UDRE ; warten bis das UART bereit ist
rjmp sendbyte
out UDR, temp
ret

; hier wird der EEPROM-Inhalt definiert

.ESEG

text1:
.db "Strings funktionieren auch ", 0
text2:
.db "im EEPROM",10,13, 0
</avrasm>

==== Schreiben ====

Als erstes muss geprüft werden, ob ein vorheriger Schreibzugriff schon abgeschlossen ist. Danach wird die EEPROM-Adresse, auf die geschrieben wird, in das IO-Register '''EEAR''' ('''EE'''PROM '''A'''ddress '''R'''egister) geladen. Dann schreibt man die Daten, welche man auf der im Adressregister abgespeicherten Position ablegen will ins Register '''EEDR''' ('''EE'''PROM '''D'''ata '''R'''egister). Als nächstes setzt man das '''EEMWE''' Bit im EEPROM-Kontrollregister '''EECR''' ('''EE'''PROM '''C'''ontrol '''R'''egister) um den Schreibvorgang vorzubereiten. Nun wird es zeitkritisch - es darf nun keinesfalls ein Interrupt dazwischenfahren - denn man muss innerhalb von 4 Taktzyklen das '''EEWE''' Bit setzen um den Schreibvorgang auszulösen. Um das unter allen Bedingungen sicherzustellen werden die Interrupts kurz gesperrt. Danach startet der Schreibvorgang und läuft automatisch ab. Wenn er beendet ist, wird von der Hardware das '''EEWE''' Bit im Register '''EECR''' wieder gelöscht.

In diesem Beispiel werden Zeichen per UART und Interrupt empfangen und nacheinander im EEPROM gespeichert. Per Terminalprogramm kann man nun bis zu 512 Zeichen in den EEPROM schreiben. Per Programmieradapter kann man denn EEPROM wieder auslesen und seine gespeicherten Daten anschauen.

<avrasm>
.include "m8def.inc"

.def temp = r16
.def sreg_save = r17

.equ CLOCK = 4000000

.equ BAUD = 9600
.equ UBRRVAL = CLOCK/(BAUD*16)-1

; hier geht das Programmsegment los

.CSEG
.org 0x00
rjmp main

.org URXCaddr
rjmp int_rxc

; Hauptprogramm
main:
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

ldi temp, LOW(UBRRVAL) ; Baudrate einstellen
out UBRRL, temp
ldi temp, HIGH(UBRRVAL)
out UBRRH, temp

ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit
out UCSRC, temp

sbi UCSRB, RXCIE ; Interrupt bei Empfang
sbi UCSRB, RXEN ; RX (Empfang) aktivieren

ldi ZL,low(daten) ; der Z-Zeiger wird hier exclusiv
ldi ZH,high(daten) ; für die Datenadressierung verwendet

sei ; Interrupts global aktivieren

loop:
rjmp loop ; Endlosschleife (ABER Interrupts!)

; Interruptroutine wird ausgeführt,
; sobald ein Byte über den UART empfangen wurde

int_rxc:
push temp ; temp auf dem Stack sichern
in temp,sreg ; SREG sicher, muss praktisch in jeder
; Interruptroutine gemacht werden
push temp

in temp, UDR ; empfangenes Byte lesen
rcall EEPROM_write ; Byte im EEPROM speichern
adiw ZL,1 ; Zeiger erhöhen
cpi ZL,low(EEPROMEND+1) ; Vergleiche den Z Zeiger
ldi temp,high(EEPROMEND+1) ; mit der maximalen EEPROM Adresse +1
cpc ZH,temp
brne int_rxc_1 ; wenn ungleich, springen
ldi ZL,low(Daten) ; wenn gleich, Zeiger zurücksetzen
ldi ZH,high(Daten)
int_rxc_1:

pop temp
out sreg,temp
pop temp ; temp wiederherstellen
reti

; der eigentliche EEPROM Schreibzugriff
; Adresse in ZL/ZH
; Daten in temp

EEPROM_write:
sbic EECR, EEWE ; prüfe ob der letzte Schreibvorgang beendet ist
rjmp EEPROM_write ; wenn nein, nochmal prüfen

out EEARH, ZH ; Adresse schreiben
out EEARL, ZL ;
out EEDR,temp ; Daten schreiben
in sreg_save,sreg ; SREG sichern
cli ; Interrupts sperren, die nächsten
; zwei Befehle dürfen NICHT
; unterbrochen werden
sbi EECR,EEMWE ; Schreiben vorbereiten
sbi EECR,EEWE ; Und los !
out sreg, sreg_save ; SREG wieder herstellen
ret

; hier wird der EEPROM-Inhalt definiert
.ESEG

Daten:
.db 0
</avrasm>

=== SRAM ===

Die Verwendung des SRAM wird in einem anderen Kapitel erklärt: [[AVR-Tutorial: SRAM]]

== Siehe auch ==

* [[Adressierung]]

{{Navigation_zurückhochvor|
zurücktext=UART|
zurücklink=AVR-Tutorial: UART|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Timer|
vorlink=AVR-Tutorial: Timer}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Speicher

2007-12-23T16:50:23Z

FalkB: Beispiele überarbeitet und getestet!

== Speichertypen ==

Die AVR-Mikrocontroller besitzen 3 verschiedene Arten von Speicher:

<table border="1">
<tr>
<th align="left"></th>
<th align="left">Flash</th>
<th align="left">EEPROM</th>
<th align="left">RAM</th>
</tr>
<tr>
<th align="left">Schreibzyklen</th>
<td>>10.000</td>
<td>>100.000</td>
<td>unbegrenzt</td>
</tr>
<tr>
<th align="left">Lesezyklen</th>
<td>unbegrenzt</td>
<td>unbegrenzt</td>
<td>unbegrenzt</td>
</tr>
<tr>
<th align="left">flüchtig</th>
<td>nein</td>
<td>nein</td>
<td>ja</td>
</tr>
<tr>
<th align="left">Größe beim ATtiny2313</th>
<td>2 KB</td>
<td>128 Byte</td>
<td>128 Byte</td>
</tr>
<tr>
<th align="left">Größe beim ATmega8</th>
<td>8 KB</td>
<td>512 Byte</td>
<td>1 KB</td>
</tr>
<tr>
<th align="left">Größe beim ATmega32</th>
<td>32 KB</td>
<td>1 KB</td>
<td>2 KB</td>
</tr>

</table>

=== Flash-ROM ===

Das [[Speicher#Flash-ROM | '''Flash-ROM''']] der AVRs dient als Programmspeicher. Über den Programmieradapter werden die kompilierten Programme vom PC an den Controller übertragen und im Flash-ROM abgelegt. Bei der Programmausführung wird das ROM Byte für Byte ausgelesen und ausgeführt, es lässt sich aber auch zur Speicherung von Daten (z.B. Texte für eine LCD-Anzeige) nutzen. Vom laufenden Programm aus kann man das ROM normalerweise nur lesen, nicht beschreiben.

Es kann beliebig oft ausgelesen werden, aber (theoretisch) nur ~10.000 mal beschrieben werden.

=== EEPROM ===

Das [[Speicher#EEPROM |'''EEPROM''']] ist wie das Flash ein nichtflüchtiger Speicher, die Daten bleiben also auch nach dem Ausschalten der Betriebsspannung erhalten. Es kann beliebig oft gelesen und mindestens 100.000 mal beschrieben werden. Bei den AVRs kann man es z.B. als Speicher für Messwerte oder Einstellungen benutzen.

=== RAM ===

Das [[Speicher#RAM |'''RAM''']] ist ein flüchtiger Speicher, d.h. die Daten gehen nach dem Ausschalten verloren. Es kann beliebig oft gelesen und beschrieben werden, weshalb es sich zur Speicherung von Variablen eignet für die die Register R0-R31 nicht ausreichen. Daneben dient es als Speicherort für den Stack, in dem z.B. bei Unterprogrammaufrufen (rcall) die Rücksprungadresse gespeichert wird (siehe Kapitel 3).

== Anwendung ==

=== Flash-ROM ===

Die erste und wichtigste Anwendung des Flash-ROMs kennen wir bereits: Das Speichern von Programmen, die wir nach dem Assemblieren dort hineingeladen haben. Nun sollen aber auch vom laufenden Programm aus Daten ausgelesen werden.

Um die Daten wieder auszulesen, muss man die Adresse, auf die zugegriffen werden soll, in den '''Z-Pointer''' laden. Der Z-Pointer besteht aus den Registern '''R30''' (Low-Byte) und '''R31''' (High-Byte), daher kann man das Laden einer Konstante wie gewohnt mit dem Befehl '''ldi''' durchführen. Statt R30 und R31 kann man übrigens einfach '''ZL''' und '''ZH''' schreiben, da diese Synonyme bereits in der include-Datei m8def.inc definiert sind.

Wenn die richtige Adresse erstmal im Z-Pointer steht, geht das eigentliche Laden der Daten ganz einfach mit dem Befehl '''lpm'''. Dieser Befehl, der im Gegensatz zu out, ldi usw. keine Operanden hat, veranlasst das Laden des durch den Z-Pointer addressierte Byte aus dem Programmspeicher in das Register '''R0''', von wo aus man es weiterverarbeiten kann.

Jetzt muss man nur noch wissen, wie man dem Assembler überhaupt beibringt, dass er die von uns festgelegte Daten im ROM plazieren soll, und wie man dann an die Adresse kommt an der sich diese Daten befinden. Um den Programmspeicher mit Daten zu füllen, gibt es die [http://www.mikrocontroller.net/studiohelp/Assembler/directives.html Direktiven] .db und .dw. In der Regel benötigt man nur .db, was folgendermaßen funktioniert:

<avrasm>
daten:
.db 12, 20, 255, 0xFF, 0b10010000
</avrasm>

Dieser Ausschnitt sagt dem Assembler, dass er die angegebenen Bytes nacheinander im Speicher platzieren soll; wenn man die Zeile also assembliert, erhält man eine Hex-Datei, die nur diese Daten enthält.

Aber was soll das '''daten:''' am Anfang der Zeile? Bis jetzt haben wir Labels nur als Sprungmarken verwendet, um den Befehlen '''rcall''' und '''rjmp''' zu sagen, an welche Stelle im Programm gesprungen werden soll. Würden wir in diesem Fall '''rjmp daten''' im Programm stehen haben, dann würde die Programmausführung zur Stelle '''daten:''' springen, und versuchen die sinnlosen Daten als Befehle zu interpretieren - was mit Sicherheit dazu führt, dass der Controller Amok läuft.

Statt nach '''daten:''' zu springen, sollten wir die Adresse besser in den Z-Pointer laden. Da der Z-Pointer aus zwei Bytes besteht, brauchen wir dazu zweimal den Befehl '''ldi''':

<avrasm>
ldi ZL, LOW(daten*2) ; Low-Byte der Adresse in Z-Pointer
ldi ZH, HIGH(daten*2) ; High-Byte der Adresse in Z-Pointer
</avrasm>

Wie man sieht, ist das Ganze sehr einfach: Man kann die Labels im Assembler direkt wie Konstanten verwenden. Über die Multiplikation der Adresse mit zwei sollte man sich erst mal keine Gedanken machen: "Das ist einfach so." Wer es genauer wissen will schaut [[AVR-Tutorial:_Mehrfachverzweigung#Z-Pointer_leicht_verst.C3.A4ndlich | hier]] nach.

Um zu zeigen wie das alles konkret funktioniert, ist das folgende Beispiel nützlich:

<avrasm>
.include "m8def.inc"

ldi R16, 0xFF
out DDRB, R16 ; Port B: Ausgang

ldi ZL, LOW(daten*2) ; Low-Byte der Adresse in Z-Pointer
ldi ZH, HIGH(daten*2) ; High-Byte der Adresse in Z-Pointer

lpm ; durch Z-Pointer adressiertes Byte
; in R0 laden
out PORTB, R0 ; an PORTB ausgeben

ende:
rjmp ende ; Endlosschleife

daten:
.db 0b10101010
</avrasm>

Wenn man dieses Programm assembliert und in den Controller überträgt, dann kann man auf den an Port B angeschlossenen LEDs das mit '''.db 0b10101010''' im Programmspeicher abgelegte Bitmuster sehen.

Eine häufige Anwendung von '''lpm''' ist das Auslesen von Zeichenketten ("Strings") aus dem Flash-ROM und die Ausgabe an den seriellen Port oder ein LCD. Das folgende Programm gibt in einer Endlosschleife den Text "AVR-Assembler ist ganz einfach", gefolgt von einem Zeilenumbruch, an den UART aus.

<avrasm>
.include "m8def.inc"

.def temp = r16
.def temp1 = r17

.equ CLOCK = 4000000 ; Frequenz des Quarzes
.equ BAUD = 9600 ; Baudrate
.equ UBRRVAL = CLOCK/(BAUD*16)-1 ; Baudratenteiler

; hier geht das Programmsegment los

.CSEG
.org 0
ldi r16, low(RAMEND) ; Stackpointer initialisieren
out SPL, r16
ldi r16, high(RAMEND)
out SPH, r16

ldi temp, LOW(UBRRVAL) ; Baudrate einstellen
out UBRRL, temp
ldi temp, HIGH(UBRRVAL)
out UBRRH, temp

ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit
out UCSRC, temp
sbi UCSRB, TXEN ; TX (Senden) aktivieren

loop:
ldi ZL, LOW(text*2) ; Adresse des Strings in den
ldi ZH, HIGH(text*2) ; Z-Pointer laden
rcall print ; Funktion print aufrufen
rcall wait ; kleine Pause
rjmp loop ; das Ganze wiederholen

; kleine Pause
wait:
ldi temp,0
wait_1:
ldi temp1,0
wait_2:
dec temp1
brne wait_2
dec temp
brne wait_1
ret

; print: sendet die durch den Z-Pointer adressierte Zeichenkette

print:
lpm ; Erstes Byte des Strings nach R0 lesen
tst R0 ; R0 auf 0 testen
breq print_end ; wenn 0, dann zu print_end
mov r16, r0 ; Inhalt von R0 nach R16 kopieren
rcall sendbyte ; UART-Sendefunktion aufrufen
adiw ZL, 1 ; Adresse des Z-Pointers um 1 erhöhen
rjmp print ; wieder zum Anfang springen
print_end:
ret

; sendbyte: sendet das Byte aus R16 über das UART

sendbyte:
sbis UCSRA, UDRE ; warten bis das UART bereit ist
rjmp sendbyte
out UDR, r16
ret

; Konstanten werden hier im Flash abgelegt

text:
.db "AVR-Assembler ist ganz einfach",10,13,0
; Stringkonstante, durch eine 0 abgeschlossen
; die 10 bzw. 13 sind Steuerzeichen für Wagenrücklauf und neue Zeile
</avrasm>

Neuere AVR-Controller besitzen einen erweiterten Befehlssatz. Darunter befindet sich auch der folgende Befehl:

<avrasm>
lpm r16, Z+
</avrasm>

Dieser Befehl liest ein Byte aus dem Flash und speichert es in einem beliebigen Register, hier r16. Danach wird der Zeiger Z um eins erhöht. Für die neuen Controller, wie ATmegas kann das Codebeispiel also so abgeändert werden:

<avrasm>
; print: sendet die durch den Z-Pointer adressierte Zeichenkette
print:
lpm r16, Z+ ; Erstes Byte des Strings nach r16 lesen
tst r16 ; r16 auf 0 testen
breq print_end ; wenn 0, dann zu print_end
rcall sendbyte ; UART-Sendefunktion aufrufen
rjmp print ; wieder zum Anfang springen
print_end:
ret
</avrasm>

Wenn man bei .db einen Text in doppelten Anführungszeichen angibt, werden die Zeichen automatisch in die entsprechenden ASCII-Codes umgerechnet:

<avrasm>
.db "Test", 0
; ist äquivalent zu
.db 84, 101, 115, 116, 0
</avrasm>

Damit das Programm das Ende der Zeichenkette erkennen kann, wird eine 0 an den Text angehängt.

Das ist doch schonmal sehr viel praktischer, als jeden Buchstaben einzeln in ein Register zu laden und abzuschicken. Und wenn man statt '''sendbyte''' einfach die Routine '''lcd_data''' aus dem 4. Teil des Tutorials aufruft, dann funktioniert das gleiche sogar mit dem LCD!

==== Neue Assemblerbefehle ====

<avrasm>
lpm ; Liest das durch den Z-Pointer
; addressierte Byte aus dem Flash-ROM
; in das Register R0 ein.

lpm [Register], Z ; Macht das gleiche wie lpm, jedoch in
; ein beliebiges Register

lpm [Register], Z+ ; Erhöht zusätzlich den Z-Zeiger

tst [Register] ; Prüft, ob Inhalt eines Registers
; gleich 0 ist.

breq [Label] ; Springt zu [Label], wenn der
; vorhergehende Vergleich wahr ist.

adiw [Register], [Konstante] ; Addiert eine Konstante zu einem
; Registerpaar. [Register] bezeichnet das
; untere der beiden Register.
; Kann nur auf die Registerpaare
; R25:R24, R27:R26, R29:R28 und R31:R30
; angewendet werden.
</avrasm>

=== EEPROM ===

==== Lesen ====

Als erstes muss geprüft werden, ob ein vorheriger Schreibzugriff schon abgeschlossen ist. Danach wird die EEPROM-Adresse von der gelesen werden soll in das IO-Registerpaar '''EEARH/EEARL''' (EEPROM Address Register) geladen. Da der ATmega8 mehr als 256 Byte EEPROM hat, passt die Adresse nicht in ein einziges 8-Bit-Register, sondern muss in zwei Register aufgeteilt werden: EEARH bekommt das obere Byte der Adresse, EEARL das untere Byte. Dann löst man den Lesevorgang durch das Setzen des Bits '''EERE''' (EEPROM Read Enable) im IO-Register '''EECR''' (EEPROM Control Register) aus. Das gelesene Byte kann sofort aus dem IO-Register '''EEDR''' (EEPROM Data Register) in ein normales CPU-Register kopiert und dort weiterverarbeitet werden.

Wie auch das Flash-ROM kann man das EEPROM über den ISP-Programmer programmieren. Die Daten, die im EEPROM abgelegt werden sollen, werden wie gewohnt mit .db angegeben; allerdings muss man dem Assembler natürlich sagen, dass es sich hier um Daten für das EEPROM handelt. Das macht man durch die Direktive '''.eseg''', woran der Assembler erkennt, dass alle nun folgenden Daten für das EEPROM bestimmt sind.

Damit man die Bytes nicht von Hand abzählen muss um die Adresse herauszufinden, kann man auch im EEPROM-Segment wieder Labels einsetzen und diese im Assemblerprogramm wie Konstanten verwenden.

<avrasm>
.include "m8def.inc"

; hier geht die Programmsektion los
.cseg
.org 0

ldi r16, low(RAMEND) ; Stackpointer initialisieren
out SPL, r16
ldi r16, high(RAMEND)
out SPH, r16

ldi r16, 0xFF
out DDRB, r16 ; Port B Ausgang

ldi ZL,low(daten) ; Z-Zeiger laden
ldi ZH,high(daten)
rcall EEPROM_read ; Daten aus EEPROM lesen
out PORTB, r16

loop:
rjmp loop

EEPROM_read:
sbic EECR,EEWE ; prüfe ob der vorherige Schreibzugriff
; beendet ist
rjmp EEPROM_read ; nein, nochmal prüfen

out EEARH, ZH ; Adresse laden
out EEARL, ZL
sbi EECR, EERE ; Lesevorgang aktivieren
in r16, EEDR ; Daten in CPU Register kopieren
ret

; Daten im EEPROM definieren
.eseg
daten:
.db 0b10101010
</avrasm>

Wenn man dieses Programm assembliert, erhält man außer der .hex-Datei noch eine Datei mit der Endung '''.eep'''. Diese Datei enthält die Daten aus dem EEPROM-Segment (.eseg), und muss zusätzlich zu der hex-Datei in den Controller programmiert werden.

Das Programm gibt die Binärzahl 0b10101010 an den Port B aus, das heißt jetzt sollte jede zweite LED leuchten.

Natürlich kann man auch aus dem EEPROM Strings lesen und an den UART senden:

<avrasm>
.include "m8def.inc"

.def temp = r16

.equ CLOCK = 4000000 ; Frequenz des Quarzes

.equ BAUD = 9600 ; Baudrate
.equ UBRRVAL = CLOCK/(BAUD*16)-1 ; Baudratenteiler

; hier geht das Programmsegment los

.CSEG

; Hauptprogramm
main:
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

ldi temp, LOW(UBRRVAL) ; Baudrate einstellen
out UBRRL, temp
ldi temp, HIGH(UBRRVAL)
out UBRRH, temp

ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit
out UCSRC, temp
sbi UCSRB, TXEN ; TX (Senden) aktivieren

ldi ZL, low(text1) ; ersten String senden
ldi ZH, high(text1) ; Z-Pointer laden
rcall EEPROM_print

ldi ZL, low(text2) ; zweiten String senden
ldi ZH, high(text2) ; Z-Pointer laden
rcall EEPROM_print

loop:
rjmp loop ; Endlosschleife

; EEPROM Lesezugriff auf Strings + UART Ausgabe

EEPROM_print:
sbic EECR,EEWE ; prüf ob der vorherige Schreibzugriff
; beendet ist
rjmp EEPROM_print ; nein, nochmal prüfen

out EEARH, ZH ; Adresse laden
out EEARL, ZL

sbi EECR, EERE ; Lesevorgang aktivieren
in temp, EEDR ; Daten in CPU Register kopieren
tst temp ; auf 0 testen (=Stringende)
breq eep_print_end ; falls 0, Funktion beenden
rcall sendbyte ; ansonsten Byte senden...
adiw ZL,1 ; Adresse um 1 erhöhen...
rjmp EEPROM_print ; und zum Anfang der Funktion
eep_print_end:
ret

; sendbyte: sendet das Byte aus "data" über den UART

sendbyte:
sbis UCSRA, UDRE ; warten bis das UART bereit ist
rjmp sendbyte
out UDR, temp
ret

; hier wird der EEPROM-Inhalt definiert

.ESEG

text1:
.db "Strings funktionieren auch ", 0
text2:
.db "im EEPROM",10,13, 0
</avrasm>

==== Schreiben ====

Als erstes muss geprüft werden, ob ein vorheriger Schreibzugriff schon abgeschlossen ist. Danach wird die EEPROM-Adresse, auf die geschrieben wird, in das IO-Register '''EEAR''' ('''EE'''PROM '''A'''ddress '''R'''egister) geladen. Dann schreibt man die Daten, welche man auf der im Adressregister abgespeicherten Position ablegen will ins Register '''EEDR''' ('''EE'''PROM '''D'''ata '''R'''egister). Als nächstes setzt man das '''EEMWE''' Bit im EEPROM-Kontrollregister '''EECR''' ('''EE'''PROM '''C'''ontrol '''R'''egister) um den Schreibvorgang vorzubereiten. Nun wird es zeitkritisch - es darf nun keinesfalls ein Interrupt dazwischenfahren - denn man muss innerhalb von 4 Taktzyklen das '''EEWE''' Bit setzen um den Schreibvorgang auszulösen. Um das unter allen Bedingungen sicherzustellen werden die Interrupts kurz gesperrt. Danach startet der Schreibvorgang und läuft automatisch ab. Wenn er beendet ist, wird von der Hardware das '''EEWE''' Bit im Register '''EECR''' wieder gelöscht.

In diesem Beispiel werden Zeichen per UART und Interrupt empfangen und nacheinander im EEPROM gespeichert. Per Terminalprogramm kann man nun bis zu 512 Zeichen in den EEPROM schreiben. Per Programmieradapter kann man denn EEPROM wieder auslesen und seine gespeicherten Daten anschauen.

<avrasm>
.include "m8def.inc"

.def temp = r16
.def sreg_save = r17

.equ CLOCK = 4000000

.equ BAUD = 9600
.equ UBRRVAL = CLOCK/(BAUD*16)-1

; hier geht das Programmsegment los

.CSEG
.org 0x00
rjmp main

.org URXCaddr
rjmp int_rxc

; Hauptprogramm
main:
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

ldi temp, LOW(UBRRVAL) ; Baudrate einstellen
out UBRRL, temp
ldi temp, HIGH(UBRRVAL)
out UBRRH, temp

ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit
out UCSRC, temp

sbi UCSRB, RXCIE ; Interrupt bei Empfang
sbi UCSRB, RXEN ; RX (Empfang) aktivieren

ldi ZL,low(daten) ; der Z-Zeiger wird hier exclusiv
ldi ZH,high(daten) ; für die Datenadressierung verwendet

sei ; Interrupts global aktivieren

loop:
rjmp loop ; Endlosschleife (ABER Interrupts!)

; Interruptroutine wird ausgeführt,
; sobald ein Byte über den UART empfangen wurde

int_rxc:
push temp ; temp auf dem Stack sichern
in temp,sreg ; SREG sicher, muss praktisch in jeder
; Interruptroutine gemacht werden
push temp

in temp, UDR ; empfangenes Byte lesen
rcall EEPROM_write ; Byte im EEPROM speichern
adiw ZL,1 ; Zeiger erhöhen
cpi ZL,low(EEPROMEND+1) ; Vergleiche den Z Zeiger
ldi temp,high(EEPROMEND+1) ; mit der maximalen EEPROM Adresse +1
cpc ZH,temp
brne int_rxc_1 ; wenn ungleich, springen
ldi ZL,low(Daten) ; wenn gleich, Zeiger zurücksetzen
ldi ZH,high(Daten)
int_rxc_1:

pop temp
out sreg,temp
pop temp ; temp wiederherstellen
reti

; der eigentliche EEPROM Schreibzugriff
; Adresse in ZL/ZH
; Daten in temp

EEPROM_write:
sbic EECR, EEWE ; prüfe ob der letzte Schreibvorgang beendet ist
rjmp EEPROM_write ; wenn nein, nochmal prüfen

out EEARH, ZH ; Adresse schreiben
out EEARL, ZL ;
out EEDR,temp ; Daten schreiben
in sreg_save,sreg ; SREG sichern
cli ; Interrupts sperren, die nächsten
; zwei Befehle dürfen NICHT
; unterbrochen werden
sbi EECR,EEMWE ; Schreiben vorbereiten
sbi EECR,EEWE ; Und los !
out sreg, sreg_save ; SREG wieder herstellen
ret

; hier wird der EEPROM-Inhalt definiert
.ESEG

Daten:
.db 0
</avrasm>

=== SRAM ===

Die Verwendung des SRAM wird in einem anderen Kapitel erklärt: [[AVR-Tutorial: SRAM]]

== Siehe auch ==

* [[Adressierung]]

{{Navigation_zurückhochvor|
zurücktext=UART|
zurücklink=AVR-Tutorial: UART|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Timer|
vorlink=AVR-Tutorial: Timer}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Speicher

2007-12-23T13:25:30Z

FalkB: /* Schreiben */ EEPROM Schreibzugriff korrigiert

== Speichertypen ==

Die AVR-Mikrocontroller besitzen 3 verschiedene Arten von Speichern:

<table border="0">
<tr>
<th align="left"></th>
<th align="left">Flash</th>
<th align="left">EEPROM</th>
<th align="left">RAM</th>
</tr>
<tr>
<th align="left">Schreibzyklen</th>
<td>>10.000</td>
<td>>100.000</td>
<td>unbegrenzt</td>
</tr>
<tr>
<th align="left">Lesezyklen</th>
<td>unbegrenzt</td>
<td>unbegrenzt</td>
<td>unbegrenzt</td>
</tr>
<tr>
<th align="left">flüchtig</th>
<td>nein</td>
<td>nein</td>
<td>ja</td>
</tr>
<tr>
<th align="left">Größe beim AT90S2333</th>
<td>2 KB</td>
<td>128 Byte</td>
<td>128 Byte</td>
</tr>
<tr>
<th align="left">Größe beim AT90S4433</th>
<td>4 KB</td>
<td>256 Byte</td>
<td>128 Byte</td>
</tr>
<tr>
<th align="left">Größe beim ATmega8</th>
<td>8 KB</td>
<td>512 Byte</td>
<td>1 KB</td>
</tr>
</table>

=== Flash-ROM ===

Das '''Flash-ROM''' der AVRs dient als Programmspeicher. Über den Programmieradapter werden die kompilierten Programme vom PC an den Controller übertragen und im Flash-ROM abgelegt. Bei der Programmausführung wird das ROM Byte für Byte ausgelesen und ausgeführt, es lässt sich aber auch zur Speicherung von Daten (z.B. Texte für eine LCD-Anzeige) nutzen. Vom laufenden Programm aus kann man das ROM normalerweise nur lesen, nicht beschreiben.

Es kann beliebig oft ausgelesen werden, aber (theoretisch) nur ~10.000 mal beschrieben werden.

=== EEPROM ===

Das '''EEPROM''' ist wie das Flash ein nichtflüchtiger Speicher, die Daten bleiben also auch nach dem Ausschalten der Betriebsspannung erhalten. Es kann beliebig oft gelesen und mindestens 100.000 mal beschrieben werden. Bei den AVRs kann man es z.B. als Speicher für Messwerte oder Einstellungen benutzen.

=== [[RAM]] ===

Das '''RAM''' ist ein flüchtiger Speicher, d.h. die Daten gehen nach dem Ausschalten verloren. Es kann beliebig oft gelesen und beschrieben werden, weshalb es sich zur Speicherung von Variablen eignet für die die Register R0-R31 nicht ausreichen (siehe Kapitel [[AVR-Tutorial: SRAM|SRAM]]). Daneben dient es als Speicherort für den Stack, in dem z.B. bei Unterprogrammaufrufen (rcall) die Rücksprungadresse gespeichert wird (siehe Kapitel 3).

== Anwendung ==

=== Flash-ROM ===

Die erste und wichtigste Anwendung des Flash-ROMs kennen wir bereits: Das Speichern von Programmen, die wir nach dem Assemblieren dort hineingeladen haben. Nun sollen aber auch vom laufenden Programm aus Daten ausgelesen werden.

Um die Daten wieder auszulesen, muss man die Adresse, auf die zugegriffen werden soll, in den '''Z-Pointer''' laden. Der Z-Pointer besteht aus den Registern '''R30''' (Low-Byte) und '''R31''' (High-Byte), daher kann man das Laden einer Konstante wie gewohnt mit dem Befehl '''ldi''' durchführen. Statt R30 und R31 kann man übrigens einfach '''ZL''' und '''ZH''' schreiben, da diese Synonyme bereits in der include-Datei m8def.inc definiert sind.

Wenn die richtige Adresse erstmal im Z-Pointer steht, geht das eigentliche Laden der Daten ganz einfach mit dem Befehl '''lpm'''. Dieser Befehl, der im Gegensatz zu out, ldi usw. keine Operanden hat, veranlasst dass das durch den Z-Pointer addressierte Byte aus dem Programmspeicher in das Register '''R0''' geladen wird, von wo aus man es weiterverarbeiten kann.

Jetzt muss man nur noch wissen, wie man dem Assembler überhaupt beibringt, dass er die von uns festgelegte Daten im ROM plazieren soll, und wie man dann an die Adresse kommt an der sich diese Daten befinden. Um den Programmspeicher mit Daten zu füllen, gibt es die [http://www.mikrocontroller.net/studiohelp/Assembler/directives.html Direktiven] .db und .dw. In der Regel benötigt man nur .db, was folgendermaßen funktioniert:

<avrasm>
daten:
.db 12, 20, 255, 0xFF, 0b10010000
</avrasm>

Dieser Ausschnitt sagt dem Assembler, dass er die angegebenen Bytes nacheinander im Speicher platzieren soll; wenn man die Zeile also assembliert, erhält man eine Hex-Datei, die nur diese Daten enthält.

Aber was soll das '''daten:''' am Anfang der Zeile? Bis jetzt haben wir Labels nur als Sprungmarken verwendet, um den Befehlen '''rcall''' und '''rjmp''' zu sagen, an welche Stelle im Programm gesprungen werden soll. Würden wir in diesem Fall '''rjmp daten''' im Programm stehen haben, dann würde die Programmausführung zur Stelle '''daten:''' springen, und versuchen die sinnlosen Daten als Befehle zu interpretieren - was mit Sicherheit dazu führt, dass der Controller Amok läuft.

Statt nach '''daten:''' zu springen, sollten wir die Adresse besser in den Z-Pointer laden. Da der Z-Pointer aus zwei Bytes besteht, brauchen wir dazu zweimal den Befehl '''ldi''':

<avrasm>
ldi ZL, LOW(daten*2) ; Low-Byte der Adresse in Z-Pointer
ldi ZH, HIGH(daten*2) ; High-Byte der Adresse in Z-Pointer
</avrasm>

Wie man sieht, ist das Ganze sehr einfach: Man kann die Labels im Assembler direkt wie Konstanten verwenden. Über die Multiplikation der Adresse mit 2 sollte man sich erst mal keine Gedanken machen: "Das ist einfach so."

Um zu zeigen wie das alles konkret funktioniert, ist das folgende Beispiel nützlich:

<avrasm>
.include "m8def.inc"

ldi R16, 0xFF
out DDRB, R16 ; Port B: Ausgang

ldi ZL, LOW(daten*2) ; Low-Byte der Adresse in Z-Pointer
ldi ZH, HIGH(daten*2) ; High-Byte der Adresse in Z-Pointer

lpm ; durch Z-Pointer adressiertes Byte nach R0 lesen
mov R16, R0 ; nach R16 kopieren
out PORTB, R16 ; an PORTB ausgeben

ende: rjmp ende ; Endlosschleife

daten:
.db 0b10101010
</avrasm>

Wenn man dieses Programm assembliert und in den Controller überträgt, dann kann man auf den an Port B angeschlossenen LEDs das mit '''.db 0b10101010''' im Programmspeicher abgelegte Bitmuster sehen.

Eine häufige Anwendung von '''lpm''' ist das Auslesen von Zeichenketten ("Strings") aus dem Flash-ROM und die Ausgabe an den seriellen Port oder ein LCD. Das folgende Programm gibt in einer Endlosschleife den Text "AVR-Assembler ist ganz einfach", gefolgt von einem Zeilenumbruch, an den UART aus.

<avrasm>
.include "m8def.inc"

.def temp = R16

ldi R16, RAMEND
out SPL, R16 ; Stackpointer initialisieren

sbi UCSRB,TXEN ; UART TX aktivieren
ldi temp,4000000/(9600*16)-1 ; Baudrate 9600 einstellen
out UBRR,temp

start:
ldi ZL, LOW(text*2) ; Adresse des Strings in den
ldi ZH, HIGH(text*2) ; Z-Pointer laden
rcall print ; Unterfunktion print aufrufen

ldi R16, 10 ; die Bytes 10 und 13 senden
rcall sendbyte ; (Zeilenumbruch im Terminal)
ldi R16, 13
rcall sendbyte

rjmp start ; das Ganze wiederholen

; print: sendet die durch den Z-Pointer adressierte Zeichenkette
print:
lpm ; Erstes Byte des Strings nach R0 lesen
tst R0 ; R0 auf 0 testen
breq print_end ; wenn 0, dann zu print_end
mov r16, r0 ; Inhalt von R0 nach R16 kopieren
rcall sendbyte ; UART-Sendefunktion aufrufen
adiw ZL, 1 ; Adresse des Z-Pointers um 1 erhöhen
rjmp print ; wieder zum Anfang springen
print_end:
ret

; sendbyte: sendet das Byte aus R16 über das UART
sendbyte:
sbis UCSRA, UDRE ; warten bis das UART bereit ist
rjmp sendbyte
out UDR, R16
ret

text:
.db "AVR-Assembler ist ganz einfach",0 ; Stringkonstante, durch eine 0 abgeschlossen
</avrasm>

Neuere AVR-Controller besitzen einen erweiterten Befehlssatz. Darunter befindet sich auch der folgende Befehl:

<avrasm>
lpm r16, Z+
</avrasm>

Dieser Befehl liest ein Byte aus dem Flash und speichert es in einem beliebigen Register, hier r16. Danach wird der Zeiger Z um eins erhöht.

Für die neuen Controller, wie ATmegas kann das Codebeispiel also so abgeändert werden:

<avrasm>
; print: sendet die durch den Z-Pointer adressierte Zeichenkette
print:
lpm r16, z+ ; Erstes Byte des Strings nach r16 lesen
tst r16 ; r16 auf 0 testen
breq print_end ; wenn 0, dann zu print_end
rcall sendbyte ; UART-Sendefunktion aufrufen
rjmp print ; wieder zum Anfang springen
print_end:
ret
</avrasm>

Wenn man bei .db einen Text in doppelten Anführungszeichen angibt, werden die Zeichen automatisch in die entsprechenden ASCII-Codes umgerechnet:

<avrasm>
.db "Test", 0
</avrasm>

ist äquivalent zu

<avrasm>
.db 84, 101, 115, 116, 0
</avrasm>

Damit das Programm das Ende der Zeichenkette erkennen kann, wird eine 0 an den Text angehängt.

Das ist doch schonmal sehr viel praktischer, als jeden Buchstaben einzeln in ein Register zu laden und abzuschicken. Und wenn man statt '''sendbyte''' einfach die Routine '''lcd_data''' aus dem 4. Teil des Tutorials aufruft, dann funktioniert das gleiche sogar mit dem LCD!

==== Neue Assemblerbefehle ====

<avrasm>
lpm ; Liest das durch den Z-Pointer addressierte Byte
; aus dem Flash-ROM in das Register R0 ein.
lpm [Register], Z ; Macht das gleiche wie lpm, jedoch in ein beliebiges Register
lpm [Register], Z+ ; Erhöht zusätzlich den Z-Zeiger

tst [Register] ; Prüft, ob der Inhalt eines Registers 0 ist.

breq [Label] ; Springt zu [Label], wenn der vorhergehende Vergleich wahr ist.

adiw [Register], [Konstante] ; Addiert eine Konstante zu einem Registerpaar.
; [Register] bezeichnet das untere der beiden Register.
; Kann nur auf die Registerpaare R25:R24, R27:R26,
; R29:R28 und R31:R30 angewendet werden.
</avrasm>

=== EEPROM ===

==== Lesen ====

Zuerst wird die EEPROM-Adresse von der gelesen werden soll in das IO-Registerpaar '''EEARH/EEARL''' (EEPROM Address Register) geladen. Da der ATmega8 mehr als 256 Byte RAM hat passt die Adresse nicht in ein einziges 8-Bit-Register, sondern muss in zwei Register aufgeteilt werden: EEARH bekommt das obere Byte der Adresse, EEARL das untere Byte.

Dann löst man den Lesevorgang durch das Setzen des Bits '''EERE''' (EEPROM Read Enable) im IO-Register '''EECR''' (EEPROM Control Register) aus. Da das EEPROM eine größere Zugriffszeit als das Flash besitzt, wird anschließend eine Schleife eingefügt, die solange wartet, bis das EEPROM signalisiert, dass die Daten jetzt verfügbar sind. Das gelesene Byte kann dann aus dem IO-Register '''EEDR''' (EEPROM Data Register) in ein normales Arbeitsregister kopiert und von dort weiterverarbeitet werden.

Doch um etwas aus dem EEPROM lesen zu können, muss man natürlich erst mal Daten hineinbekommen.

Wie auch das Flash-ROM kann man das EEPROM über den ISP-Programmer programmieren. Die Daten, die im EEPROM abgelegt werden sollen, werden wie gewohnt mit .db angegeben; allerdings muss man dem Assembler natürlich sagen, dass es sich hier um Daten für das EEPROM handelt. Das macht man durch die Direktive '''.eseg''', woran der Assembler erkennt, dass alle nun folgenden Daten für das EEPROM bestimmt sind.

Damit man die Bytes nicht von Hand abzählen muss um die Adresse herauszufinden, kann man auch im EEPROM-Segment wieder Labels einsetzen und diese im Assemblerprogramm wie Konstanten verwenden.

<avrasm>
.include "m8def.inc"

ldi R16, 0xFF
out DDRB, R16 ; Port B: Ausgang

ldi r16, HIGH(daten) ; Adresse laden
out EEARH, r16
ldi r16, LOW(daten)
out EEARL, r16

sbi EECR, EERE ; Lesevorgang aktivieren

in R16, EEDR

out PORTB, R16

loop: rjmp loop

.eseg
daten:
.db 0b10101010
</avrasm>

Wenn man dieses Programm assembliert, erhält man außer der .hex-Datei noch eine Datei mit der Endung '''.eep'''. Diese Datei enthält die Daten aus dem EEPROM-Segment (.eseg), und muss zusätzlich zu der hex-Datei in den Controller programmiert werden.

Das Programm gibt die Binärzahl 0b10101010 an den Port B aus, das heißt jetzt sollte jede zweite LED leuchten.

Natürlich kann man auch aus dem EEPROM Strings lesen und an den UART senden:

<div style="color:red; font-weight: bold;">Hinweis: Dieses Beispiel wurde noch nicht für den ATmega8 angepasst.</div>

<avrasm>
.include "4433def.inc"

.def temp = r16
.def address = r17
.def data = r18

ldi temp, RAMEND
out SPL, temp

sbi UCSRB,TXEN ; UART TX aktivieren
ldi temp,4000000/(9600*16)-1 ; Baudrate 9600 einstellen
out UBRR,temp

ldi address, text1 ; ersten String senden
rcall eep_print

ldi address, text2 ; zweiten String senden
rcall eep_print

ldi data, 10 ; die Bytes 10 und 13 senden
rcall sendbyte ; (Zeilenumbruch im Terminal)
ldi data, 13
rcall sendbyte

loop: rjmp loop

eep_print:
out EEAR, address ; EEPROM-Adresse
sbi EECR, EERE ; Lesevorgang starten
in data, EEDR ; gelesenes Byte nach "data"
tst data ; auf 0 (Stringende testen)
breq eep_print_end ; falls 0, Funktion beenden
rcall sendbyte ; ansonsten Byte senden...
inc address ; ... Adresse um 1 erhöhen...
rjmp eep_print ; ... und zum Anfang der Funktion
eep_print_end:
ret

; sendbyte: sendet das Byte aus "data" über den UART
sendbyte:
sbis UCSRA, UDRE ; warten bis das UART bereit ist
rjmp sendbyte
out UDR, data
ret

.eseg
text1:
.db "Strings funktionieren auch ", 0
text2:
.db "im EEPROM", 0
</avrasm>

==== Schreiben ====

Als erstes muss geprüft werden, ob ein vorheriger Schreibzugriff schon abgeschlossen ist. Danach wird die EEPROM-Adresse, auf die geschrieben wird, in das IO-Register '''EEAR''' ('''EE'''PROM '''A'''ddress '''R'''egister) geladen. Dann schreibt man die Daten, welche man auf der im Adressregister abgespeicherten Position ablegen will ins Register '''EEDR''' ('''EE'''PROM '''D'''ata '''R'''egister). Als nächstes setzt man das '''EEMWE''' Bit im EEPROM-Kontrollregister '''EECR''' ('''EE'''PROM '''C'''ontrol '''R'''egister) um den Schreibvorgang vorzubereiten. Nun wird es zeitkritisch - es darf nun keinesfalls ein Interrupt dazwischenfahren - denn man muss innerhalb von 4 Taktzyklen das '''EEWE''' Bit setzen um den Schreibvorgang auszulösen. Um das sicherzustellen werden die Interrupts kurz gesperrt. Danach startet der Schreibvorgang und läuft automatisch ab. Wenn er beendet ist, wird von der Hardware das '''EEPE''' Bit im Register '''EECR''' wieder gelöscht.

Hier ein Code für das Schreiben in den EEPROM (durch UART-Interrupt ausgelöst) dazu:

<avrasm>
include "m8def.inc"

.def temp = R16
.def sreg_save = r17

.equ CLOCK = 4000000
.equ BAUD = 9600
.equ UBRRVAL = CLOCK/(BAUD*16)-1

; hier geht das Programmsegment los
.CSEG
.org 0x00
rjmp main

.org URXCaddr
rjmp int_rxc

; Hauptprogramm
main:
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

ldi temp, LOW(UBRRVAL) ; Baudrate einstellen
out UBRRL, temp
ldi temp, HIGH(UBRRVAL)
out UBRRH, temp

ldi temp, (1<<URSEL)|(3<<UCSZ0) ; Frame-Format: 8 Bit
out UCSRC, temp

sbi UCSRB, RXCIE ; Interrupt bei Empfang
sbi UCSRB, RXEN ; RX (Empfang) aktivieren

sei ; Interrupts global aktivieren

loop:
rjmp loop ; Endlosschleife(ABER Interrupts!)

; Interruptroutine wird ausgeführt, sobald ein Byte über den UART empfangen wurde

int_rxc:
push temp ; temp auf dem Stack sichern
in temp,sreg ; SREG sicher, muss praktisch in jeder
; Interruptroutine gemacht werden
push temp

in temp, UDR ; empfangenes Byte lesen

rcall EEPROM_write ; Byte im EEPROM speichern

pop temp
out sreg,temp
pop temp ; temp wiederherstellen
reti

; der eigentliche EEPROM Schreibzugriff

EEPROM_write:
sbic EECR, EEPE ; prüfe ob der letzte Schreibvorgang beendet ist
rjmp EEPROM_write ; wenn nein, nochmal prüfen

ldi temp, HIGH(Daten) ; High-Adresse im EEPROM laden
out EEARH, temp ; und ins EEARH schreiben
ldi temp, LOW(Daten) ; Low-Adresse im EEPROM laden
out EEARL, temp ; und ins EEARL schreiben
out EEDR,temp ; Daten ins EEPROM-Datenregister

in sreg_save,sreg ; SREG sichern
cli ; Interrupts sperren, die nächsten
; zwei Befehle dürfen NICHT
; unterbrochen werden
sbi EECR,EEMWE ; Schreiben vorbereiten
sbi EECR,EEWE ; Und los !
out sreg, sreg_save ; SREG wieder herstellen
ret

; hier wird der EEPROM-Inhalt definiert
.ESEG

Daten: .db 0,0,0,0

</avrasm>

Das ist jetzt sehr einfach gehalten, aber für Anfänger leicht auf ihr Projekt zu übertragen.

=== SRAM ===

Die Verwendung des SRAM wird in einem späteren Kapitel erklärt: [[AVR-Tutorial: SRAM]]

== Siehe auch ==
* [[Adressierung]]

{{Navigation_zurückhochvor|
zurücktext=UART|
zurücklink=AVR-Tutorial: UART|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Timer|
vorlink=AVR-Tutorial: Timer}}

[[Category:AVR]][[Category:AVR-Tutorial]]

Interrupt

2007-12-22T13:16:36Z

FalkB: /* Steuersignale zwischen ISR und Hauptprogramm */

== Einleitung ==

Bei bestimmten Ereignissen in Prozessoren wird ein '''Interrupt''' ausgelöst. Dabei wird das Programm unterbrochen und ein Unterprogramm, die sogenannte '''I'''nterrupt '''S'''ervice '''R'''outine ('''ISR'''), aufgerufen. Wenn dieses beendet ist läuft das Hauptprogramm ganz normal weiter.

Bei [[Mikrocontroller]]n werden Interrupts z.B. ausgelöst wenn:
* sich der an einem bestimmten Eingangs-Pin anliegende Pegel ändert
* eine vorher festgelegte Zeitspanne abgelaufen ist ([[Timer]])
* eine [[Seriell|serielle]] Übertragung abgeschlossen ist
* eine Messung des [[ADC |Analog-Digital-Wandlers]] abgeschlossen ist

== Wichtige Eigenschaften von ISRs ==

ISRs reagieren auf ein bestimmtes Ereignis, welches relativ oft oder selten passiert. Prinzipiell sollte man ISRs möglichst kurz halten und schnell beenden. '''Im Mittel muss die Interruptroutine kürzer sein als die Periodendauer des Ereignises, anderenfalls wird es passieren, dass Interrupts "verschluckt" werden''', d.h. beim UART gehen Daten verloren, beim Timer gehen Zählzyklen verloren, beim AD-Wandler gehen Daten verloren etc. '''Solche verschluckten Interrupts sind bisweilen schwer zu finden, weil es bisweilen nur sehr wenige in ganz bestimmten Konstellationen sind.''' Wenn dann eine per Timer realisierte Uhr in der Stunde um 1s falsch geht, merkt man das oft nicht. '''Langwierige Berechnungen, Auswertungen, Ausgaben oder gar Warteschleifen haben in ISRs nichts zu suchen.''' Typische C-Funktionen wie printf(), scanf(), längere Ausgaben auf ein [[LCD]] etc. sollte man nicht in ISRs vornehmen. Hier kommt sinnvollerweise eine andere Programmiertechnik zu Einsatz, nämlich die Übergabe von Parametern bzw. Steuersignalen an das Hauptprogramm.

=== Verschachtelte Interrupts ===

Einige Mikrocontroller, wie z.B. der [[AVR]] kennen nur zwei CPU-Zustände. Normale Programmausführung und Interruptausführung, gesteuert durch das I-Bit der CPU. Die normale Programmausführung kann jederzeit durch Interrupts unterbrochen werden. Die Interruptausführung kann nicht durch neue Interrupts unterbrochen werden. Die ISR wird erst zu Ende bearbeitet, zurück in die normale Programmausführung gesprungen und erst dann werden neue, wartende (engl. pending) Interrupts bearbeitet.

Etwas komplexere Mikrocontroller oder grosse Prozessoren bieten verschiedene Interruptlevel (Stufen) an . Dabei gilt meist je niedriger die Zahl des Levels, um so höher die Priorität. Ein Interrupt mit höherer Priorität kann einen Interrupt mit niedriger Priorität unterbrechen. Ein Interrupt mit gleicher Priorität wie der gerade bearbeitete Interrupt kann das im allgemeinen nicht. Das nennt man verschachtelte Interrupts (engl. nested interrupts). Klassische Vertreter hierfür sind [[8051]], PowerPC, [[X86]] und Motorola 68000.

Auf dem AVR kann man [[AVR-GCC-Tutorial#Unterbrechbare_Interruptroutinen | verschachtelte Interrupts]] sowohl in Assembler als auch in C nachbilden, allerdings mit einigen Einschränkungen und Tücken. Das ist jedoch Leuten vorbehalten, die schon viel Erfahrung auf diesem Gebiet haben. Zu 99,9% braucht man sie nicht.

=== Zeitverhalten eines Timerinterrupts ===

Ein Timerinterrupt wird im allgemeinen dazu genutzt, in konstanten, periodischen Abständen bestimmte Funktionen aufzurufen. Es ist möglich, dass während eines Timerinterrupts derselbe Interrupt wieder aktiv wird, weil die Routine sehr verzweigt ist und dieses Mal sehr lange dauert.

Wenn zum Beispiel der Timerinterrupt mit einer Periodendauer von 100ms aufgerufen wird, er aber unter bestimmten Umständen 180ms benötigt, dann wird nach 100ms nach Eintritt in die ISR der Interrupt wieder aktiv, das Timer Interrupt Flag wird gesetzt. Da aber gerade ein Interrupt bearbeitet wird, wird er nicht sofort angesprungen, weil währenddessen die Interruptfunktion global gesperrt ist (beim AVR ist das I-Bit in der CPU gelöscht). Der Interrupt wird zu Ende bearbeitet, die CPU springt zurück zum Hauptprogramm. Dabei werden die Interrupts wieder global eingeschaltet. Der zwischenzeitlich eingetroffene und zwischengespeicherte Interrupt wird nun sofort ausgeführt, sodass das Hauptprogramm praktisch gar nicht weiter kommt, bestenfalls einen Maschinenbefehl. Nun sind aber nur noch 20ms bis zum nächsten Timerinterrupt übrig. Wenn dieser nun wieder 180 ms benötigt werden in dieser Zeit aber '''zwei''' Interrupts ausgelöst, nach 20ms und 120ms. Da diese aber nicht gezählt oder andersweitig einzeln gespeichert werden können, geht ein Interrupt verloren. Das ist ein Programmfehler.

=== Zeitverhalten des UART Empfangsinterrupts ===

Ein [[UART]] Interrupt zum Empfang von Daten per [[RS232]] mit 115200 [[Baud]] ist ein recht häufiges Ereignis (1 Zeichen = 10 Bits = 86,8μs). Wenn kontinuierlich Daten empfangen werden, wird nach jeweils 86,8μs ein neuer Interrupt ausgelöst. Dabei wird das empfangene Datenbyte vom UART aus dem Empfangsschiebegregister in einem Puffer kopiert. Während das neue Zeichen Bit für Bit empfangen wird, wird es zunächst im Schieberegister des UART gespeichert. Die Daten im Puffer bleiben davon unberührt. Die CPU muss nun schnell das empfangene Datenbyte aus dem Empfangsbuffer auslesen. Die maximale Verzögerung, die sich die CPU erlauben kann von der Aktivierung des Interrupts bis zum tatsächlichen Auslesen des Datenregisters beträgt ziemlich genau die Übertragungszeit von einem Zeichen. Wenn bis dahin nicht das Zeichen von der CPU ausgelesen wurde, wird es vom UART überschrieben und ein Fehler im Statusregister des UART signalisiert (Overrun, Überlauf des Datenpuffers). Die UARTs in heutigen Mikrocontrollern haben mindestens ein Byte Puffer wie hier beschrieben. Die neueren [[AVR]]s haben sogar effektiv 3 Byte Puffer im UART, praktisch ein kleines [[FIFO]], womit der Datenempfang besser gepuffert werden kann, wenn die CPU gerade mit anderen sehr wichtigen Dingen beschäftigt ist. D.h. kurzzeitig kann sich die CPU erlauben, die Übertragungszeit von bis zu drei Zeichen zu warten, ehe sie die Daten ausliest. Dann müssen sie aber sehr schnell hintereinander gelesen werden. Im Mittel hat die CPU aber nur die Übertragungszeit eines Zeichens zur Verfügung, um es abzuholen.

=== Zusammenfassung ===

Interruptserviceroutinen:
* sollten so kurz wie möglich gehalten werden
* können im Einzelfall nahezu doppelt so lange dauern wie die kürzeste Periodendauer des Ereignisses, ohne dass Interrupts verloren gehen (z.B. Timerinterrupt).
* dürfen im Mittel maximal solange dauern wie die kürzeste Periodendauer des Ereignisses
* dürfen maximal solange dauern, wie die kürzeste Periodendauer des Ereignisses, wenn man auf Nummer sicher gehen will, dass keine Interrupts verschluckt werden
* Die Interruptzeit versteht sich immer abzüglich einer kleinen Reserve für das Anspringen und Verlassen des Interrupt minus Panikreserve

== Beispiele für die praktische Programmierung ==

Die Beispiele sind mit WINAVR 20060421 compiliert und getestet worden. Als Mikrocontroller wird ein AVR vom Typ ATmega32 verwendet. Alle Programme wurden mit Optimierungsstufe -Os compiliert.

=== Steuersignale zwischen ISR und Hauptprogramm ===

In vielen Anwendungen wird ein Timer verwendet, um in regelmässigen Abständen bestimmte Aktionen auszuführen, wie z.B. Tasten abfragen, ADC-auslesen, ein LCD auffrischen etc. Wenn viele Dinge zu erledigen sind, nebenbei aber noch andere Interrupts verwendet werden, dann ist es notwendig die Funktionsaufrufe aus dem Timerinterrupt in die Hauptschleife zu verlagern. Der Interrupt signalisiert über eine Steuervariable (engl. Flag, Flagge), das ein neuer Timerzyklus begonnen hat. Dadurch wird der Timerinterrupt sehr kurz und die langwierigen, aber meist nicht zeitkritischen Funktionen werden als normales Programm ausgeführt. Damit kann die CPU auf andere Interrupts schnell reagieren.

Wichtig ist auf jeden Fall, dass die Steuervariable, welche in der ISR und in der Hauptschleife verwendet wird, mit [http://www.netrino.com/Embedded-Systems/How-To/C-Volatile-Keyword '''volatile'''] deklariert wird. Ausserdem muss sowohl der Lese- als auch Schreibzugriff auf die Steuersignale [[#Atomarer Datenzugriff | '''atomar''']] sein. Auf dem AVR ist das mit 8 Bit Variablen direkt möglich, für grössere Variablen müssen die Interrupts kurzzeitig gesperrt werden.

Das Beispiel ist sehr einfach gehalten um das Prinzip zu veranschaulichen. Ein Timer mit einer Überlaufperiodendauer von ca. 65ms stösst periodisch eine Funktion zum Togglen einer LED an, welche dadurch mit ca. 7 Hz blinkt.

<c>
/*
*******************************************************************************
*
* Timer Interrupt Demo
*
* ATmega32 mit internem 1 MHz Oszillator
*
* LOW Fuse Byte = 0xE1
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
*
*******************************************************************************
*/

#define F_CPU 1000000

#include <avr/io.h>
#include <avr/interrupt.h>

// globale Variablen

volatile uint8_t flag;

int main() {

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFF;

// Timer2 konfigurieren

TCCR2 = 6; // Vorteiler 256 -> ~65ms Überlaufperiode
TIMSK |= (1<<TOIE2); // Timer Overflow Interrupt freischalten

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {
if (flag == 1) { // Neuer Timerzyklus ?
flag = 0;

// hier steht jetzt in Normalfall ein grosser Programmblock ;-)
PORTD ^= (1 << PD5); // LED toggeln
}
}
}

// Timer2 overflow Interrupt
// hier wird der Hauptschleife ein neuer Timerinterrupt signalisiert

ISR( TIMER2_OVF_vect ) {
flag = 1;
}
</c>

=== UART mit Interrupts ===

Der UART ist ein oft benutztes Modul eines Mikrocontrollers. Anfänger nutzen ihn meist im sogenannten Polling Betrieb (engl. to poll, abfragen). D.h. wenn ein Zeichen empfangen werden soll, fragt eine Funktion den UART in einer Schleife ununterbrochen ab, ob Daten empfangen wurden. In dieser Zeit macht die CPU nichts anderes! Und wenn lange kein Zeichen eintrifft tut sie sehr lange nichts, sie ist praktisch blockiert! Senden verläuft ähnlich, nur dass hier die CPU vor dem Senden prüft, ob der UART ein neues Byte aufnehmen kann. D.h. während der UART selbsttätig das Zeichen sendet ist die CPU zum Warten verdammt. All diese Nachteile haben nur einen Vorteil. Die Funktionen und Mechanismen zur UART-Nutzung sind sehr einfach, klein und leicht anwendbar.

Will man aber die CPU nicht sinnlos warten lassen, was vor allem bei niedrigeren Baudraten ziemlich lange sein kann, muss man die Interrupts nutzen. Der AVR hat gleich drei davon.

* '''RXC''' (Receive Complete): Ein Zeichen wurde empfangen.
* '''UDRE''' (UART Data Register Empty): Der Zwischenpuffer des Senders ist leer und kann ein neues Zeichen aufnehmen. Dieser Zwischenpuffer ist wichtig, um lückenlos auch bei hohen Baudraten senden zu können.
* '''TXC''' (Transmit Complete): Das aktuelle Zeichen wurde vollständig inclusive Stopbit gesendet und es liegt kein neues Datenbyte im Sendepuffer. Dieser Interrupt ist extrem nützlich für eine Halbduplexkommunikation, z.B. auf einem RS485-[[Bus]]. Hier kann man nach dem vollständigen Senden aller Bytes den Bustranceiver (z.B. MAX485) von Senden auf Empfangen umschalten, um den Bus freizugeben.

Bei Nutzung der Interrupts kann die CPU andere Dinge bearbeiten und muss nur kurz einen Interrupt ausführen, wenn ein Zeichen empfangen oder gesendet wurde.

Die Kommunikation zwischen ISRs und Hauptschleife erfolgt wieder durch Flags und zwei Pufferarrays (uart_rx_buffer und uart_tx_buffer). Es gibt zwei Funktionen, eine zum Senden von Strings, eine zum Empfangen. Das Senden sowie Empfangen kann parallel erfolgen und läuft vollkommen unabhängig vom Hauptprogramm. Die Daten werden in spezielle Puffer kopiert, sodass das Hauptprogramm mit seinen Strings sofort weiterarbeiten kann. Im Beispiel ist die CPU nicht wirklich mit sinnvollen Dingen beschäftigt, zur Demonstration des Prinzips aber ausreichend.

Um das das Programm real zu nutzen braucht man ein Terminalprogramm, z.B. Hyperterminal von Windows. Dort muss nur die richtige Baudrate eingestellt werden (9600 8N1, 9600 Baud, 8 Bits, keine Parität, 1 Stopbit, keine Flusskontrolle). Ausserdem muss man im Menu Datei -> Eigenschaften -> Einstellungen -> ASCII Konfiguration den Punkt "Eingegebene Zeichen lokal ausgeben (lokales Echo)" aktivieren. Nun kann man beliebige Texte eintippen. Mit RETURN wird die Eingabe abgeschlossen und der AVR vermittelt den empfangenen String an das Hauptprogramm. Diese sendet ihn einfach zurück, paralle dazu wird der String gemorst per LED angezeigt. Sollte es Probleme bei der Inbetriebnahme des UART geben, so findet man hier wichtige Hinweise zur [[AVR_Checkliste#UART.2FUSART | Fehlersuche]].

<c>
/*
*******************************************************************************
*
* UART Interrupt Demo
*
* ATmega32 mit 3,6864 MHz Quarz an XTAL1/XTAL2
*
* LOW Fuse Byte = 0xFF
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
* An PD0/PD1 ist ein MAX232 angeschlosssen, um Daten vom PC zu empfangen/senden
*
*******************************************************************************
*/

// Systemtakt in Hz, das L am Ende ist wichtig, NICHT UL verwenden!
#define F_CPU 3686400L
// "Morsedauer" für ein Bit in Millisekunden
#define BITZEIT 100

#include <string.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Baudrate, das L am Ende ist wichtig, NICHT UL verwenden!
#define BAUD 9600L

// Berechnungen
// clever runden
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)
// Reale Baudrate
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))
// Fehler in Promille
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000)

#if ((BAUD_ERROR>10) || (BAUD_ERROR<-10))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif

// globale Variablen für den UART

// Puffergrösse in Bytes, RX und TX sind gleich gross
#define uart_buffer_size 32

volatile uint8_t uart_rx_flag=0; // Flag, String komplett empfangen
volatile uint8_t uart_tx_flag=1; // Flag, String komplett gesendet
char uart_rx_buffer[uart_buffer_size]; // Empfangspuffer
char uart_tx_buffer[uart_buffer_size]; // Sendepuffer

// lange, variable Wartezeit, Einheit in Millisekunden
void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

// einen String senden
// vor Aufruf der Funktion muss man prüfen, ob uart_t_flag==1 ist
// nur dann kann ein neuer String gesendet werden

void put_string(char *daten) {

if (uart_tx_flag==1) {
// String daten ind en Sendepuffer kopieren
strcpy(uart_tx_buffer, daten);
// Flag für 'Senden ist komplett' löschen,
uart_tx_flag = 0;
// UDRE Interrupt einschalten, los gehts
UCSRB |= (1<<UDRIE);
}
}

// einen empfangenen String kopieren
// vor Aufruf der Funktion muss man prüfen, ob uart_rx_flag==1 ist
// anderenfalls ist der RX Buffer noch ungültig

void get_string(char *daten) {

if (uart_rx_flag==1) {
// String kopieren
strcpy(daten, uart_rx_buffer);
// Flag löschen
uart_rx_flag = 0;
}
}

// Ein Byte im RS232 Format auf eine LED ausgeben

void morse(uint8_t data) {
uint8_t i;

// Startbit, immer 0
PORTD &= ~(1 << PD5); // LED aus
long_delay(BITZEIT);

for(i=0; i<8; i++) {
if (data & 0x01) // Prüfe Bit #0
PORTD |= (1 << PD5); // LED an
else
PORTD &= ~(1 << PD5); // LED aus
long_delay(BITZEIT);
data >>= 1; // nächstes Bit auf Bit #0 schieben
}
// Stopbit, immer 1
PORTD |= (1 << PD5); // LED an
long_delay(BITZEIT);
}

// Hauptprogramm

int main (void) {

char stringbuffer[64]; // Allgemeiner Puffer für Strings
uint8_t buffer_full=0; // noch ein Flag, aber nur in der Hauptschleife
char * charpointer; // Hilfszeiger

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFF;

// UART konfigurieren

UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
UCSRB = (1<<RXCIE) | (1<<RXEN) | (1<<TXEN);

// Stringpuffer initialisieren

stringbuffer[0] = '\n';
stringbuffer[1] = '\r';

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {

// "Sinnvolle" CPU Tätigkeit
PORTD &= ~(1<<PD5);
long_delay(300);
PORTD |= (1<<PD5);
long_delay(300);

// Wurde ein kompletter String empfangen
// und der Buffer ist leer?
if (uart_rx_flag==1 && buffer_full==0) {
// ja, dann String lesen,
// die ersten zwei Zeichen
// aber nicht überschreiben
get_string(stringbuffer+2);
buffer_full=1;
}

// Ist letzte Stringsendung abgeschlossen
// und ein neuer String verfügbar?
if (uart_tx_flag==1 && buffer_full==1) {
// Newline + Carrige return anfügen
strcat(stringbuffer, "\n\r");
put_string(stringbuffer); // zurücksenden
buffer_full=0; // Buffer ist wieder verfügbar
// Alle Zeichen per LED morsen
charpointer = stringbuffer;
while(*charpointer) morse(*charpointer++);
}
}
}

// UART RX complete interrupt

// hier werden Daten vom PC empfangen und in einem String zwischengespeichert
// Wird ein Stringterminator empfangen, wird ein Flag gesetzt, welches dem
// Hauptprogramm den kompletten Empfang signalisiert

ISR(USART_RXC_vect) {

static uint8_t uart_rx_cnt; // Zähler für empfangene Zeichen
uint8_t data;

// Daten auslesen, dadurch wird das Interruptflag gelöscht
data = UDR;

// Ist Puffer frei für neue Daten?
if (!uart_rx_flag) {
// ja, ist Ende des Strings (RETURN) erreicht?
if (data=='\r') {
// ja, dann String terminieren
uart_rx_buffer[uart_rx_cnt]=0;
// Flag für 'Empfangspuffer voll' setzen
uart_rx_flag=1;
// Zähler zurücksetzen
uart_rx_cnt=0;
}
else if (uart_rx_cnt<(uart_buffer_size-1)) {
// Daten in Puffer speichern
// aber durch if() Pufferüberlauf vermeiden
uart_rx_buffer[uart_rx_cnt]=data;
uart_rx_cnt++; // Zähler erhöhen
}
}
}

// UART TX data register empty interrupt
// hier werden neue Daten in das UART Senderegister geladen

ISR(USART_UDRE_vect) {
// Zeiger auf Sendepuffer
static char* uart_tx_p = uart_tx_buffer;
uint8_t data;

// zu sendendes Zeichen lesen,
// Zeiger auf Sendepuffer erhöhen
data = *uart_tx_p++;

// Ende des nullterminierten Strings erreicht?
if (data==0 ) {
UCSRB &= ~(1<<UDRIE); // ja, dann UDRE Interrupt ausschalten
uart_tx_p = uart_tx_buffer; // Pointer zurücksetzen
uart_tx_flag = 1; // Flag setzen, Übertragung beeendet
}
else UDR = data; // nein, Daten senden
}
</c>

=== Wie lange dauert meine Interruptroutine ? ===

Diese Frage sollte man beantworten können, zumindest sollte eine Worst Case Abschätzung gemacht werden. Das geht auf zwei Wegen.

* Simulation, dabei muss in einer verzweigten ISR der längste Pfad simuliert werden. Dazu müssen alle beteiligten Variablen auf den ensprechenden Wert gesetzt werden.
* Messung mit dem [[Oszilloskop]], dabei wird zum Beginn der ISR ein Pin auf HIGH gesetzt und am Ende auf LOW. Damit kann man in Echtzeit die Dauer der ISR messen. Die zusätzlichen Taktzyklen zum Aufruf und verlassen der ISR sind konstant und im wesentlichen bekannt. Mit einem modernen Digitaloszilloskop und dem "Infinite Persistence Mode" kann man eine Worst Case Messung vornehmen

Als Hilfmittel zur Fehlersuche kann man auch am Ende der ISR prüfen, ob das jeweilige Interrupt-Request Bit schon wieder gesetzt ist. Wenn ja, dann ist die ISR in den meisten Fällen zu lang. Auch hier kann man einen Ausgang auf HIGH setzen und somit den Fehler anzeigen.

==Interruptfeste Programmierung==

=== Atomarer Datenzugriff ===

Von einem atomaren (engl. atomic) Datenzugriff spricht man, wenn der Zugriff innerhalb einer nicht unterbrechbaren Maschinenanweisung abgearbeitet wird.

Alle Variablen, Steuerregister und I/O-Ports, die sowohl im Hauptprogramm als auch in Interrupts verwendet werden, sind mit viel Sorgfalt zu behandeln.

Beispiel:
<c>
port |= 0x03;
</c>
übersetzt sich auf AVR Prozessoren in
<avrasm>
IN r16,port
ORI r16,0x03
OUT port,r16
</avrasm>
Wenn nun zwischen IN und OUT ein Interrupt auftritt, der beispielsweise Bit 7 verändert, dann geht mit dem OUT-Befehl diese Änderung verloren, da der OUT Befehl den alten Zustand vor dem Interrupt wiederherstellt.

'''Gefährlich ist das insbesondere deshalb, weil der Fall nur selten auftritt und dies Verhalten sehr schlecht reproduzierbar ist.'''

Bei verschiedenen Prozessor-Architekturen tritt das Problem verschieden häufig auf. So übersetzt sich obiger Code bei MSP430 Prozessoren in einen einzelnen Befehl
<pre>
OR #0x03,port
</pre>
und stellt somit kein Problem dar. Im Zweifel hilft nur ein Blick in den erzeugten Assembler-Code. Bei der Übernahme fremden Codes ist dies zu beachten. Was bei i51 kein Problem war, kann bei AVR zu einem Problem werden, unter Umständen sogar abhängig von verwendeten Port sein.

Ein ähnliches Problem entsteht bei Variablen, deren Grösse die Wortbreite der Maschine übersteigt. Bei 8-Bit-Prozessoren wie AVR oder i51 also bereits bei normalen "int" Variablen. Diese Variablen werden zwangsläufig byteweise verarbeitet. Wenn genau dazwischen ein Interrupt erfolgt, wird ein falscher Wert gelesen. Wenn beispielsweise eine Interrupt-Routine einen 16-Bit-Zähler verwendet und von 0x00FF auf 0x0100 hochzählt, dann kann das Hauptprogramm auch schon mal versehentlich die Werte 0x01FF oder 0x0000 lesen.

Dies ist auch ein Grund, weshalb für Programmierung auf derart "niedriger" Ebene Kenntnisse in Prozessorarchitektur und Assembler-Programmierung sehr hilfreich sind.

'''Abhilfe''': Wenn man sich nicht wirklich ganz sicher ist, sollten um kritische Aktivitäten herum jedesmal die Interrupts abgeschaltet werden.

Beispiel ([[AVR-GCC]]):
<c>
cli(); // Interrupts abschalten
port |= 0x03;
sei(); // Interrupts wieder einschalten
</c>

Wenn man ein globales Einschalten der Interrupts mit sei() vermeiden will, kann man die folgende Methode benutzen. Hierbei werden die Interrupts nur eingeschaltet, wenn sie vorher bereits eingeschaltet waren (Hinweis aus der FAQ von avr-libc):

<c>
{
// ...
{
uint8_t sreg; // Lokale Sicherungskopie von SREG
sreg = SREG;
cli();
// hierhin kommt der Code mit atomarem Zugriff
SREG = sreg;
}
// ...
}
</c>

Je nach Prozessor kann man das Problem manchmal auch ohne Abschalten von Interrupts durch geeignete Programmierung lösen. So führt
<c>
port = (port & ~0x0F) | lcd_data;
</c>
immer zum beschriebenen Problem,
<c>
port &= ~0x0F;
port |= lcd_data;
</c>
jedoch nicht, wenn die beiden Zeilen zu jeweils einem Assembler-Befehl übersetzt werden. Was dann aber abhängig von den Optimierungs-Einstellungen des Compilers werden kann. Eine Interrupt-feste Variante für AVR-Prozessoren der neuesten Generation, wie beispielsweise Tiny2313 und Mega88 (alle ab 2004):
<c>
PINx = (PORTx & 0x0F) ^ lcd_data;
</c>

=== Reentrante Funktionen ===

Eine Funktion ist reentrant (wiedereintrittsfest), wenn sie mehrmals gleichzeitig aktiv sein kann, ohne dass sich diese Aufrufe gegenseitig beeinflussen. Betrifft beispielsweise Funktionen, die sowohl im Hauptprogramm als auch in Interrupts aufgerufen werden. Manche C Compiler erfordern eine besondere Kennzeichnung solcher Funktionen. Wenn möglich sollte man es jedoch vermeiden, eine Funktion aus dem Hauptprogramm '''und''' aus einem Interrupt aus aufzurufen. Das ist meist problemlos machbar.

== Siehe auch ==
* [[Timer]]
* [[AVR-Tutorial: Interrupts | AVR-Tutorial - Interrupts in Assembler]]
* [[AVR-GCC-Tutorial#Programmieren_mit_Interrupts | AVR-GCC-Tutorial - Interrupts in C]]
* [[ADC]]

Interrupt

2007-12-22T13:13:06Z

FalkB: Formatierung geändert, Tipfehler korrigiert, UART DEMO korrigiert

== Einleitung ==

Bei bestimmten Ereignissen in Prozessoren wird ein '''Interrupt''' ausgelöst. Dabei wird das Programm unterbrochen und ein Unterprogramm, die sogenannte '''I'''nterrupt '''S'''ervice '''R'''outine ('''ISR'''), aufgerufen. Wenn dieses beendet ist läuft das Hauptprogramm ganz normal weiter.

Bei [[Mikrocontroller]]n werden Interrupts z.B. ausgelöst wenn:
* sich der an einem bestimmten Eingangs-Pin anliegende Pegel ändert
* eine vorher festgelegte Zeitspanne abgelaufen ist ([[Timer]])
* eine [[Seriell|serielle]] Übertragung abgeschlossen ist
* eine Messung des [[ADC |Analog-Digital-Wandlers]] abgeschlossen ist

== Wichtige Eigenschaften von ISRs ==

ISRs reagieren auf ein bestimmtes Ereignis, welches relativ oft oder selten passiert. Prinzipiell sollte man ISRs möglichst kurz halten und schnell beenden. '''Im Mittel muss die Interruptroutine kürzer sein als die Periodendauer des Ereignises, anderenfalls wird es passieren, dass Interrupts "verschluckt" werden''', d.h. beim UART gehen Daten verloren, beim Timer gehen Zählzyklen verloren, beim AD-Wandler gehen Daten verloren etc. '''Solche verschluckten Interrupts sind bisweilen schwer zu finden, weil es bisweilen nur sehr wenige in ganz bestimmten Konstellationen sind.''' Wenn dann eine per Timer realisierte Uhr in der Stunde um 1s falsch geht, merkt man das oft nicht. '''Langwierige Berechnungen, Auswertungen, Ausgaben oder gar Warteschleifen haben in ISRs nichts zu suchen.''' Typische C-Funktionen wie printf(), scanf(), längere Ausgaben auf ein [[LCD]] etc. sollte man nicht in ISRs vornehmen. Hier kommt sinnvollerweise eine andere Programmiertechnik zu Einsatz, nämlich die Übergabe von Parametern bzw. Steuersignalen an das Hauptprogramm.

=== Verschachtelte Interrupts ===

Einige Mikrocontroller, wie z.B. der [[AVR]] kennen nur zwei CPU-Zustände. Normale Programmausführung und Interruptausführung, gesteuert durch das I-Bit der CPU. Die normale Programmausführung kann jederzeit durch Interrupts unterbrochen werden. Die Interruptausführung kann nicht durch neue Interrupts unterbrochen werden. Die ISR wird erst zu Ende bearbeitet, zurück in die normale Programmausführung gesprungen und erst dann werden neue, wartende (engl. pending) Interrupts bearbeitet.

Etwas komplexere Mikrocontroller oder grosse Prozessoren bieten verschiedene Interruptlevel (Stufen) an . Dabei gilt meist je niedriger die Zahl des Levels, um so höher die Priorität. Ein Interrupt mit höherer Priorität kann einen Interrupt mit niedriger Priorität unterbrechen. Ein Interrupt mit gleicher Priorität wie der gerade bearbeitete Interrupt kann das im allgemeinen nicht. Das nennt man verschachtelte Interrupts (engl. nested interrupts). Klassische Vertreter hierfür sind [[8051]], PowerPC, [[X86]] und Motorola 68000.

Auf dem AVR kann man [[AVR-GCC-Tutorial#Unterbrechbare_Interruptroutinen | verschachtelte Interrupts]] sowohl in Assembler als auch in C nachbilden, allerdings mit einigen Einschränkungen und Tücken. Das ist jedoch Leuten vorbehalten, die schon viel Erfahrung auf diesem Gebiet haben. Zu 99,9% braucht man sie nicht.

=== Zeitverhalten eines Timerinterrupts ===

Ein Timerinterrupt wird im allgemeinen dazu genutzt, in konstanten, periodischen Abständen bestimmte Funktionen aufzurufen. Es ist möglich, dass während eines Timerinterrupts derselbe Interrupt wieder aktiv wird, weil die Routine sehr verzweigt ist und dieses Mal sehr lange dauert.

Wenn zum Beispiel der Timerinterrupt mit einer Periodendauer von 100ms aufgerufen wird, er aber unter bestimmten Umständen 180ms benötigt, dann wird nach 100ms nach Eintritt in die ISR der Interrupt wieder aktiv, das Timer Interrupt Flag wird gesetzt. Da aber gerade ein Interrupt bearbeitet wird, wird er nicht sofort angesprungen, weil währenddessen die Interruptfunktion global gesperrt ist (beim AVR ist das I-Bit in der CPU gelöscht). Der Interrupt wird zu Ende bearbeitet, die CPU springt zurück zum Hauptprogramm. Dabei werden die Interrupts wieder global eingeschaltet. Der zwischenzeitlich eingetroffene und zwischengespeicherte Interrupt wird nun sofort ausgeführt, sodass das Hauptprogramm praktisch gar nicht weiter kommt, bestenfalls einen Maschinenbefehl. Nun sind aber nur noch 20ms bis zum nächsten Timerinterrupt übrig. Wenn dieser nun wieder 180 ms benötigt werden in dieser Zeit aber '''zwei''' Interrupts ausgelöst, nach 20ms und 120ms. Da diese aber nicht gezählt oder andersweitig einzeln gespeichert werden können, geht ein Interrupt verloren. Das ist ein Programmfehler.

=== Zeitverhalten des UART Empfangsinterrupts ===

Ein [[UART]] Interrupt zum Empfang von Daten per [[RS232]] mit 115200 [[Baud]] ist ein recht häufiges Ereignis (1 Zeichen = 10 Bits = 86,8μs). Wenn kontinuierlich Daten empfangen werden, wird nach jeweils 86,8μs ein neuer Interrupt ausgelöst. Dabei wird das empfangene Datenbyte vom UART aus dem Empfangsschiebegregister in einem Puffer kopiert. Während das neue Zeichen Bit für Bit empfangen wird, wird es zunächst im Schieberegister des UART gespeichert. Die Daten im Puffer bleiben davon unberührt. Die CPU muss nun schnell das empfangene Datenbyte aus dem Empfangsbuffer auslesen. Die maximale Verzögerung, die sich die CPU erlauben kann von der Aktivierung des Interrupts bis zum tatsächlichen Auslesen des Datenregisters beträgt ziemlich genau die Übertragungszeit von einem Zeichen. Wenn bis dahin nicht das Zeichen von der CPU ausgelesen wurde, wird es vom UART überschrieben und ein Fehler im Statusregister des UART signalisiert (Overrun, Überlauf des Datenpuffers). Die UARTs in heutigen Mikrocontrollern haben mindestens ein Byte Puffer wie hier beschrieben. Die neueren [[AVR]]s haben sogar effektiv 3 Byte Puffer im UART, praktisch ein kleines [[FIFO]], womit der Datenempfang besser gepuffert werden kann, wenn die CPU gerade mit anderen sehr wichtigen Dingen beschäftigt ist. D.h. kurzzeitig kann sich die CPU erlauben, die Übertragungszeit von bis zu drei Zeichen zu warten, ehe sie die Daten ausliest. Dann müssen sie aber sehr schnell hintereinander gelesen werden. Im Mittel hat die CPU aber nur die Übertragungszeit eines Zeichens zur Verfügung, um es abzuholen.

=== Zusammenfassung ===

Interruptserviceroutinen:
* sollten so kurz wie möglich gehalten werden
* können im Einzelfall nahezu doppelt so lange dauern wie die kürzeste Periodendauer des Ereignisses, ohne dass Interrupts verloren gehen (z.B. Timerinterrupt).
* dürfen im Mittel maximal solange dauern wie die kürzeste Periodendauer des Ereignisses
* dürfen maximal solange dauern, wie die kürzeste Periodendauer des Ereignisses, wenn man auf Nummer sicher gehen will, dass keine Interrupts verschluckt werden
* Die Interruptzeit versteht sich immer abzüglich einer kleinen Reserve für das Anspringen und Verlassen des Interrupt minus Panikreserve

== Beispiele für die praktische Programmierung ==

Die Beispiele sind mit WINAVR 20060421 compiliert und getestet worden. Als Mikrocontroller wird ein AVR vom Typ ATmega32 verwendet. Alle Programme wurden mit Optimierungsstufe -Os compiliert.

=== Steuersignale zwischen ISR und Hauptprogramm ===

In vielen Anwendungen wird ein Timer verwendet, um in regelmässigen Abständen bestimmte Aktionen auszuführen, wie z.B. Tasten abfragen, ADC-auslesen, ein LCD auffrischen etc. Wenn viele Dinge zu erledigen sind, nebenbei aber noch andere Interrupts verwendet werden, dann ist es notwendig die Funktionsaufrufe aus dem Timerinterrupt in die Hauptschleife zu verlagern. Der Interrupt signalisiert über eine Steuervariable (engl. Flag, Flagge), das ein neuer Timerzyklus begonnen hat. Dadurch wird der Timerinterrupt sehr kurz und die langwierigen, aber meist nicht zeitkritischen Funktionen werden als normales Programm ausgeführt. Damit kann die CPU auf andere Interrupts schnell reagieren.

Wichtig ist auf jeden Fall, dass die Steuervariable, welche in der ISR und in der Hauptschleife verwendet wird, mit [http://www.netrino.com/Embedded-Systems/How-To/C-Volatile-Keyword '''volatile'''] deklariert wird. Ausserdem muss sowohl der Lese- als auch Schreibzugriff auf die Steuersignale [[#Atomarer Datenzugriff | '''atomar''']] sein. Auf dem AVR ist das mit 8 Bit Variablen direkt möglich, für grössere Variablen müssen die Interrupts kurzzeitig gesperrt werden.

Das Beispiel ist sehr einfach gehalten um das Prizip zu veranschaulichen. Ein Timer mit einer Überlaufperiodendauer von ca. 65ms stösst periodisch eine Funktion zum Togglen einer LED an, welche dadurch mit ca. 7 Hz blinkt.

<c>
/*
*******************************************************************************
*
* Timer Interrupt Demo
*
* ATmega32 mit internem 1 MHz Oszillator
*
* LOW Fuse Byte = 0xE1
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
*
*******************************************************************************
*/

#define F_CPU 1000000

#include <avr/io.h>
#include <avr/interrupt.h>

// globale Variablen

volatile uint8_t flag;

int main() {

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFF;

// Timer2 konfigurieren

TCCR2 = 6; // Vorteiler 256 -> ~65ms Überlaufperiode
TIMSK |= (1<<TOIE2); // Timer Overflow Interrupt freischalten

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {
if (flag == 1) { // Neuer Timerzyklus ?
flag = 0;

// hier steht jetzt in Normalfall ein grosser Programmblock ;-)
PORTD ^= (1 << PD5); // LED toggeln
}
}
}

// Timer2 overflow Interrupt
// hier wird der Hauptschleife ein neuer Timerinterrupt signalisiert

ISR( TIMER2_OVF_vect ) {
flag = 1;
}
</c>

=== UART mit Interrupts ===

Der UART ist ein oft benutztes Modul eines Mikrocontrollers. Anfänger nutzen ihn meist im sogenannten Polling Betrieb (engl. to poll, abfragen). D.h. wenn ein Zeichen empfangen werden soll, fragt eine Funktion den UART in einer Schleife ununterbrochen ab, ob Daten empfangen wurden. In dieser Zeit macht die CPU nichts anderes! Und wenn lange kein Zeichen eintrifft tut sie sehr lange nichts, sie ist praktisch blockiert! Senden verläuft ähnlich, nur dass hier die CPU vor dem Senden prüft, ob der UART ein neues Byte aufnehmen kann. D.h. während der UART selbsttätig das Zeichen sendet ist die CPU zum Warten verdammt. All diese Nachteile haben nur einen Vorteil. Die Funktionen und Mechanismen zur UART-Nutzung sind sehr einfach, klein und leicht anwendbar.

Will man aber die CPU nicht sinnlos warten lassen, was vor allem bei niedrigeren Baudraten ziemlich lange sein kann, muss man die Interrupts nutzen. Der AVR hat gleich drei davon.

* '''RXC''' (Receive Complete): Ein Zeichen wurde empfangen.
* '''UDRE''' (UART Data Register Empty): Der Zwischenpuffer des Senders ist leer und kann ein neues Zeichen aufnehmen. Dieser Zwischenpuffer ist wichtig, um lückenlos auch bei hohen Baudraten senden zu können.
* '''TXC''' (Transmit Complete): Das aktuelle Zeichen wurde vollständig inclusive Stopbit gesendet und es liegt kein neues Datenbyte im Sendepuffer. Dieser Interrupt ist extrem nützlich für eine Halbduplexkommunikation, z.B. auf einem RS485-[[Bus]]. Hier kann man nach dem vollständigen Senden aller Bytes den Bustranceiver (z.B. MAX485) von Senden auf Empfangen umschalten, um den Bus freizugeben.

Bei Nutzung der Interrupts kann die CPU andere Dinge bearbeiten und muss nur kurz einen Interrupt ausführen, wenn ein Zeichen empfangen oder gesendet wurde.

Die Kommunikation zwischen ISRs und Hauptschleife erfolgt wieder durch Flags und zwei Pufferarrays (uart_rx_buffer und uart_tx_buffer). Es gibt zwei Funktionen, eine zum Senden von Strings, eine zum Empfangen. Das Senden sowie Empfangen kann parallel erfolgen und läuft vollkommen unabhängig vom Hauptprogramm. Die Daten werden in spezielle Puffer kopiert, sodass das Hauptprogramm mit seinen Strings sofort weiterarbeiten kann. Im Beispiel ist die CPU nicht wirklich mit sinnvollen Dingen beschäftigt, zur Demonstration des Prinzips aber ausreichend.

Um das das Programm real zu nutzen braucht man ein Terminalprogramm, z.B. Hyperterminal von Windows. Dort muss nur die richtige Baudrate eingestellt werden (9600 8N1, 9600 Baud, 8 Bits, keine Parität, 1 Stopbit, keine Flusskontrolle). Ausserdem muss man im Menu Datei -> Eigenschaften -> Einstellungen -> ASCII Konfiguration den Punkt "Eingegebene Zeichen lokal ausgeben (lokales Echo)" aktivieren. Nun kann man beliebige Texte eintippen. Mit RETURN wird die Eingabe abgeschlossen und der AVR vermittelt den empfangenen String an das Hauptprogramm. Diese sendet ihn einfach zurück, paralle dazu wird der String gemorst per LED angezeigt. Sollte es Probleme bei der Inbetriebnahme des UART geben, so findet man hier wichtige Hinweise zur [[AVR_Checkliste#UART.2FUSART | Fehlersuche]].

<c>
/*
*******************************************************************************
*
* UART Interrupt Demo
*
* ATmega32 mit 3,6864 MHz Quarz an XTAL1/XTAL2
*
* LOW Fuse Byte = 0xFF
*
* An PD5 muss eine LED mit 1 kOhm Vorwiderstand angeschlossen werden
* An PD0/PD1 ist ein MAX232 angeschlosssen, um Daten vom PC zu empfangen/senden
*
*******************************************************************************
*/

// Systemtakt in Hz, das L am Ende ist wichtig, NICHT UL verwenden!
#define F_CPU 3686400L
// "Morsedauer" für ein Bit in Millisekunden
#define BITZEIT 100

#include <string.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Baudrate, das L am Ende ist wichtig, NICHT UL verwenden!
#define BAUD 9600L

// Berechnungen
// clever runden
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)
// Reale Baudrate
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))
// Fehler in Promille
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000)

#if ((BAUD_ERROR>10) || (BAUD_ERROR<-10))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif

// globale Variablen für den UART

// Puffergrösse in Bytes, RX und TX sind gleich gross
#define uart_buffer_size 32

volatile uint8_t uart_rx_flag=0; // Flag, String komplett empfangen
volatile uint8_t uart_tx_flag=1; // Flag, String komplett gesendet
char uart_rx_buffer[uart_buffer_size]; // Empfangspuffer
char uart_tx_buffer[uart_buffer_size]; // Sendepuffer

// lange, variable Wartezeit, Einheit in Millisekunden
void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

// einen String senden
// vor Aufruf der Funktion muss man prüfen, ob uart_t_flag==1 ist
// nur dann kann ein neuer String gesendet werden

void put_string(char *daten) {

if (uart_tx_flag==1) {
// String daten ind en Sendepuffer kopieren
strcpy(uart_tx_buffer, daten);
// Flag für 'Senden ist komplett' löschen,
uart_tx_flag = 0;
// UDRE Interrupt einschalten, los gehts
UCSRB |= (1<<UDRIE);
}
}

// einen empfangenen String kopieren
// vor Aufruf der Funktion muss man prüfen, ob uart_rx_flag==1 ist
// anderenfalls ist der RX Buffer noch ungültig

void get_string(char *daten) {

if (uart_rx_flag==1) {
// String kopieren
strcpy(daten, uart_rx_buffer);
// Flag löschen
uart_rx_flag = 0;
}
}

// Ein Byte im RS232 Format auf eine LED ausgeben

void morse(uint8_t data) {
uint8_t i;

// Startbit, immer 0
PORTD &= ~(1 << PD5); // LED aus
long_delay(BITZEIT);

for(i=0; i<8; i++) {
if (data & 0x01) // Prüfe Bit #0
PORTD |= (1 << PD5); // LED an
else
PORTD &= ~(1 << PD5); // LED aus
long_delay(BITZEIT);
data >>= 1; // nächstes Bit auf Bit #0 schieben
}
// Stopbit, immer 1
PORTD |= (1 << PD5); // LED an
long_delay(BITZEIT);
}

// Hauptprogramm

int main (void) {

char stringbuffer[64]; // Allgemeiner Puffer für Strings
uint8_t buffer_full=0; // noch ein Flag, aber nur in der Hauptschleife
char * charpointer; // Hilfszeiger

// IO konfigurieren

DDRA = 0xFF;
DDRB = 0xFF;
DDRC = 0xFF;
DDRD = 0xFF;

// UART konfigurieren

UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
UCSRB = (1<<RXCIE) | (1<<RXEN) | (1<<TXEN);

// Stringpuffer initialisieren

stringbuffer[0] = '\n';
stringbuffer[1] = '\r';

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {

// "Sinnvolle" CPU Tätigkeit
PORTD &= ~(1<<PD5);
long_delay(300);
PORTD |= (1<<PD5);
long_delay(300);

// Wurde ein kompletter String empfangen
// und der Buffer ist leer?
if (uart_rx_flag==1 && buffer_full==0) {
// ja, dann String lesen,
// die ersten zwei Zeichen
// aber nicht überschreiben
get_string(stringbuffer+2);
buffer_full=1;
}

// Ist letzte Stringsendung abgeschlossen
// und ein neuer String verfügbar?
if (uart_tx_flag==1 && buffer_full==1) {
// Newline + Carrige return anfügen
strcat(stringbuffer, "\n\r");
put_string(stringbuffer); // zurücksenden
buffer_full=0; // Buffer ist wieder verfügbar
// Alle Zeichen per LED morsen
charpointer = stringbuffer;
while(*charpointer) morse(*charpointer++);
}
}
}

// UART RX complete interrupt

// hier werden Daten vom PC empfangen und in einem String zwischengespeichert
// Wird ein Stringterminator empfangen, wird ein Flag gesetzt, welches dem
// Hauptprogramm den kompletten Empfang signalisiert

ISR(USART_RXC_vect) {

static uint8_t uart_rx_cnt; // Zähler für empfangene Zeichen
uint8_t data;

// Daten auslesen, dadurch wird das Interruptflag gelöscht
data = UDR;

// Ist Puffer frei für neue Daten?
if (!uart_rx_flag) {
// ja, ist Ende des Strings (RETURN) erreicht?
if (data=='\r') {
// ja, dann String terminieren
uart_rx_buffer[uart_rx_cnt]=0;
// Flag für 'Empfangspuffer voll' setzen
uart_rx_flag=1;
// Zähler zurücksetzen
uart_rx_cnt=0;
}
else if (uart_rx_cnt<(uart_buffer_size-1)) {
// Daten in Puffer speichern
// aber durch if() Pufferüberlauf vermeiden
uart_rx_buffer[uart_rx_cnt]=data;
uart_rx_cnt++; // Zähler erhöhen
}
}
}

// UART TX data register empty interrupt
// hier werden neue Daten in das UART Senderegister geladen

ISR(USART_UDRE_vect) {
// Zeiger auf Sendepuffer
static char* uart_tx_p = uart_tx_buffer;
uint8_t data;

// zu sendendes Zeichen lesen,
// Zeiger auf Sendepuffer erhöhen
data = *uart_tx_p++;

// Ende des nullterminierten Strings erreicht?
if (data==0 ) {
UCSRB &= ~(1<<UDRIE); // ja, dann UDRE Interrupt ausschalten
uart_tx_p = uart_tx_buffer; // Pointer zurücksetzen
uart_tx_flag = 1; // Flag setzen, Übertragung beeendet
}
else UDR = data; // nein, Daten senden
}
</c>

=== Wie lange dauert meine Interruptroutine ? ===

Diese Frage sollte man beantworten können, zumindest sollte eine Worst Case Abschätzung gemacht werden. Das geht auf zwei Wegen.

* Simulation, dabei muss in einer verzweigten ISR der längste Pfad simuliert werden. Dazu müssen alle beteiligten Variablen auf den ensprechenden Wert gesetzt werden.
* Messung mit dem [[Oszilloskop]], dabei wird zum Beginn der ISR ein Pin auf HIGH gesetzt und am Ende auf LOW. Damit kann man in Echtzeit die Dauer der ISR messen. Die zusätzlichen Taktzyklen zum Aufruf und verlassen der ISR sind konstant und im wesentlichen bekannt. Mit einem modernen Digitaloszilloskop und dem "Infinite Persistence Mode" kann man eine Worst Case Messung vornehmen

Als Hilfmittel zur Fehlersuche kann man auch am Ende der ISR prüfen, ob das jeweilige Interrupt-Request Bit schon wieder gesetzt ist. Wenn ja, dann ist die ISR in den meisten Fällen zu lang. Auch hier kann man einen Ausgang auf HIGH setzen und somit den Fehler anzeigen.

==Interruptfeste Programmierung==

=== Atomarer Datenzugriff ===

Von einem atomaren (engl. atomic) Datenzugriff spricht man, wenn der Zugriff innerhalb einer nicht unterbrechbaren Maschinenanweisung abgearbeitet wird.

Alle Variablen, Steuerregister und I/O-Ports, die sowohl im Hauptprogramm als auch in Interrupts verwendet werden, sind mit viel Sorgfalt zu behandeln.

Beispiel:
<c>
port |= 0x03;
</c>
übersetzt sich auf AVR Prozessoren in
<avrasm>
IN r16,port
ORI r16,0x03
OUT port,r16
</avrasm>
Wenn nun zwischen IN und OUT ein Interrupt auftritt, der beispielsweise Bit 7 verändert, dann geht mit dem OUT-Befehl diese Änderung verloren, da der OUT Befehl den alten Zustand vor dem Interrupt wiederherstellt.

'''Gefährlich ist das insbesondere deshalb, weil der Fall nur selten auftritt und dies Verhalten sehr schlecht reproduzierbar ist.'''

Bei verschiedenen Prozessor-Architekturen tritt das Problem verschieden häufig auf. So übersetzt sich obiger Code bei MSP430 Prozessoren in einen einzelnen Befehl
<pre>
OR #0x03,port
</pre>
und stellt somit kein Problem dar. Im Zweifel hilft nur ein Blick in den erzeugten Assembler-Code. Bei der Übernahme fremden Codes ist dies zu beachten. Was bei i51 kein Problem war, kann bei AVR zu einem Problem werden, unter Umständen sogar abhängig von verwendeten Port sein.

Ein ähnliches Problem entsteht bei Variablen, deren Grösse die Wortbreite der Maschine übersteigt. Bei 8-Bit-Prozessoren wie AVR oder i51 also bereits bei normalen "int" Variablen. Diese Variablen werden zwangsläufig byteweise verarbeitet. Wenn genau dazwischen ein Interrupt erfolgt, wird ein falscher Wert gelesen. Wenn beispielsweise eine Interrupt-Routine einen 16-Bit-Zähler verwendet und von 0x00FF auf 0x0100 hochzählt, dann kann das Hauptprogramm auch schon mal versehentlich die Werte 0x01FF oder 0x0000 lesen.

Dies ist auch ein Grund, weshalb für Programmierung auf derart "niedriger" Ebene Kenntnisse in Prozessorarchitektur und Assembler-Programmierung sehr hilfreich sind.

'''Abhilfe''': Wenn man sich nicht wirklich ganz sicher ist, sollten um kritische Aktivitäten herum jedesmal die Interrupts abgeschaltet werden.

Beispiel ([[AVR-GCC]]):
<c>
cli(); // Interrupts abschalten
port |= 0x03;
sei(); // Interrupts wieder einschalten
</c>

Wenn man ein globales Einschalten der Interrupts mit sei() vermeiden will, kann man die folgende Methode benutzen. Hierbei werden die Interrupts nur eingeschaltet, wenn sie vorher bereits eingeschaltet waren (Hinweis aus der FAQ von avr-libc):

<c>
{
// ...
{
uint8_t sreg; // Lokale Sicherungskopie von SREG
sreg = SREG;
cli();
// hierhin kommt der Code mit atomarem Zugriff
SREG = sreg;
}
// ...
}
</c>

Je nach Prozessor kann man das Problem manchmal auch ohne Abschalten von Interrupts durch geeignete Programmierung lösen. So führt
<c>
port = (port & ~0x0F) | lcd_data;
</c>
immer zum beschriebenen Problem,
<c>
port &= ~0x0F;
port |= lcd_data;
</c>
jedoch nicht, wenn die beiden Zeilen zu jeweils einem Assembler-Befehl übersetzt werden. Was dann aber abhängig von den Optimierungs-Einstellungen des Compilers werden kann. Eine Interrupt-feste Variante für AVR-Prozessoren der neuesten Generation, wie beispielsweise Tiny2313 und Mega88 (alle ab 2004):
<c>
PINx = (PORTx & 0x0F) ^ lcd_data;
</c>

=== Reentrante Funktionen ===

Eine Funktion ist reentrant (wiedereintrittsfest), wenn sie mehrmals gleichzeitig aktiv sein kann, ohne dass sich diese Aufrufe gegenseitig beeinflussen. Betrifft beispielsweise Funktionen, die sowohl im Hauptprogramm als auch in Interrupts aufgerufen werden. Manche C Compiler erfordern eine besondere Kennzeichnung solcher Funktionen. Wenn möglich sollte man es jedoch vermeiden, eine Funktion aus dem Hauptprogramm '''und''' aus einem Interrupt aus aufzurufen. Das ist meist problemlos machbar.

== Siehe auch ==
* [[Timer]]
* [[AVR-Tutorial: Interrupts | AVR-Tutorial - Interrupts in Assembler]]
* [[AVR-GCC-Tutorial#Programmieren_mit_Interrupts | AVR-GCC-Tutorial - Interrupts in C]]
* [[ADC]]

Bitmanipulation

2007-12-20T16:07:42Z

FalkB: /* Bit togglen */

== Bits setzen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Eins gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#ODER | ODER]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden auf '1' gesetzt. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<avrasm>
sbr r16, 0b11110000 ; setzt Bits 4-7 in r16
; funktioniert nur für die Arbeitsregister r16-r31

ori r16, 0b11110000 ; setzt Bits 4-7 in r16, ori ist identisch mit dem Pseudobefehl sbr
; funktioniert nur für die Arbeitsregister r16-r31

sbi PORTB, 5 ; setzt Bit 5 in PortB
; funktioniert nur für die IO-Register 0..31
</avrasm>

Man beachte den Unterschied! Eine "5" würde von sbr als "setze Bit 2 und 0" gedeutet, während sbi sie als "setzte Bit 5" versteht. Der Befehl '''sbr''' erwartet ein Bit'''muster''' für eine ODER-Verknüpfung, während der Befehlt '''sbi''' die Bit'''nummer''' benötigt.

=== Standard C ===

<c>
PORTB |= 0xF0; // Kurzschreibweise, entspricht PORTB = PORTB | 0xF0 also bitweises ODER.

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB |= ((1 << MEINBIT0) | (1 << MEINBIT2)); // setzt Bit 0 und 2 in PORTB auf "1"
</c>

Die letzte Zeile "entschlüsselt": 
Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2). Das Ergebnis wird bitweise ODER-verknüpft, also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101. Diese Maske wird mit dem aktuellen Inhalt von PORTB bitweise ODER-verknüpft und das Ergebnis PORTB mittels '|=' wieder zugewiesen. Ist PORTB vorher z.B. 0b01111010, dann ist der Inhalt nach der Operation 0b01111010 ''or'' 0b00000101 = 0b01111111, die gewünschten Bits sind somit gesetzt!

Anmerkung: Will man das gezeigte Beispiel der Bitmanipulation auf größere Datentypen anwenden, ist zu beachten, dass der Compiler in der Operation (1 << MEINBIT1) stillschweigend die 1 als Integer Type ansieht. Beim AVR-GCC bedeutet das 16-Bit und die folgende Operation bringt ggf. nicht das gewünschte Ergebnis. (Stichwort: "Integer Promotion").

Angenommen Bit 15 soll in einer 32-Bit weiten Variable gesetzt werden.

<c>
#define MEINBIT15 15
#define MEINBIT42 42

uint32_t reg_32;
uint64_t reg_64;

reg_32 |= (1 << MEINBIT15); /* FEHLER: Setzt die Bits 31 - 15, da ((int)1 << 15) == 0xFFFF8000 */

reg_32 |= ((uint32_t)1 << MEINBIT15); /* Hier wird nur Bit 15 gesetzt. */
reg_32 |= (1L << MEINBIT15); /* andere Schreibweise. */
reg_64 |= (1LL << MEINBIT42); /* Hier wird nur Bit 42 gesetzt,
andere Schreibweise für 64 Bit (long long). */
</c>

== Bit löschen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Null gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#UND | UND]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '0' sind, werden auf '0' gesetzt. Alle Bits, die in der Maske auf '1' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<avrasm>
cbr r16, 0b11110000 ; löscht Bits 0-3 in r16, setzt sie auf 0
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, 0b11110000 ; löscht Bits 0-3 in r16, andi ist identisch mit dem Pseudobefehl cbr
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, ~0b00001111 ; andere Schreibweise, hier wird die Bitmaske durch ~ invertiert
; dadurch kann man einfach alle zu löschenden Bit als '1' angeben
; so wie bei den Bitmasken für das setzen von Bits (positive Logik)

cbi PORTB, 5 ; löscht Bit 5 in PortB
; funktioniert nur für die IO-Register 0..31
</avrasm>

Auch hier gilt. Man beachte den Unterschied! Eine "5" würde von cbr als "lösche Bit 7,6,5,4,3 und 1" gedeutet, während cbi sie als "lösche Bit 5" versteht. Der Befehl '''cbr''' erwartet ein Bit'''muster''' für eine UND-Verknüpfung, während der Befehlt '''cbi''' die Bit'''nummer''' benötigt.

=== Standard C ===

<c>
PORTB &= 0xF0; // entspricht PORTB = PORTB & 0xF0 also bitweises UND;
// Bits 0-3 (das "niederwertige" Nibble) werden geloescht

/* uebersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB &= ~((1 << MEINBIT0) | (1 << MEINBIT2)); // löscht Bit 0 und 2 in PORTB
</c>

Die letzte Zeile "entschlüsselt": 
Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2). Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101. Durch '~' wird der Wert in der Klammer invertiert, aus 0b00000101 wird 0b11111010. Schließlich wird durch '&=' mit dem aktuellen Wert von PORTB UND-verknüpft und das Ergebnis wieder PORTB zugewiesen. Ist PORTB vorher z.B. 0b01111111, dann ist der Inhalt nach der Operation 0b011111111 ''and'' 0b11111010 = 0b01111010, die gewünschten Bits (0 und 2) sind somit gelöscht.

Die C-Ausdrücke sehen auf den ersten Blick etwas "erschreckend" aus und sind mehr "Tipparbeit", funktionieren aber universell und sind nach einiger Gewöhnung deutlicher und nachvollziehbarer als "handoptimierte" Konstanten.

=== Niederwertigstes gesetztes Bit löschen (Standard C) ===

Folgender Code löscht von allen 1-Bits in einer Integer-Variable das niederwertigste, unabhängig von der Position desselben.

Beispiel: 01101000 -> 01100000

<c>
uint8_t byte;

byte = irgendwas();

byte = byte & (byte - 1); /* Diese seltsame Operation löscht das
niederwertigste 1-Bit */
</c>

Dies kann bspw. zur schnellen Paritätsgenerierung eingesetzt werden:

<c>
uint8_t pareven(uint8_t byte) {
uint8_t par = 0;

while(byte) {
byte = byte & (byte - 1);
par = !par;
}
return par;
}
</c>

Das genannte gilt natürlich nicht nur für 8-Bit-Integers, sondern für beliebige, vom Compiler unterstützte Wortlängen.

== Bit togglen ==

Togglen bedeutet den Wert eines Bits invertiert. Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] invertiert (getoggelt) werden sollen, wird die durch eine [[AVR-Tutorial:_Logik#XOR_.28Exlusives_Oder.29 | XOR]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden invertiert. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR Assembler ===

Bei [[AVR]]s erlaubt dies z.B. folgender Assemblercode:

<avrasm>
sbic PortB, 0 ; skip if bit is cleared
rjmp ClrBitNow ; jump
sbi PortB, 0 ; set bit (if bit was cleared)
rjmp BitReady ; jump
ClrBitNow:
cbi PortB, 0 ; clear bit (if bit was set)
BitReady:
</avrasm>

Kürzer gehts mit folgender Variante. Zwischen der 2. und 3. Instruktion darf jedoch kein Interrupt erfolgen, sonst würde das SBIC schon den neuen Pegel des SBI auswerten (evtl. globale Interrupts ausschalten).

<avrasm>
cli ; disable global interrupts
sbis PinB, 0 ; skip if bit is set
sbi PortB, 0 ; otherwise set bit
sbic PinB, 0 ; skip if bit is cleared
cbi PortB, 0 ; otherwise clear bit
sei ; enable global interrupts
</avrasm>

Noch kürzer gehts so: 
Die zweite Zeile mit dem Befehl '''ldi''' lädt die Bitmaske, in welcher die zu den zu toggelnden Bits auf '1' gesetzt sind. In diesem Beispiel wird das dritte Bit invertiert. Der Vorteil dieser Methode ist neben der Kürze und Übersichtlichkeit auch die Möglichkeit, bis zu 8 Bit gleichzeitig zu toggeln.

<avrasm>
in R24, PORTE ; Daten lesen
ldi R25, 0x04 ; Bitmaske laden, hier Bit#2
eor R24, R25 ; Exklusiv ODER
out PORTE, R24 ; Daten zurückschreiben
</avrasm>

Eine andere Möglichkeit gibt es, wenn man nur das 8. Bit kippen will:

<avrasm>
in r16, PORTB
subi r16, 0x80
out PORTB, r16
</avrasm>

=== Standard C ===

<c>
PORTB ^= (1<<PB0); /* XOR, Kurzschreibweise, PORTB = PORTB ^ (1<<PB0) */
</c>

=== Neuere ATmegas ===

Bei den neueren ATmegas (z.B. ATmega48) kann man IO-Pins direkt ohne den Umweg über Register togglen, indem man das entsprechende Bit im PINx-Register '''setzt''':

<avrasm>
sbi PIND, 2 ; Bit 2 von Port D togglen
</avrasm>

=== 8051er ===

<avrasm>
cpl bitadresse
</avrasm>

[[Category:8051]][[Category:AVR]]

DDS

2007-12-20T15:16:55Z

FalkB: /* Lesestoff */

===Direkte Digitale Synthese===
Erzeugung einer Wechselspannung / eines Wechselstromes mittels Frequenzgenerator, FixedPoint-Addierer, LookUpTable und Digital-Analog-Wandler [[DAC]].

==Funktionsweise==
Erzeugung der Basisfrequenz durch Quarzoszillator (evtl. mit Phase-Locked-Loop PLL Synthesizer). Ausgangsfrequenz ist immer geringer als die Basisfrequenz.

Sehr gute Beschreibung der Theorie und der Nachteile (PhasenRauschen, Oberwellen): 
http://www.analog.com/UploadedFiles/Tutorials/450968421DDS_Tutorial_rev12-2-99.pdf

Die LookUpTable kann fest (meist Sinus) oder programmierbar (RAM, Arbitrary Waveform) oder ein Algorithmus sein.

Verwendung im NF / Audio- und HF / Funk-Bereich (bis 1 GHz).

Hersteller: Analog Devices http://www.analog.com

Bekannte ICs: Fairchild ML2037, AD9833 (25MHz), AD9835, AD9851, AD9854 (300MHz), AD9951 (400MHz)

Die modernener Chips beinhalten weitere Funktionen wie digitale Amplitudenmodulation (AM), Phasenmodulation (PM), Frequency Shift Keying (FSK).

==Projekte:==
[[Digitaler Funktionsgenerator]]

HF-Meßplatz 
http://www.mikrocontroller.net/forum/read-1-350237.html

Einfache Schaltung: 6 Drehschalter - PIC16F84 - AD9833 
http://www.mikrocontroller.net/forum/read-1-403708.html

Ganz ähnlich, mit ML2037: 
http://www.seattlerobotics.org/encoder/200205/ddsfgen.htm

DDS-Signalgenerator bis 500 MHz (1200MHz Takt) 
http://www.dg4rbf.de/ -> SYN500, SYN500/2

=Lesestoff=
* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=dds* Suche nach dds* in allen Foren]
* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=synthe* Suche nach synthe* in allen Foren]
* [http://www.mikrocontroller.net/topic/84498#new Lange, ausführliche Diskussion zur Berechung des Frequency Tuning Words]
* [http://www.mikrocontroller.net/topic/84498#710690 Praktische Umsetzung]

Implementierung im NF-Bereich auch durch µC möglich, z.B. für DialTone (DTFM): 
* http://www.myplace.nu/avr/minidds/index.htm 
* http://www.atmel.com/dyn/resources/prod_documents/doc1982.pdf 
* http://www.mikrocontroller.net/forum/list-1-1.html?filter=sinus* 
* http://www.mikrocontroller.net/forum/list-1-1.html?filter=tonerzeug*

DDS

2007-12-20T15:15:06Z

FalkB: /* Lesestoff */ Links auf Threads gesetzt

===Direkte Digitale Synthese===
Erzeugung einer Wechselspannung / eines Wechselstromes mittels Frequenzgenerator, FixedPoint-Addierer, LookUpTable und Digital-Analog-Wandler [[DAC]].

==Funktionsweise==
Erzeugung der Basisfrequenz durch Quarzoszillator (evtl. mit Phase-Locked-Loop PLL Synthesizer). Ausgangsfrequenz ist immer geringer als die Basisfrequenz.

Sehr gute Beschreibung der Theorie und der Nachteile (PhasenRauschen, Oberwellen): 
http://www.analog.com/UploadedFiles/Tutorials/450968421DDS_Tutorial_rev12-2-99.pdf

Die LookUpTable kann fest (meist Sinus) oder programmierbar (RAM, Arbitrary Waveform) oder ein Algorithmus sein.

Verwendung im NF / Audio- und HF / Funk-Bereich (bis 1 GHz).

Hersteller: Analog Devices http://www.analog.com

Bekannte ICs: Fairchild ML2037, AD9833 (25MHz), AD9835, AD9851, AD9854 (300MHz), AD9951 (400MHz)

Die modernener Chips beinhalten weitere Funktionen wie digitale Amplitudenmodulation (AM), Phasenmodulation (PM), Frequency Shift Keying (FSK).

==Projekte:==
[[Digitaler Funktionsgenerator]]

HF-Meßplatz 
http://www.mikrocontroller.net/forum/read-1-350237.html

Einfache Schaltung: 6 Drehschalter - PIC16F84 - AD9833 
http://www.mikrocontroller.net/forum/read-1-403708.html

Ganz ähnlich, mit ML2037: 
http://www.seattlerobotics.org/encoder/200205/ddsfgen.htm

DDS-Signalgenerator bis 500 MHz (1200MHz Takt) 
http://www.dg4rbf.de/ -> SYN500, SYN500/2

=Lesestoff=
* http://www.mikrocontroller.net/forum/list-1-1.html?filter=dds* 
* http://www.mikrocontroller.net/forum/list-1-1.html?filter=synthe* 
* [http://www.mikrocontroller.net/topic/84498#new Lange, ausführliche Diskussion]
* [http://www.mikrocontroller.net/topic/84498#710690 Praktische Umsetzung]

Implementierung im NF-Bereich auch durch µC möglich, z.B. für DialTone (DTFM): 
* http://www.myplace.nu/avr/minidds/index.htm 
* http://www.atmel.com/dyn/resources/prod_documents/doc1982.pdf 
* http://www.mikrocontroller.net/forum/list-1-1.html?filter=sinus* 
* http://www.mikrocontroller.net/forum/list-1-1.html?filter=tonerzeug*

Bitmanipulation

2007-12-20T15:03:18Z

FalkB: Fehler beim Bitsetzen korrigiert, kleine Änderungen

== Bits setzen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Eins gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#ODER | ODER]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden auf '1' gesetzt. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<avrasm>
sbr r16, 0b11110000 ; setzt Bits 4-7 in r16
; funktioniert nur für die Arbeitsregister r16-r31

ori r16, 0b11110000 ; setzt Bits 4-7 in r16, ori ist identisch mit dem Pseudobefehl sbr
; funktioniert nur für die Arbeitsregister r16-r31

sbi PORTB, 5 ; setzt Bit 5 in PortB
; funktioniert nur für die IO-Register 0..31
</avrasm>

Man beachte den Unterschied! Eine "5" würde von sbr als "setze Bit 2 und 0" gedeutet, während sbi sie als "setzte Bit 5" versteht. Der Befehl '''sbr''' erwartet ein Bit'''muster''' für eine ODER-Verknüpfung, während der Befehlt '''sbi''' die Bit'''nummer''' benötigt.

=== Standard C ===

<c>
PORTB |= 0xF0; // Kurzschreibweise, entspricht PORTB = PORTB | 0xF0 also bitweises ODER.

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB |= ((1 << MEINBIT0) | (1 << MEINBIT2)); // setzt Bit 0 und 2 in PORTB auf "1"
</c>

Die letzte Zeile "entschlüsselt": 
Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2). Das Ergebnis wird bitweise ODER-verknüpft, also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101. Diese Maske wird mit dem aktuellen Inhalt von PORTB bitweise ODER-verknüpft und das Ergebnis PORTB mittels '|=' wieder zugewiesen. Ist PORTB vorher z.B. 0b01111010, dann ist der Inhalt nach der Operation 0b01111010 ''or'' 0b00000101 = 0b01111111, die gewünschten Bits sind somit gesetzt!

Anmerkung: Will man das gezeigte Beispiel der Bitmanipulation auf größere Datentypen anwenden, ist zu beachten, dass der Compiler in der Operation (1 << MEINBIT1) stillschweigend die 1 als Integer Type ansieht. Beim AVR-GCC bedeutet das 16-Bit und die folgende Operation bringt ggf. nicht das gewünschte Ergebnis. (Stichwort: "Integer Promotion").

Angenommen Bit 15 soll in einer 32-Bit weiten Variable gesetzt werden.

<c>
#define MEINBIT15 15
#define MEINBIT42 42

uint32_t reg_32;
uint64_t reg_64;

reg_32 |= (1 << MEINBIT15); /* FEHLER: Setzt die Bits 31 - 15, da ((int)1 << 15) == 0xFFFF8000 */

reg_32 |= ((uint32_t)1 << MEINBIT15); /* Hier wird nur Bit 15 gesetzt. */
reg_32 |= (1L << MEINBIT15); /* andere Schreibweise. */
reg_64 |= (1LL << MEINBIT42); /* Hier wird nur Bit 42 gesetzt,
andere Schreibweise für 64 Bit (long long). */
</c>

== Bit löschen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Null gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#UND | UND]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '0' sind, werden auf '0' gesetzt. Alle Bits, die in der Maske auf '1' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<avrasm>
cbr r16, 0b11110000 ; löscht Bits 0-3 in r16, setzt sie auf 0
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, 0b11110000 ; löscht Bits 0-3 in r16, andi ist identisch mit dem Pseudobefehl cbr
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, ~0b00001111 ; andere Schreibweise, hier wird die Bitmaske durch ~ invertiert
; dadurch kann man einfach alle zu löschenden Bit als '1' angeben
; so wie bei den Bitmasken für das setzen von Bits (positive Logik)

cbi PORTB, 5 ; löscht Bit 5 in PortB
; funktioniert nur für die IO-Register 0..31
</avrasm>

Auch hier gilt. Man beachte den Unterschied! Eine "5" würde von cbr als "lösche Bit 7,6,5,4,3 und 1" gedeutet, während cbi sie als "lösche Bit 5" versteht. Der Befehl '''cbr''' erwartet ein Bit'''muster''' für eine UND-Verknüpfung, während der Befehlt '''cbi''' die Bit'''nummer''' benötigt.

=== Standard C ===

<c>
PORTB &= 0xF0; // entspricht PORTB = PORTB & 0xF0 also bitweises UND;
// Bits 0-3 (das "niederwertige" Nibble) werden geloescht

/* uebersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB &= ~((1 << MEINBIT0) | (1 << MEINBIT2)); // löscht Bit 0 und 2 in PORTB
</c>

Die letzte Zeile "entschlüsselt": 
Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2). Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101. Durch '~' wird der Wert in der Klammer invertiert, aus 0b00000101 wird 0b11111010. Schließlich wird durch '&=' mit dem aktuellen Wert von PORTB UND-verknüpft und das Ergebnis wieder PORTB zugewiesen. Ist PORTB vorher z.B. 0b01111111, dann ist der Inhalt nach der Operation 0b011111111 ''and'' 0b11111010 = 0b01111010, die gewünschten Bits (0 und 2) sind somit gelöscht.

Die C-Ausdrücke sehen auf den ersten Blick etwas "erschreckend" aus und sind mehr "Tipparbeit", funktionieren aber universell und sind nach einiger Gewöhnung deutlicher und nachvollziehbarer als "handoptimierte" Konstanten.

=== Niederwertigstes gesetztes Bit löschen (Standard C) ===

Folgender Code löscht von allen 1-Bits in einer Integer-Variable das niederwertigste, unabhängig von der Position desselben.

Beispiel: 01101000 -> 01100000

<c>
uint8_t byte;

byte = irgendwas();

byte = byte & (byte - 1); /* Diese seltsame Operation löscht das
niederwertigste 1-Bit */
</c>

Dies kann bspw. zur schnellen Paritätsgenerierung eingesetzt werden:

<c>
uint8_t pareven(uint8_t byte) {
uint8_t par = 0;

while(byte) {
byte = byte & (byte - 1);
par = !par;
}
return par;
}
</c>

Das genannte gilt natürlich nicht nur für 8-Bit-Integers, sondern für beliebige, vom Compiler unterstützte Wortlängen.

== Bit togglen ==

Togglen bedeutet den Wert eines Bits invertiert. Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] invertiert (getogglet) werden sollen, wird die durch eine [[AVR-Tutorial:_Logik#XOR_.28Exlusives_Oder.29 | XOR]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden invertiert. Alle Bit, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR Assembler ===

Bei [[AVR]]s erlaubt dies z.B. folgender Assemblercode:

<avrasm>
sbic PortB, 0 ; skip if bit is cleared
rjmp ClrBitNow ; jump
sbi PortB, 0 ; set bit (if bit was cleared)
rjmp BitReady ; jump
ClrBitNow:
cbi PortB, 0 ; clear bit (if bit was set)
BitReady:
</avrasm>

Kürzer gehts mit folgender Variante. Zwischen der 2. und 3. Instruktion darf jedoch kein Interrupt erfolgen, sonst würde das SBIC schon den neuen Pegel des SBI auswerten (evtl. globale Interrupts ausschalten).

<avrasm>
cli ; disable global interrupts
sbis PinB, 0 ; skip if bit is set
sbi PortB, 0 ; otherwise set bit
sbic PinB, 0 ; skip if bit is cleared
cbi PortB, 0 ; otherwise clear bit
sei ; enable global interrupts
</avrasm>

Noch kürzer gehts so: 
Die zweite Zeile mit dem Befehl '''ldi''' lädt die Bitmaske, in welcher die zu den zu toggelnden Bits auf '1' gesetzt sind. In diesem Beispiel wird das dritte Bit invertiert. Der Vorteil dieser Methode ist neben der Kürze und Übersichtlichkeit auch die Möglichkeit, bis zu 8 Bit gleichzeitig zu toggeln.

<avrasm>
in R24, PORTE ; Daten lesen
ldi R25, 0x04 ; Bitmaske laden, hier Bit#2
eor R24, R25 ; Exklusiv ODER
out PORTE, R24 ; Daten zurückschreiben
</avrasm>

Eine andere Möglichkeit gibt es, wenn man nur das 8. Bit kippen will:

<avrasm>
in r16, PORTB
subi r16, 0x80
out PORTB, r16
</avrasm>

=== Standard C ===

<c>
PORTB ^= (1<<PB0); /* XOR, Kurzschreibweise, PORTB = PORTB ^ (1<<PB0) */
</c>

=== Neuere ATmegas ===

Bei den neueren ATmegas (z.B. ATmega48) kann man IO-Pins direkt ohne den Umweg über Register togglen, indem man das entsprechende Bit im PINx-Register '''setzt''':

<avrasm>
sbi PIND, 2 ; Bit 2 von Port D togglen
</avrasm>

=== 8051er ===

<avrasm>
cpl bitadresse
</avrasm>

[[Category:8051]][[Category:AVR]]

Pegelwandler

2007-12-19T19:32:56Z

FalkB: /* STEP-DOWN: 5V -> 3.3V */

== Vorwort ==

Dies ist die erste aufgeräumte Version. Sicher nicht die letzte.

* [http://www.mikrocontroller.net/forum/read-1-375051.html "Stein des Anstosses"]
* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=pegelwand*+levelsh*&x=0&y=0 Suche in den Forenartikel]

== Einleitung ==

Pegelwandeln (engl. level shifting) wird oft notwendig, wenn Systeme mit unterschiedlicher Ausgangs- und Eingangsspannungen (z.B. Versorgungs- oder Logikspannungen) miteinander verbunden werden sollen.

Das vielleicht bekannteste Beispiel ist die Umsetzung von 0V/5V [[TTL]] Logikpegeln auf die -12V/12V Pegel einer seriellen [[RS232]] Schnittstelle.

Die Probleme beim Pegelwandeln können sein:

# Überlastung einer oder beider Seiten
# Inkompatible Logikpegel und daraus resultierendes Nichtfunktionieren der Schaltung, oder noch schlimmer sporadische Fehlfunktionen
# Verzögerungen der Signale durch die Pegelwandlung und daraus resultierende maximale Signalfrequenzen

=== Überlastung ===

Das Erzeugen von verschiedenen Versorgungsspannungen ist ziemlich einfach, aber man muss sicher gehen, daß man die Signalleitungen zwischen den Bauteilen überprüft. Wenn ein 5V Bauteil ein Signal an ein 3V Bauteil schickt können beide Bauteile beschädigt werden. Vor allem für neue ICs ist es ein Problem mit "hohen" Spannungen wie 5V zu arbeiten. Auf grund der immer kleineren Schaltkreistrukturen (der aktuelle Pentium wird mit 45nm Technologie hergestellt!) werden auch die Abstände und Schichtdicken immer geringer. Das reduziert natürlich auch die Spannungsfestigkeit der Transistoren auf dem IC. Neue ICs vertragen deshalb meist nur noch 3.3V, teilweise sogar weniger! Die Überlastung erfolgt durch zu hohe Spannung und dadurch mehr oder weniger langsame Zerstörung des ICs.

=== Schutzdioden ===

Hauptursache Nummer zwei für Überlastung von ICs mit verschiedenen Betriebsspannungen sind die in nahezu allen ICs integrierten Schutzdioden. Deren Aufgabe ist es in Normalfall, elektrostatische Entladungen auf eine sichere, niedrige Spannung zu begrenzen. Die Entladungen geschehen durch unsachgemässe Handhabung und Transport von ICs, z.B. wenn jemand über einen Kunstfaserteppich läuft, sich dabei elektrostatisch auflädt und einen IC anfasst. Oder wenn Bauteile in einem Gerät eingebaut sind und der Anwender berührt offen liegende Kontakte (RS232 Eingang, USB-Stick, PCI-Steckkarten beim Einbau etc.). Die Schutzdioden beginnen Strom zu leiten, wenn die Eingangsspannung ca. 500mV über VCC ansteigt oder mehr als 500mV unter GND absinkt. Im Normalbetrieb sollten die Schutzdioden keinen Strom leiten. Manchmal kann man sie aber zur Spannungsbegrenzung missbrauchen, siehe [[#STEP-DOWN:_5V_-.3E_3.3V | Step Down mit Vorwiderstand]].

[[bild:pw_schutzdioden.png]]

=== 5V tolerante Eingänge ===

5 Volt tolerant bedeutet, daß 3 Volt Bausteine ohne Probleme von einem 5 Volt Baustein angesteuert werden können.

Viele Bauteile die auf 3V arbeiten verfügen über 5V tolerante Eingänge. Man sollte aber grundsätzlich im Datenblatt darüber nachlesen, bevor die Schaltung aufgebaut wird. Sind sie es nicht, so ist ein Pegelwandler auf den Verbindungsleitungen zwischen den Bauteilen notwendig. Ein Pegelwandler kann eine einfache Zener-Diode mit einem Widerstand sein, es kann aber auch ein eigens dafür vorgesehener IC sein. Sind die Signalwege bidirektional, so wird man meist die Lösung mit einem eigenen IC bevorzugen.

[[AVR]]s sind generell nicht 5V tolerant, wenn sie mit 3.3V betrieben werden. Die absolute obere Grenze für Eingangsspannungen liegt bei Vcc + 0.5V. Zu finden in den elektrischen Spezifikationen im Datenblatt.

Ob ein Bauteil 5V-tolerant ist und unter welchen Betriebsbedingungen das gilt steht im Datenblatt des betreffenden Bauteils vom betreffenden Hersteller. Wenn es auf diese Eigenschaft ankommt, lieber genau bei Lieferanten nachsehen, von welchem Hersteller die Bauteile kommen.

Vorsicht bei:

* 74'''LVX'''xxxx und 74'''LCX'''xxxx (245, 244, 240 ...) an Vcc=3,3V. Achtung: Nicht alle 74LVX sind für 5V -> 3,3V geeignet, da jeder Hersteller die ICs anders baut!

=== Kompatibilität von Logikpegeln ===

Siehe auch http://www.interfacebus.com/Design_Translation.html

Verschiedene Mikroprozessoren haben eigene elektrische Kenndaten für HIGH und LOW Pegel, die abhängig von der Versorgungsspannung sind z.B. der [[R8C]]:

* HIGH grösser 0.8 * Vcc
* LOW kleiner 0.2 * Vcc

Man muss die Spannungen der Aus-und Eingänge vergleichen. Wenn es um ein Hobbyprojekt geht kann man einfach messen. Wenn es um eine kommerzielle Anwendung geht die man verkaufen will, sollte man besser die Spezifikationen der ICs studieren.

== UNIDIREKTIONAL ==

=== STEP-UP: 3.3V -> 5V ===

* 3.3V Pegel werden bei TTL kompatiblen Eingängen richtig erkannt (Schaltschwelle 1,4V). Es ist kein Pegelwandler erforderlich. Direkte Verbindung.

* 5V CMOS Eingänge haben typisch eine minimale Eingangsspannug für HIGH (<math>V_{IH}</math>) von 0.6 * VCC = 0.6 * 5V = 3V. Das kann ein 3.3V CMOS Ausgang direkt treiben, allerdings kann sich das Zeitverhalten dadurch etwas ändern weil der HIGH Pegel später erkannt wird. Vorsicht! Viele 5V CMOS ICs wollen für HIGH offiziell mindestens 0.7V * VCC = 3.5V oder manche auch 0.8 * VCC = 4.0V! Das geht dann offiziell nicht mehr mit einem 3.3V Ausgang! Für Hobbyzwecke kann man das aber ggf. probieren.

* 3.3V [[Ausgangsstufen_Logik-ICs | Open Collector]] nach 5V (TTL oder CMOS): Einfach einen Pull-Up Widerstand hinzufügen und gut. Allerdings verbraucht der Pull-Up Widerstand bei LOW relativ viel Strom und kann bei HIGH nicht allzuviel Strom liefern. Die Schaltgeschwindigkeit von LOW nach HIGH wird durch die Grösse des Pull-Ups bestimmt.

[[bild:pw_oc_3-5.png]]

* 3,3V auf echte 5V (CMOS) geht am einfachsten mit einem Baustein der HCT Familie (NICHT HC !). Diese haben TTL-compatible Eingänge und echte CMOS Ausgänge

* Man kann einen Komparator in nichtinvertierender Schaltung benutzen (LM339/393). Allerdings ist diese Lösung meist relativ langsam, abhängig vom verwendeten Komparator.

[[bild:pw_comp_3-5.png]]

'''Bauteile'''

* 74HCTxxx (245, 244, 240 ...)
* 74HCT125
* SN74LVC07AD

=== STEP-UP: 5V -> 9..15V ===

* Am einfachsten geht das mit einem Open Collector Ausgang, einfach einen Pull-Up hinzufügen (an die hohe Spannung) und fertig.

[[bild:pw_oc_5-12.png]]

* Man kann einen Komparator benutzen. Allerdings ist diese Lösung meist relativ langsam, abhängig vom verwendeten Komparator. Wenn nur zwei Signale pegelgewandlet werden müssen bietet sich der LM393 an, ein Doppelkomparator mit Open Collector Ausgang, mit dem man auf einen beliebigen Pegel ausgeben kann. Der LM339 ist ein Vierfachkomparator mit den gleichen Eigenschaften. Wenn wenig Platz vorhanden ist, dann ist der TL311 im winzigen SOT-23 Gehäuse sehr empfehlenswert. Bei jedem Komparator kann auch einfach eine Invertierung gemacht werden, einfach die Eingänge + und - vertauschen. Diese Komparatoren eignen sich bis ca. 1 MHz.

* [http://www.elektronik-kompendium.de/sites/praxis/bausatz_pegelwandler-mit-transistoren.htm Pegelwandler mit Transistor, invertierend]

[[bild:pw_trans_inv.png]]

* Pegelwandler mit Transistor, nicht invertierend

[[bild:pw_trans_ni.png]]

Die Idee ist einfach. Wenn der Ausgang des 5V Gatters auf HIGH ist dann ist der Transistor ausgeschaltet, der Pull-Up Widerstand R7 zeiht den Ausgang auf +12V. Ist der Ausgang des 5V Gatters auf LOW ist, dann ist er vollkommen durchgesteuert und der Ausgang nahe 0V (je nach Typ ca. 300mV). Der Vorteil ist hier erhöhte Störsicherheit im Gegensatz zur einfachen Ansteurung der Basis über einen Vorwiderstand. Ausserdem wird dadurch nicht die Logik invertiert. Nachteilig ist der geringe Strom, der bei HIGH zur Verfügung steht (typisch 100μA).

* Wenn mehr Geschwindigkeit, Ausgangsstrom und weniger Stromverbrauch nötig ist, dann muss ein spezieller Baustein her, wie z.B. 
** MOSFET-Treiber (z.B. L293, L298, UCC27325 und deren Verwandte), wenns nicht zu schnell ist (einige Dutzend kHz)
** CD40109, bei Reichelt verfügbar
** HEF4104, 4fach LOW-HIGH Pegelwandler mit normalen und invertierten Augängen sowie Tristate. Um GGf sicherzustellen, dass wie im Datenblatt beschrieben immer VDDI <= VDDO ist, kann man einfach eine Diode von VDDO nach VDDI schalten (z.B. Schottky SB120, aber auch 4148 & Co sollte problemlos funktionieren)
** CMOS 4504, 6fach LOW-HIGH/HIGH-LOW 3-20V Pegelwandler, TTL/CMOS (umschaltbar) => CMOS, kein Reihenfolge von Vcc/Vee erforderlich (Bezugsquelle: CSD)
** MAX232, der braucht nur 5V Versorgungsspannung. Allerdings ist der Ausgangswiderstand relativ hoch (ca. 300Ohm) und man kann nur ca. 5mA Ausgangstrom liefern. Die Ausgangsspannung beträgt maximal 10V.

=== STEP-DOWN: 5V -> 3.3V ===

* Zuerst sollte man prüfen, ob die Eingänge 5V tolerant sind, Dann kann man die ICs direkt verbinden. Sehr schnell und billig!

* Wenn die Eingänge nicht 5V tolerant sind und es trotzdem schnell sein soll, muss ein Gatter aus der LVC oder AHC Familie dazwischen geschaltet werden. Bei 3V Betriebsspannung kann man problemlos 5V an den Eingang anlegen. Der Baustein 74HC4050 erlaubt per Definition eine Step-Down Pegelwandlung bis etwa 15V (siehe Datenblatt). Beide Anordungen verbrauchen auch sehr wenig Ruhestrom.

: '''Bauteile'''

:* 74LVC245A ('A' ist wichtig, I/Os 5V-tolerant)
:* 74LVC245DW
:* 74LVT245
:* 74LVXxxx (245, 244, 240 ...) an Vcc=3,3V. Achtung: Nicht alle 74LVX sind für 5V -> 3,3V geeignet, da jeder Hersteller die ICs anders baut!
:** 74LVX04
:** 74LVX244 (Fairchild)
:** 74LVX245 (nicht von Reichelt, nicht 5V tolerant)

:* 74HC4050 (bis 15V Step Down Pegelwandlung laut Datenblatt, bei Reichelt in DIP und SO erhältlich)
:* MAX3373/MAX3375
:* NC7SZ08 oder andere aus derselben Serie. CMOS-Logik mit 5V-toleranten Eingängen, recht flott und braucht dank SOT-23 auch wenig Platz auf dem Print

* 5V Open Collector auf 3.3V Eingang. Einfach einen Pull-Up hinzufügen (Pull-Up liegt auf 3.3V). Nachteilig ist der relativ hohe Stromverbrauch bei LOW, die begrenzte Geschwindigkeit bei hochohmigen Pull-Ups und der relativ geringe Ausgangsstrom bei HIGH (abhängig vom Pull-Up).

[[bild:pw_oc_5-3.png]]

* Spannungsteiler mit 680 Ohm und 1kOhm. Der Nachteil dieser Lösung ist der relativ hohe Stromverbrauch (~3mA), der relativ geringe Ausgangsstrom (mehr als 200..300uA sollte man da nicht rausziehen) un die relativ geringe Geschwindigkeit (ca. 10 MHz).

[[bild:pw_st_5-3.png]]

* 1 kOhm Vorwiderstand. Dadurch wird der Strom vom 5V Ausgang in die 3.3V Versorgung durch die internenen Schutzdioden auf ca. 1mA begrenzt. Diese Lösung ist auch relativ langsam (ca. 5MHz). Ggf. kann man den Vorwiderstand auf 100 Ohm reduzieren, das erhöht dann wieder die Geschwindigkeit. Aufpassen, einige ICs vertragen nur 1mA oder weniger durch die Schutzdioden! Ausserdem muss man aufpassen, das jetzt von der 5V Seite Strom in die 3.3V Verorgung eingespeist wird. Besonders in Schaltungen mit sehr niedrigem Stromverbrauch kann das zum Problem werden, wenn weniger Strom verbraucht wird als über die Vorwiderstände eingespeist wird. Dann nimmt es meist der Spannungsregler für 3.3V übel wenn jemand "schiebt", sprich, Strom einspeist. Denn die allermeisten Spannungsregler können nur Strom liefern (source), aber keinen Strom aufnehmen (sink). Es gibt 4-fach-Diodennetzwerke, die die internen Schutzdioden entlasten können, außerdem ist teilweise noch eine Zenerdiode enthalten, die diesen sink-Strom aufnehmen.

[[bild:pw_vw_5-3.png]]

Achtung: Mindestens für 74HC(T) Gatter ist dokumentiert (Philips 74HC/T High-Speed CMOS User Guide), dass auch schon geringer Strom durch die internen Schutzdioden zu einer unerwünschten Kopplung von Eingängen führen kann, d.h. der Strom fliesst zu einem anderen Eingang wieder hinaus. Sind also andere Eingänge ebenso hochohmig angeschlossen, kann dieser Querstrom zu Fehlfunktion führen.

== BIDIREKTIONAL ==

=== 5V <-> 3.3V ===

* Wenn die 5V Seite TTL-kompatible Eingänge hat kann wieder der Spannungsteiler oder Vorwiderstand wie bei der unidirektionalen Anpassung verwendet werden (mit all seinen Vor- und Nachteilen).

* Für bidirektionale Busse gibt es spezielle Pegelwandler mit 2 Versorgungsspannungen. Allerdings brauchen die meist ein Signal zur Richtungsumschaltung. Auch muss man die Reihenfolge der Versorgungsspannungen beim Einschalten beachten. Aktive bidirektionale Pegelwandler OHNE Steuereingang zur Richtungsumschaltung sind mit Vorsicht zu geniessen, denn die brauchen teilweise kurzzeitig einen relativ hohen Strom, um die Eingänge zu treiben.

'''Bauteile'''

* SN74CB3T3306
* MAX1741
* MAX3378E
* 74AHC126 s.u.
* ST2378 (bei CSD erhältlich, 3.5 eur, leider TSSOP)

== Mit galvanischer Trennung ==

* [[Optokoppler]]

[[bild:pw_opto.png]]

* GMR-Koppler von der Firma NVE
* iCoupler Technologie von der Firma Analog Devices

Lit.: ''Galvanische Trennung: Optokoppler, GMR-Koppler oder iCoupler?'', Siegfried W. Best, Redaktion elektronik industrie, [http://www.elektronik-industrie.de/ei/11,2003/article/2f0082f824c.html elektronik industrie 11-2003, S. 22ff.]

== Praktische Beispiele ==

=== Einfaches RS232-Interface ===

[http://web.archive.org/web/20050122013618/http://www.henrik-reimers.de/control/rs232interface.gif Erfolgreicher Einsatz bis 19200 Baud und bis zu 10 m Leitungslänge]

Beschränkungen:

* ggf. Platzbedarf
* Geschwindigkeit s.o.

Beispiel: http://www.hagtech.com/pdf/translator.pdf

=== [[I2C]]-Bus: gemeinsam 3.3V und 5V ===

* [[MSP430]] an 3,3V/5V: http://www-s.ti.com/sc/psheets/slaa148/slaa148.pdf

* Philips PCA9515: I2C Puffer mit Pegelwandlung. Der PCA9515 ist ein I2C-Bus Repeater, welcher I2C Busse mit verschiedenen Spannungen isoliert. Verfügbar bei DigiKey.

* [http://www.standardics.philips.com/support/documents/i2c/pdf/an97055.pdf Philips AN97055 Bi-directional level shifter for I²C-bus and other systems]

* Bevor man ein Philips I2C Chip auswählt sollte man prüfen ob er verfügbar ist und auch das verfügbare Gehäuse wählen. Man sollte auch überlegen ob ein Puffer wirklich gebraucht wird. Wenn man echte I2C ICs mit 5V betreibt, dann sind die Eingänge vom Typ Schmitt Trigger CMOS (z.B. PCF8574). Dann müssen 3.3V Pegel auf 5V umgesetzt werden. Wenn man jedoch SMBUS Ics verwendet (z.B. ADT7461, Silabs 8051) dann sind die Schwellspannungen TTL kompatibel und es ist keine Anpassung notwendig. Für neue Pegelwandler sollte man hier nachschauen. http://www.bus-buffer.com

* [http://www.edn.com/article/CA193193.html "Two-transistor circuit replaces IC"]. Für diese Anwendung kann ENABLE direkt mit 3.3V verbunden werden. Es ist eigentlich nur dazu da, den ICs "hot-swappable" zu machen (kann unter Spannung gesteckt und getrennt werden). Man sollte beachten, daß die Schaltung sowohl für SCL als auch SDA benötigt wird.

* Noch einfachere Lösungen mit nur einem MOSFET und zwei Pull-Up Widerständen pro Leitung sind in den folgenden Links zu finden. Vielleicht ist es sogar noch billiger Bipolartransistoren zu verwenden.
* http://www.semiconductors.philips.com/markets/mms/protocols/i2c/facts/#levelshifting
* http://www.semiconductors.philips.com/acrobat_download/literature/9398/39340011.pdf

=== Auswählbare Pegel ===

'''Frage:'''
Ein CMOS Logikpegel zwischen 1,8V, 2,5V und 3,3V (abhängig von der Anwendung) muss auf 5V CMOS Logikpegel gewandelt werden. Es geht nur um diese Richtung mit maximal 8MHz. Es gibt die Stromversorgung für alle Pegel. Ein normaler Komparator wie LM311 ist nicht möglich, da er beim Betrieb mit 5V Versorgunsspannung erst ab 1V zu schalten anfängt. Meine Idee ist die Verwendung eines High Speed OPVs mit R2R Eingang, z.B. LMH6645.

'''Antworten:'''
* Man könnte einen ultra-low threshold N-Kanal MOSFET nehmen und als Open Drain mit einem Pull-Up nach 5V betreiben, BSH103 könnte passen (Schwellspannung ~0,4V).
* High-Speed Single Supply Komparator wie z.B. [http://www-s.ti.com/sc/ds/tl712.pdf TL712] .

'''Frage:'''
Ich suchen einen IC, welcher eine Pegelwandlung von 3,3V nach 1,8V, 2,0V oder 5V ermöglicht und während des Betriebs umgeschaltet werden kann.

'''Antworten:'''
* So ein IC ist der Linear [http://www.linear.com/pc/productDetail.jsp?navId=H0,C1,C1007,C1071,P1601 LTC1555L-1.8] .

=== AVR <-> [[MMC]] ===

5V AVR an eine MMC.
* [http://www.microsyl.com/ledsign/ledsign.html Projektseite]
* [http://www.microsyl.com/ledsign/ledsign1.pdf Schaltplan]

Der MAX3378E ist günstig zur Anbindung von 5V Mikrocontrollern an 3.3V SD/MMC Karten. Verfügbar in kleinem Gehäuse, bidirektional ohne Richtungsumschaltung und wenig Pins, ideal für SPI.
* [http://www.maxim-ic.com/appnotes.cfm/appnote_number/1159 MAX3378E]
* '''74LVC245''' mit 3.3V Betriebsspannung geht auch gut

=== µC <-> Parallelport ([[ISP]]-Dongle, [[JTAG]] Wiggler, ...) ===

Dieser Schaltplan funktioniert auch bei 3.3V wenn man einen 74HC244 anstatt eines 74LS244 verwendet: [http://www.epanorama.net/circuits/parallel_output.html Parallel port interfacing made easy: Simple circuits and programs to show how to use PC parallel port output capabilities].

= Bauteile =

* '''74ALVC16245''' - ''16bit dual supply translating transceiver''. Eine Seite von 1.5V bis 3.6V, die andere von 1.5 bis 5.5V.
* '''74LVX573''' (unidirektional, Latch, nicht alle Hersteller bauen diesen 5V tolerant!)
* '''74LVX245''' (bidirektional, nicht alle Hersteller bauen diesen 5V tolerant!)
* '''74LVX125''' - ''Low Voltage Quad Buffer with 3-STATE Outputs''. http://www.fairchildsemi.com/pf/74/74LVX125.html
* '''SN74LVC2T45'''
* '''SN74LVC8T245''' - ''8-Bit Dual-Supply Bus Transceiver with Configurable Voltage Translation and Three-State Outputs''. http://focus.ti.com/docs/prod/folders/print/sn74lvc8t245.html
* '''74LCX244MSA''' von Fairchild.
* '''MAX3377'''
* '''MAX3000''' 8-Kanal bidirektioneler Pegelwandler ohne Richtungsumschaltung

Vierfachdioden im kleinen 6-poligen SMD-Gehäuse:
* http://www.st.com/stonline/products/literature/ds/12635/dsilc6-4xx.pdf
* http://www.st.com/stonline/products/literature/ds/11599.pdf
* http://www.st.com/stonline/products/literature/ds/6477/dalc208.pdf
* http://www.diodes.com/datasheets/ds30195.pdf
* http://www.littlefuse.com/data/en/Data_Sheets/SP724Lead_Free.pdf

= Weblinks =

* Gaurang Kavaiya, [http://www.edn.com/contents/images/6335309.pdf Don’t pay for level translators in systems using multiple power-supply voltages], EDN, MAY 25, 2006, 81-86 (PDF)
* http://www.elektronik-kompendium.de/public/schaerer/scf3_lc.htm
* http://www.prog-link.com/dcf77/dcf77-17.html
* http://elektronik.kai-uwe-schmidt.de/index.php?page=mp3_blueschaltung
* http://www.mikrocontroller.net/attachment.php/256452/levelshifter.pdf
* http://www.semiconductors.philips.com/acrobat_download/literature/9398/39340011.pdf
* http://www.mikrocontroller.net/forum/read-1-234277.html#new
* http://www.semiconductors.philips.com/acrobat/literature/9398/39340011.pdf
* http://www.st.com/stonline/products/literature/ds/5186/74lcx16245.pdf
* http://www.standardics.nxp.com/products/lvc/buffers/
* http://www.standardics.nxp.com/products/lvc/transceivers/

[[Category:Bauteile]]