AVR Embedded Tutorial - I²C EEPROM/de

│ Deutsch (de) │ English (en) │

I²C EEPROM (24LC256)

Vorwort

Dieser Code ist für einen Atmega328/Arduino mit 16MHz und 24LC256.
Es können auch andere 24LCxx angesteuert werden.

Die folgende Funktionen, sind in folgenden Tutorials beschrieben:

• Delay
• UART, Serielle Schnittstelle
• I²C-Bus ansteuern oder AVR Embedded Tutorial - Software I2C, TWI/de

Beschreibung

Dieses Beispiel zeigt, wie man einen externen EEPROM (24LC256) ansteuert, welcher am I²C-Bus hängt.

PulUp-Widerstände sind nötig, der EEPROM enthält keine.

Funktionen für die EEPROM (24LC256) Ansteuerung.

Konstanten

const
  TWI_Write = 0;
  TWI_Read  = 1;

Funktionen

Hinweis: Bei einem ShortString ist ist das Längen-Byte in ShortString[0].

Aufrufparameter:

• addr Geräteadresse am I²C-Bus
• pos Speicherstelle im EEPROM
• value Zu schreibendes Byte

Funktionen zum schreiben und lesen eines Bytes:

// Schreibt ein Zeichen
procedure I2C_EEPROM_Write(addr, pos: Int16; value: Byte);
begin
  TWIStart((addr shl 1) or TWI_Write);
  TWIWrite(pos shr 8);
  TWIWrite(pos and $FF);
  TWIWrite(value);
  TWIStop;
  delay_ms(10);
end;

// Liest ein Zeichen
function I2C_EEPROM_Read(addr, pos: Int16):Byte;
begin
  TWIStart((addr shl 1) or TWI_Write);
  TWIWrite(pos shr 8);
  TWIWrite(pos and $FF);
  TWIStop;

  TWIStart((addr shl 1) or TWI_Read);
  Result := TWIReadNACK;
  TWIStop;
end;

Bei einem String, oder sonstigen Puffer, wird Zeichen für Zeichen geschrieben/gelesen.

// Schreibt einen String, inklusive LängenByte.
procedure I2C_EEPROM_WriteString(addr, pos: Int16; s: ShortString);
var
  i:Byte;
begin
  for i := 0 to Length(s) do begin
    I2C_EEPROM_Write(addr, pos + i, Byte(s[i]));
  end;
end;

// Liest eine String aus, inklusive LängenByte.
function I2C_EEPROM_ReadString(addr, pos: Int16):ShortString;
var
  i, l:Byte;
begin
  l := I2C_EEPROM_Read(addr, pos); // Länge des Strings auslesen.
  SetLength(Result, l);
  for i := 1 to l do begin
    Result[i] := Char(I2C_EEPROM_Read(addr, pos + i));
  end;
end;

Beispiel

Konstanten und Variablen

const
  I2Caddr = $54; // Adresse des 24LC256 am I²C-Bus
  s1      = 'Hello World !';
  s2      = 'AVR mit Lazarus ist so schön';

var
  s: ShortString;

Hauptprogramm

Da ein ShortString 256Byte lang ist, wird der zweite String an der Adresse $100(256) im EEPROM gespeichert.

begin
  UARTInit;     // UART inizialisieren
  TWIInit;      // I²C  inizialisieren
  asm Sei end;

  // Die beiden Strings speichern
  I2C_EEPROM_WriteString(I2Caddr, 0,    s1); // Erster String
  I2C_EEPROM_WriteString(I2Caddr, $100, s2); // Zweiter String

  // Die Strings zur Überprüfung wieder laden.
  repeat
    s := I2C_EEPROM_ReadString(I2Caddr, 0);
    UARTSendString('s1: ');
    UARTSendString(s);
    UARTSendString(#13#10);

    s := I2C_EEPROM_ReadString(I2Caddr, $100);
    UARTSendString('s2: ');
    UARTSendString(s);
    UARTSendString(#13#10);
  until 1 = 2;
end.

Wen man es nicht glaubt, das der String im EEPROM ist, der kann die zwei Zeilen mit WriteString(... ausklammern und so nochmals testen.

Siehe auch

• Übersichtseite AVR Embedded Tutorial

Autor: Mathias