kramann.info
© Guido Kramann

Login: Passwort:










Mikrocontroller
1 Einfuehrung
..1.1 Entwicklungsgeschichtliches
..1.2 Maschinensprache
..1.3 Assemblerbeispiel
..1.4 Sprachwahl
..1.5 Praxis
....1.5.1 Digital_IO
....1.5.2 Byteoperationen
....1.5.3 AVR_Studio
....1.5.4 Testboard
....1.5.5 Aufgaben
....1.5.6 Do_it_yourself
......1.5.6.1 Ampel
......1.5.6.2 Programmierer
..1.6 Literatur
..1.7 Programmierer
....1.7.1 Bauverlauf
....1.7.2 KurzreferenzLow
....1.7.2 Kurzreferenz_16PU
..1.8 Uebung1
..1.9 BoardAtHome
....1.9.1 Software
....1.9.2 Hardware
....1.9.3 Knoppix
....1.9.4 Aufbau
....1.9.5 LED
2 Oszillator
..2.1 Assembler
..2.2 Interner_RC
..2.3 Quarz
..2.4 Taktgenerator
3 DigitalIO
..3.1 Elektrische_Eigenschaften
..3.2 Pullup_Widerstaende
..3.3 Bitmasken_Eingang
..3.4 Bitmasken_Ausgang
..3.5 Tic_Tac_Toe
....3.5.1 DuoLEDs
....3.5.2 Schaltplan
....3.5.3 Spielfeld
....3.5.4 Anwahl
....3.5.5 Kontrolle
..3.6 Laboruebung2
..3.7 Laboruebung2_alt
4 PWM
..4.1 Prinzip
..4.2 Nutzen
..4.3 Generierung
..4.4 Programmierung
..4.5 Servos
..4.7 Laboruebung3
..4.8 LoesungUE3
..4.9 Uebung6
5 LichtKlangKugeln
..5.1 LED
..5.2 RGB
..5.3 Sensoren
..5.4 lautsprecher
..5.5 tonerzeugung
6 UART
..6.1 Bussysteme
..6.2 UART
..6.3 RS232
..6.4 Hardware
..6.5 Senden
..6.6 Hyperterminal
..6.7 Empfangen
..6.8 Broadcast
..6.9 Uebung4
7 Infrarot
..7.1 schalten
..7.2 seriell
..7.3 Uebung
8 OOP
..8.1 Probleme
..8.2 Konzept
..8.3 Statisch
..8.4 Datentypen
..8.5 RS232
....8.5.1 Prozedural
....8.5.2 Analyse
....8.5.3 Umsetzung
....8.5.4 Vererbung
....8.5.5 Statisch
....8.5.6 Performance
..8.6 Fahrzeug
9 ADW
..9.1 ADW
..9.2 Zaehler
10 Peripherie
..10.1 RS232Menue
..10.2 ASCIIDisplay
..10.3 Tastenmatrix
..10.4 Schrittmotor
..10.5 Zaehler
..10.6 Uebung7
11 SPI
..11.1 Testanordnung
..11.2 Register
..11.3 Test1
..11.4 Test2_Interrupt
..11.5 Test3_2Slaves
..11.6 Laboruebung
12 EEPROM
13 I2C
..13.1 MasterSendByte
..13.2 MasterSend2Bytes
..13.3 MasterReceiveByte
..13.4 MasterReceive2Bytes
14 Anwendungen
..14.1 Mechatroniklabor
....14.1.1 Biegelinie
....14.1.2 Ausbruchsicherung
....14.1.3 Einachser
....14.1.4 AV
....14.1.5 Vierradlenkung
....14.1.6 Kommunikation
..14.2 Sinuserzeugung
....14.2.1 Variante1
....14.2.2 Variante2
....14.2.3 Variante3
....14.2.4 Variante4
..14.3 Laboruebung8
..14.4 Loesung_Ue8
..14.5 SPI_Nachtrag
20 Xubuntu

12 Verwendung des EEPROMs beim ATmega32

  • EEPROM steht für "Electrical Erasable and Programmable Read Only Memory".
  • Es handelt sich um einen nicht flüchtigen Speicher, der elektrisch durch Überspannungen gelöscht und neu beschrieben werden kann.
  • Er kann in beliebiger Weise zur Laufzeit wie der RAM-Speicher eines Mikrocontrollerprogramms ausgelesen werden.
  • Auch der Lösch- und Schreibvorgang kann durch ein Programm erfolgen.
  • Alternativ kann das EEPROM auch direkt über die ISP-Programmierschnittstelle beschrieben werden, ähnlich dem Flashen von Programmen.
  • Jedoch ist die Anzahl der Schreib-Zyklen physikalisch durch Abnutzung begrenzt und dauert wesentlich länger als beim RAM.

Spezifische Eigenschaften des EEPROMs beim ATmega32

  • Größe: 1024 Byte
  • Lebensdauer: 100000 Lösch/Schreib-Zyklen

Register zur Benutzung des EEPROMs beim ATmega 32 laut Datenblatt

  • EEARH - EEPROM Adress-Register höherwertiges Byte, physikalische Adresse: $1F
  • EEARL - EEPROM Adress-Register niederwertiges Byte, physikalische Adresse: $1E
  • EEDR - EEPROM Datenregister, physikalische Adresse: $1D
  • EECR - EEPROM Kontrollregister, physikalische Adresse: $1C

Schreibvorgang

  • Vor einem Schreibvorgang muß gewährleistet sein, dass kein Interrupt auftritt. Dieser muß vor dem Schreiben aktiviert werden.
  • Die zu schreibenden Daten (ein Byte) werden in das Datenregister EEDR gelegt.
  • Die zu beschreibende Adresse in die Adressregidter EEARH und EEARL.
  • Der Schreibvorgang wird ausgelöst durch Setzen der entsprechenden Bits im EEPROM-Controll-Register (EECR).
  • Nach Auslösen des Schreibvorgangs muß abgewartet werden, bis dieser abgeschlossen ist.
  • Dies wird angezeigt durch das Statusbit EEWE in EECR angezeigt.
  • Wenn EEWE auf Null fällt, ist der Schreibvorgang abgeschlossen.

Bedeutung und Bezeichnung der Kontrollbits in EECR

EERIE, Bit 3: 0=kein Interrupt, 1=Interrupt frei, 0 nach Reset.
EEWME, Bit 2: 0=nicht schreiben, 1=Schreibvorgang starten, 0 nach Reset.
EEWE,  Bit 1: 0=schreiben abgeschlossen, 1=Schreibvorgang dauert noch an, unbestimmt nach Reset.
EERE,  Bit 0: 0=nicht lesen, 1=Lesevorgang starten, 0 nach Reset.

Code 12-1: Bedeutung und Bezeichnung der Kontrollbits in EECR

Lesen

  • Der Lesevorgang läuft ähnlich ab, wie das Schreiben:
  • Zunächst wird das auszulesende Register in EEARH und EEARL geschrieben.
  • Danach wird der Lesevorgang durch Setzen von EERE in EECR auf 1 ausgelöst.
  • Im Anschluß steht das gelesene Byte in EEDR zur Verfügung.

Programmbeispiel

  • Das folgende Programm testet den Zugriff auf den EEPROM des ATmega32 auf dem Testboard.
  • Zu Beginn zeigt die Anzeige (gesteuert über PORTC) die zuletzt in Adresse 1022 des EEPROMs gespeicherte Zahl an.
  • Durch Betätigen des Tasters PB0 (obere Taste) wird ein Schreibzugriff auf Adresse 1022 ausgelöst und im Anschluß 1 auf der Anzeige ausgegeben.
  • Durch Betätigen des Tasters PB1 (untere Taste) wird die gespeicherte Zahl über PORTC angezeigt.
  • Dieser Vorgang kann beliebig oft wiederholt werden, wobei zu Beginn die Zahl 3 gespeichert wird und mit jedem Auslösen des Speichervorgangs die zu speichernde Zahl (Variable zahl) um 1 erhöht wird.
#include <avr/io.h>
#include <avr/interrupt.h>
int main(void)
{
    uint8_t akku=0;
    uint8_t zahl=3;
    uint8_t status_register; //Merker für Interrupt-Status
    uint16_t adresse = 1022;
    DDRC = 0b11111111;
    DDRB &= 0b11111100;    
    //Interrupts allgemein aktivieren:
    sei();
    //Zuletzt geschriebene Zahl auslesen und anzeigen:
    //Auszulesende Speicheradresse eintragen:
    EEAR = adresse;
    //Lesevorgang auslösen:
    EECR |= (1<<EERE);            
    PORTC = EEDR; //gespeicherte Zahl anzeigen.
    while(true)
    {
        akku = PINB;
        if( (akku & 0b00000001) > 0 ) //PB0, schreiben
        {
            //Warten, bis Taster wieder losgelassen wird, um kein Mehrfachschreiben auszulösen:
            while( (akku & 0b00000001) > 0 )
                akku = PINB;
            //Statusregister zwischenspeichern:
            status_register = SREG;
            //Interrupts ausschalten:
            cli();
            //Adresse eintragen:
            EEAR = adresse; //EEARH und EEARL werden in C als 2Byte-Register EEAR dargestellt.
            //Zahl eintragen:
            EEDR = zahl;
            //Schreibstatus auf 1 setzen, da sonst undefiniert.
            EECR |= (1<<EEMWE);
            //Schreibvorgang auslösen:
            EECR |= (1<<EEWE);            
            //Abwarten, bis EEWE auf Null abfällt, also der Schreibvorgang abgeschlossen ist:
            while(EECR & (1<<EEWE));
            //Statusregister für Interrupts wieder zurück schreiben:
            SREG=status_register;
            //Interrupts wieder zulassen:
            sei();
            //Anzeigen, dass Schreibvorgang abgeschlossen ist:
            PORTC = 1;
            //Zahl inkrementieren für nächsten Schreibvorgang:
            zahl++;
        }
        if( (akku & 0b00000010) > 0 ) //PB1, lesen
        {
            while( (akku & 0b00000010) > 0 )
                akku = PINB;
            //Auszulesende Speicheradresse eintragen:
            EEAR = adresse;
            //Lesevorgang auslösen:
            EECR |= (1<<EERE);            
            PORTC = EEDR; //gespeicherte Zahl anzeigen.
        }
    }
    return 0;
}

Code 12-2: Testprogramm zur Benutzung des EEPROMs im ATmega32.

eeprom.zip - Download des AVR-Projektes.