Unterrichts- und Lernmaterial für Mikrocontroller
Unterrichts- und Lernmaterial fürMikrocontroller

EEPROM - Teil 1

Um diesen Abschnitt besser zu verstehen, sollten vorher die Kapitel

durchgearbeitet werden.

Es kommt nicht selten vor, dass man bei einem Projekt einen nicht-flüchtigen Speicher benötigt, in dem Daten auch nach dem Abschalten der Spannungsversorgung erhalten bleiben. Die dafür häufig genutzten Speicherbausteine sind sogenannte Flashs oder EEPROMs. Die AVRs verfügen von Hause aus bereits über einen kleinen EEPROM-Speicherbereich, wie zum Beispiel der ATmega8515 mit 512 Byte. Wenn das nicht ausreicht, greift man auf EEPROM-ICs mit I2C Interface zurück, die belegen nur zwei I/O Ports eines Controllers.

In den folgenden Übungen werden - je nach eingesetztem Controller - 24LC256 oder 24FC512 EEPROM ICs eingesetzt mit einer Kapazität von 32kByte bzw. 64 kByte und einem breiten Versorgungsspannungsbereich von 2,5 - 5,5 V. Zu den Boards/Controllern:

  • Propeller
  • Arduino UNO und
  • ATmegaXX

werden entsprechende Softwarelösungen in den folgenden Übungen erarbeitet.

 

BASIC Stamp und EEPROM

Wer mit einer BASIC Stamp arbeitet, muss auf die Nutzung eines EEPROMs mit I2C-Bussteuerung verzichten. Mit drei Ausnahmen: die Typen BS2p, BS2pe und BS2px sind I2C-tauglich.

Pinbelegung der 24XX256/512 ICs

Abbildung 1 - Pinbelegung des 24xx256/512

Informationen zum 24LC256

Wissenswertes zum 24 LC 256
Schreib-/Löschzyklen > 106
Interface TWI (I2C)
A0, A1, A2 Chip select; in allen Übungen hardwired auf 000
Vss GND
Vcc 2,5 V - 5,5 V
Speicherkapazität 256 Kilobit = 256 x 1024 Bit = 262.144 Bit, das entspricht 32.768 Byte oder 32 kByte.

Adressierung

Jede Speicherzelle kann maximal 8-Bit Daten speichern; es sind also nur Zahlenwerte zwischen 0 und 255 oder bei vorzeichenbehafteten Zahlen zwischen -128 bis +127 möglich. Größere Zahlen lassen sich nur in mehreren Zellen ablegen, indem man sie in ein Higher- und Lowerbyte aufspaltet.

Die Lebensdauer eines EEPROMs ist durch die Schreib-/Löschzyklen begrenzt (siehe Informationskasten zum 24LC256). Gerade Anfänger sollten deshalb sorgfältig darauf achten, dass Schreibzyklen nicht in Endlosschleifen eingebettet sind; sonst kommen schnell 10.000 oder mehr Zyklen zusammen und das IC gibt nach wenigen Minuten seinen "Speichergeist" auf.

Übung 1 - EEPROM und Propeller-Controller

Auf den Propeller-Boards (Prop-BoE, Prop-AB) befindet sich fest verdrahtet ein EEPROM 24FC512 mit 64kByte Speicher. Eine zusätzliche Verdrahtung ist nicht vorzunehmen.

 

Die Adresspins

Die drei Adressleitungen (A0 ... A2) sind auf GND gelegt; das IC wird auf einem I2C-Bus mit der Adresse 000 angesprochen.

 

Die SCL-Leitung

Über die SCL-Leitung wird die Kommunikation zwischen den einzelnen Bausteinen synchronisiert. Der SCL-Anschluss des EEPROMs ist mit dem Propeller über den I/O Pin 28 verbunden. Über einen internen Pull-Up-Widerstand wird die SCL-Leitung auf 3,3 V gezogen (siehe Schaltskizze), wenn keine Kommunikation stattfindet.

 

Die SDA-Leitung

Über die SDA-Leitung erfolgt der Datenaustausch zwischen den einzelnen Bausteinen/Geräten. Der SDA-Pin des EEPROM ist fest verbunden mit P29 des Propeller Controllers. Auch die SDA-Leitung verfügt über einen internen Pull-Up-Widerstand (s. Schaltskizze).

 

Schreibschutz

WP steht für write protect; wird es mit einem HIGH-Signal aktiviert, dann lassen sich die Daten in einem EEPROM nicht mehr verändern. Der Schutz wird mit einem LOW-Signal aufgehoben.

Adressierung des 24xx256/512

Im Datenblatt des Herstellers ist nachzulesen, wie die Adressierung des ICs zu erfolgen hat (Kapitel 5: Device Addressing). Nach dem Startbit folgt die Slaveadresse, das R/W-Bit und ein Acknowledge. Das Controlbyte hat das folgende Format:

Abbildung 2 - Die Chip Select Bits sind in diesen Übungen immer auf 000 gesetzt.

Es gibt zwei Schreiboperationen: Byte-Write und Page-Write, die sich nur dadurch unterscheiden, dass beim Page-Write 64 Byte hintereinander geschrieben werden können. Das Protokoll für Byte-Write zeigt die folgende Abbildung.

Am Ende einer Byte-Write Sequenz wird eine Stopp-Sequenz (P) gesetzt.

EEPROM und Propeller Controller

Material

 

  • 1x  Propeller BoE
  • 8x  Steckdraht
  • 1x  USB-Kabel

 

Aufgaben

  • Verbinde die 8 LEDs (R1, R0, G1, G0, B1, B0, H, V) auf dem Prop-BoE mit P7 bis P0.
  • Verbinde das Controller-Board mit dem USB-Anschluss des Rechners.
  • Übertrage das Programm EEPROM_01.c in den Editor und speichere es ab.
  • Starte das Programm und überprüfe, ob LED0 (R1) und LED7 (V) leuchten.

Schaltungsaufbau

Abbildung 3 - Links neben dem Propeller-Controller befindet sich das EEPROM 24FC512 mit seinen 8 Anschlüssen.

Schaltskizze

Abbildung 4 - Verdrahtung des IC 24FC512 auf den Propeller-Boards.

Das Programm

Wie arbeitet das Programm EEPROM_01.c?

Im Programm gibt es drei neue Befehle, die kurz erklärt werden müssen.

 

  • newbus (int sclPin, int sdaPin, int sclDrive)

Es wird ein serieller Treiber mit Sende- und Empfangspins eingerichtet. Die Bedeutung der Parameter im Einzelnen:

sclPin              i2c Buspin für den Taktimpuls

sdaPin             i2C Buspin für den seriellen Datenaustausch

sclDrive          aktiviert den internen Pull-Up-Widerstand, wenn 0

 

  • ee_putByte(unsigned char Wert, int addr)

speichert einen Wert vom Typ char an der Stelle addr vom Typ int im EEPROM.

 

  • ee_getByte(int addr)

lädt einen Wert vom Typ char aus dem EEPROM mit der Adresse addr vom Typ int.

Rückgabewert: gibt Wert vom Typ char zurück, der vorher an der Stelle addr im EEPROM abgelegt wurde..

Das solltest du wissen!

Bei einem Propeller-Controller wird der Programmcode im unteren Speicherbereich des EEPROMS abgelegt (0 - 32767). Konstante werden im obersten Bereich - ab 65535 abwärts gespeichert.

Der Speicherbereich ab 32768 aufwärts ist deshalb als Datenspeicher gut geeignet.

Propeller-C stellt zusätzlich sieben weitere Befehle für die EEPROM-Ansteuerung bereit, die über das Help-Menü des SimpleIDE-Editors unter Simple Library Reference abgerufen werden können:

 

  • void ee_putInt (int wert, int addr)

speichert einen wert vom Typ integer an einer bestimmten Adresse addr im Propeller EEPROM. Dafür werden vier Bytes benötigt; ein nachfolgender Zahlenwert vom Typ integer muss also an einer Adresse, die vier Bytes höher liegt, abgelegt werden.

 

  • int ee_getInt (int addr)

Lädt einen Zahlenwert vom Typ integer aus einer vorgegebenen Adresse addr im EEPROM. Nachfolgende Zahlenwerte unterscheiden sich in der Adresse dann immer um 4.

 

  • void ee_putStr (unsigned char *s, int n, int addr)

Speichert einen String von n Byte an einer bestimmten Adresse addr im EEPROM. s ist die Adresse eines Arrays vom Typ char, in dem der String von n Bytes abgelegt ist.

 

  • int ee_getStr (unsigned char *s, int n, int addr)

Lädt einen String von n Byte ab einer bestimmten Adresse addr aus dem EEPROM.

 

  • void ee_putFload32 (float wert, int addr)

Speichert einen 32-Bit Zahlenwert vom Typ float im EEPROM. Bei jeder nachfolgenden Speicherung eines Zahlenwertes muss die Adresse um 4 erhöht werden.

 

  • float ee_getFloat32 (int addr)

Lädt eine 32-Bit Zahl vom Typ float aus einer bestimmten Adresse des EEPROM. Bei einem nachfolgenden Ladevorgang muss die Adresse um 4 verändert werden.

 

  • void ee_config (int sclPin, int sdaPin, int sclDrive)

Optionale Funktion, mit der die Einstellungen für ein externes EEPROM eingestellt werden können.  

Übung 2 - LED Ansteuerung mit EEPROM Daten

In dieser Übung werden in einem ersten Programm vier Byte in das EEPROM geladen. Die "Einsen" in den Bitfolgen in jedem der vier Bytes stehen jeweils für eine eingeschaltete LED.

Abb. 5 - Die Hexadezimaldarstellung der Binärzahl in jedem Byte steht in der rechten Spalte.

Auf diese Weise lässt sich das Knight Rider Lauflicht darstellen; dazu werden mit einem zweiten Programm die Daten aus dem EEPROM ausgelesen und die acht fest verdrahteten LEDs auf dem Prop-BoE angesteuert.

EEPROM und Knight Rider Lauflicht
Material
  • 1x  Propeller BoE
  • 8x  Steckdraht
  • 1x  USB-Kabel
Aufgaben
  • Verbinde die 8 LEDs (R1, R0, G1, G0, B1, B0, H, V) auf dem Prop-BoE mit P7 bis P0.
  • Verbinde das Prop-BoE mit dem USB-Anschluss des Rechners.
  • Übertrage das Programm KnightRider_schreiben.c in den Editor, speichere es ab und starte anschließend das Programm. Daten werden in das EEPROM geschrieben.
  • Übertrage das Programm KnightRider_lesen.c in den Editor und speichere es ab.
  • Starte das Programm. Es sollte das aus dem Film "Knight Rider" bekannte Lauflicht ablaufen.

Schaltungsaufbau

Abb. 5a - P0 - P7 des Prop-BoE sind mit sieben LEDs auf dem Board verbunden.

Das Programm KnightRider_schreiben.c

Abb. 6 - Startet man dieses Programm, wird die Knight-Rider-Bitfolge byteweise im EEPROM abgelegt. Die Variable k vom Typ INT bestimmt das Lauflicht.

Wie arbeitet das Programm KnightRider_schreiben.c?

Programmzeilen 15 - 16

Die Ports P7 - P0 werden als Ausgänge definiert und in Zeile 16 auf LOW gezogen. Da diese Ports mit den fest verdrahteten LEDs über Steckdrähte verbunden sind, leuchtet keine LED.

 

Programmzeile 17

In der Variablen k vom Typ int (4 Byte) werden die vier Bitmuster für das Knight-Rider-Licht abgelegt (s. Abb. 5).

 

Programmzeile 20

Es wird der I2C-Bus eingerichtet; P28 - Taktleitung, P29 - Datenleitung und 0 aktiviert den internen Pull-Up-Widerstand.

 

Programmzeile 21

Die vier Bytes der Variablen k werden - beginnend ab der Speicherstelle 32768 - in den EEPROM-Bereich des Propeller-Controllers geschrieben. Solange der Schreibvorgang andauert, verbleibt das Programm in der WHILE-Schleife (Programmzeile 22).

Das Programm KnightRider_lesen.c

Abb. 7 - Wird dieses Programm gestartet, werden vier Bytes aus dem EEPROM geladen und an die Ausgänge P0 - P7 gelegt, die mit den fest verdrahteten LEDs auf dem Prop-BoE verbunden sind.

Gut zu wissen - Anwendungsbereiche für EEPROMs

Zunächst muss man wissen, dass EEPROMs wesentlich langsamer beschrieben werden können (pro Schreibzyklus ca. 1ms - 10ms) als FLASH-EEPROMs (pro Schreibzyklus ca. 1µs - 1ms), in denen bekanntlicherweise das Programm abgelegt ist. Deshalb werden EEPROMs zur netzausfallsicheren Speicherung von Konfigurationsdaten verwendet.

AVR-Mikrocontroller und der Propeller-Controller haben EEPROMs bereits "an Bord". Bei einem Propeller-Controller stehen von den 64 kByte Flash-Speicher die unteren 32 kByte für Programme und die oberen 32 kByte für Speicherung von Konfigurationsdaten zur Verfügung. Der Austausch der Daten erfolgt hier über einen I2C-Bus.

Übung 3 - Datenspeicherung mit dem Arduino UNO

Der Arduino UNO verfügt über einen EEPROM-Speicherbereich von 1 kByte. Um seine Lebensdauer nicht leichtsinnig zu verkürzen, werden die EEPROM-Schreibbefehle nur im setup() ausgeführt.

Es wird mit drei unterschiedlich gefärbten LEDs gearbeitet und nacheinander zwei Programme ausgeführt.

In einem ersten Programm wird drei farblich unterschiedlichen LEDs ein bestimmter Zustand (LOW oder HIGH) zugeordnet und im EEPROM abgespeichert; anschließend wird das Board vom PC getrennt.

Im zweiten Programm werden die Daten aus dem EEPROM gelesen und an die Arduino-Ports, die mit den LEDs verbunden sind, gelegt. Die ausgelesenen Daten sollten bestimmte LEDs zum Leuchten bringen.

EEPROM und Arduino UNO
Material
  • 1x  Arduino UNO Board mit USB-Kabel
  • 1x  Steckbrett
  • 3x  LED (rot, grün, gelb)
  • 3x  Widerstand, 470 Ohm
  • 4x  Steckdraht
Aufgaben
  • Verbinde den Arduino UNO über das USB-Kabel mit einem Rechner und starte die IDE.
  • Übertrage das Programm eeprom_schreiben.ino in den Editor und speichere es ab.
  • Trenne das Board vom PC und übertrage das Programm eeprom_lesen.ino in den Editor und speichere es ab.
  • Baue die Schaltung nach Schaltskizze auf und verbinde das Steckbrett mit der Spannungsversorgung auf dem Arduinoboard.
  • Verbinde den Arduino UNO über das USB-Kabel mit einem Rechner und starte das Programm eeprom_lesen.ino.
  • Überprüfe, ob die rote und grüne LED aufleuchten.

Schaltskizze

Das Programm eeprom_schreiben.ino

Wie arbeitet das Programm eeprom_schreiben.ino?

Im Initialisierungsteil (Programmzeilen 10 - 14) werden die Variablennamen und Zuweisungen festgelegt. Die Digitalports 2 - 4 werden als Ausgang geschaltet (Zeilen 17 - 19) und mit drei Schreibbefehlen werden in die Adressen 0 - 2 die Werte 1, 0 und 1 geschrieben.

Der Verzögerungsbefehl nach jedem EEPROM.write ist notwendig, da jeder Schreibbefehl ca. 3ms benötigt.

Das Programm eeprom_lesen.ino

Wie arbeitet das Programm eeprom_lesen.ino?

Neues passiert nur in den Programmzeilen 17 - 22. Es werden nacheinander die mit dem ersten Programm in das EEPROM geschriebenen Werte aus den Speichern 0 - 2 ausgelesen, der Variablen HiLow zugewiesen und an die Ausgänge des jeweiligen Ports gelegt, mit der Folge, dass die angeschlossene LED leuchtet (wenn 1) oder nicht (wenn 0).

 

Im Hauptmenü des Editors über Hilfe - In der Referenz suchen - Libraries - EEPROM findet man umfassende Informationen zu den o.g. Befehlen und weiteren.

Druckversion Druckversion | Sitemap
© Reinhard Rahner - Gettorf