AVR-Tutorial: Speicher

Wechseln zu: Navigation, Suche

Speichertypen[Bearbeiten]

Die AVR-Mikrocontroller besitzen 3 verschiedene Arten von Speicher:

has Flash EEPROM RAM
Schreibzyklen >10.000 >100.000 unbegrenzt
Lesezyklen unbegrenzt unbegrenzt unbegrenzt
flüchtig nein nein ja
Größe beim ATtiny2313 2 KB 128 Byte 128 Byte
Größe beim ATmega8 8 KB 512 Byte 1 KB
Größe beim ATmega32 32 KB 1 KB 2 KB

Flash-ROM[Bearbeiten]

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 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[Bearbeiten]

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[Bearbeiten]

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. 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[Bearbeiten]

Flash-ROM[Bearbeiten]

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 festgelegten Daten im ROM platzieren 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 Direktiven .db und .dw. In der Regel benötigt man nur .db, was folgendermaßen funktioniert:

 
daten:
    .db 12, 20, 255, 0xFF, 0b10010000

Direktiven wie .db sind Anweisungen an den Assembler, keine Prozessorbefehle. Von denen kann man sie durch den vorangestellten Punkt unterscheiden. In diesem Fall sagen wir 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:

 
    ldi ZL, LOW(daten*2)    ; Low-Byte der Adresse in Z-Pointer
    ldi ZH, HIGH(daten*2)   ; High-Byte der Adresse in Z-Pointer

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 hier nach.

Um zu zeigen wie das alles konkret funktioniert, ist das folgende Beispiel nützlich:

 
.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

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.

 
.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

Neuere AVR-Controller besitzen einen erweiterten Befehlssatz. Darunter befindet sich auch der folgende Befehl:

 
    lpm     r16, Z+

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:

 
; 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

Wenn man bei .db einen Text in doppelten Anführungszeichen angibt, werden die Zeichen automatisch in die entsprechenden ASCII-Codes umgerechnet:

 
    .db     "Test", 0               
    ; ist äquivalent zu
    .db     84, 101, 115, 116, 0

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[Bearbeiten]

 
    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.

EEPROM[Bearbeiten]

Den Flash Speicher kann man also benutzen, um dort Daten abzulegen, die sich während eines Programmlaufs nicht verändern. Irgendwelche Tabellen oder konstante Texte. Aber des öfteren möchte man auch die Möglichkeit haben, Daten zu speichern und wieder zu lesen, die sich während des Programmlaufs ändern. Ganz besonders möchte man eine Speicherfläche zur Verfügung haben, die ihren Inhalt auch dann behält, wenn dem µC die Versorgungsspannung abgedreht wird. Man denke z.B. an irgendwelche Konfigurationsdaten oder an Informationen, wie weit der µC in der Bearbeitung von Daten vorangekommen ist oder irgendwelche Statistikdaten, die auch nach einem Stromausfall noch verfügbar sein sollen. In solchen Fällen kommt das EEPROM zum Einsatz

Lesen[Bearbeiten]

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.

 
.include "m8def.inc"
 
; hier geht die Programmsektion los
.cseg
 
    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

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:

 
.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

Schreiben[Bearbeiten]

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 (EEPROM Address Register) geladen. Dann schreibt man die Daten, welche man auf der im Adressregister abgespeicherten Position ablegen will ins Register EEDR (EEPROM Data Register). Als nächstes setzt man das EEMWE Bit im EEPROM-Kontrollregister EECR (EEPROM Control Register) 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.

 
.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

SRAM[Bearbeiten]

Die Verwendung des SRAM wird in einem anderen Kapitel erklärt: AVR-Tutorial: SRAM

Siehe auch[Bearbeiten]