Daten Speichern und Lesen auf 24LC32

International Deutsch
21

Wo finde ich i2c_eeprom_read_page()?

22

sorry zwei mal das gleiche gepostet hier:

void i2c_eeprom_read_buffer( unsigned int eeaddress, byte *buffer, int length ) {
#ifdef dataReadFromEEPROM
  ueberschriftAnzeigen("Daten vom EEPROM auslesenlesen");
  Serial.print("Adresse der angeforderten Daten: ");
  Serial.println(eeaddress);
  Serial.print("Datenmenge die Angefordert wird: ");
  Serial.println(length);
  Serial.print("Daten die gekommen sind: ");
#endif

  Wire.beginTransmission(deviceaddress_24LC32);
  Wire.write((int)(eeaddress >> 8)); // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
  Wire.requestFrom(deviceaddress_24LC32, length);

  int c = 0;
  for ( c = 0; c < length; c++ ) {
    if (Wire.available()) buffer[c] = Wire.read();
#ifdef dataReadFromEEPROM
    Serial.print((char)buffer[c]);
#endif
  }
23

Es gab mal eine Zeit, da waren I2C EERPOMs für mich interessant.

Funktioniert soweit ganz gut....
Weiterhin.
Macht auch das Paging richtig.

24

Schaue ich mir an :+1:

25

sizeof(somedataA) hat den Wert 13, weil auch die abschließende '\0' mitgezählt wird.

Es geht auch ohne page, nur eben langsamer:

#include <Wire.h>

void i2c_eeprom_writeByte(int deviceaddress, unsigned int eeaddress, byte data)
{
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8)); // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.write(data);
  Wire.endTransmission();
  delay(10);
}

byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress )
{
  byte rdata = 0xFF;
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8)); // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
  Wire.requestFrom(deviceaddress, 1);
  if (Wire.available()) rdata = Wire.read();
  return rdata;
};

void MemoryDump(int deviceaddress, unsigned int NumberOfBytes)
{
  Serial.print(F("Dump of memory content ("));
  Serial.print(NumberOfBytes);
  Serial.print(F(" bytes) from I2C device at address "));
  Serial.println(deviceaddress, HEX);
  unsigned int addr = 0;
  byte b = i2c_eeprom_read_byte(deviceaddress, addr);
  char c;
  while (addr < NumberOfBytes)
  {
    Serial.print(addr, HEX);
    Serial.print("  ");
    c = (char)b;
    Serial.print(c); //print content to serial port
    // if ( (b < 0x20) or (b >= 0x7F) )
    // {
    Serial.print(" (0x");
    Serial.print(b, HEX);
    Serial.print(")");
    // };
    Serial.println();
    addr++; //increase address
    b = i2c_eeprom_read_byte(deviceaddress, addr);
  };
  Serial.println(F("\nEnd of Dump\n"));
};

void setup()
{
  char somedataA[] = "ICEFILAMENTS";
  char somedataB[] = "icefilaments";
  const byte I2C_EEPROM_ADDRESS = 0x57;
  Wire.begin();
  Serial.begin(9600);
  Serial.println(F("\nAnfang EEPROM 24c32\n"));
  Serial.print(I2C_EEPROM_ADDRESS);
  Serial.print(" (0x");
  Serial.print(I2C_EEPROM_ADDRESS, HEX);
  Serial.println(")");
  i2c_eeprom_write (I2C_EEPROM_ADDRESS, 100, (byte *)somedataA, sizeof(somedataA)-1 );
  delay(20);
  i2c_eeprom_write (I2C_EEPROM_ADDRESS, 112, (byte *)somedataB, sizeof(somedataB)-1 );
  delay(20);
  MemoryDump(I2C_EEPROM_ADDRESS, 124);
};

void loop() {};

void i2c_eeprom_write( int i2cadresse, unsigned int eeaddress, byte* data, byte length ) {
  for ( byte c = 0; c < length; c++) {
    i2c_eeprom_writeByte(i2cadresse, eeaddress + c, data[c]);
  }
}

Ist zusammenkopiert, könntest Du für Deine Zwecke optimieren.

Ausgabe:

60  ⸮ (0xFF)
61  ⸮ (0xFF)
62  ⸮ (0xFF)
63  ⸮ (0xFF)
64  I (0x49)
65  C (0x43)
66  E (0x45)
67  F (0x46)
68  I (0x49)
69  L (0x4C)
6A  A (0x41)
6B  M (0x4D)
6C  E (0x45)
6D  N (0x4E)
6E  T (0x54)
6F  S (0x53)
70  i (0x69)
71  c (0x63)
72  e (0x65)
73  f (0x66)
74  i (0x69)
75  l (0x6C)
76  a (0x61)
77  m (0x6D)
78  e (0x65)
79  n (0x6E)
7A  t (0x74)
7B  s (0x73)

End of Dump

Das von @combie ist vermutlich besser :roll_eyes:

26

Besser ist immer relativ.....
Leider kann es bisher nur EEPROM und FRAM im 1Byte und 2Byte Adressierungsmodus.

Ein Upgrade auf die neueren größeren EEPROM wäre mal angesagt, in Verbindung mit einer eher allgemeinen Renovierung. Habe ja schließlich die letzten 5 Jahre sogar noch etwas dazugelernt. (so ich hoffe)

27

EEprom sind in Page eingeteilt.
Pages kann man in einem Rutsch schreiben. Das Page Write funktioniert indem man die Adresse sendet und dann bei diesem EEprom bis zu 32 Byte, Die Adresse wird automatisch nach jedem Byte erhöht. Das Problem ist daß nur die unteren (5) Adresbyte incrementiert werden und man somit innerhalb der Page bleibt. fängt man am Anfang einer Page an kann man 32 Byte schreiben, fängt man beie iner höheren Adresse an kann man bis zu Pagegrenze schreiben und muß dann für die Nächste Page nochmal die Startadresse senden.

also zB ich will bei 32 byte Page 16 Byte ab Adresse 24 schreiben dann übermittle ich die Adresse 24 und schreib 8 Byte. Dann muß ich die Adresse 32 übermitteln und dann die nächsten 8 Byte. Würde ich 16 byte ab adresse 24 schreiben hätte ich von 24 bis 31 und von 0 bis 7 geschrieben.

Grüße Uwe

28

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.