Nur ein Schreibvorgang auf EEPROM möglich

Hallo zusammen,
ich habe einen EEPROM, 24lc64
auf den ich einen int schreiben möchte.
Hierzu zerleg ich den int in zwei einzelne Bytes und speichere diese ab.
Zum Auslesen lese ich die zuvor abgelegten zwei Byte’s aus und setze sie wieder zu einem int zusammen.
Leider gibt es ein Problem beim schreiben: Es wird immer nur das erste Byte auf den eeprom geschrieben, das zweite nicht.
Jetzt meine Frage: Ist die Software richtig?

#include <Wire.h>
#define EEPROM_Address 0x50

void setup() 
  {
    Wire.begin(); // initialise the connection
    Serial.begin(9600);
    EEPROM_intToByte(409, 1);
    delay(20);
  }

  void loop() 
  {
    Serial.println(EEPROM_2byteToInt(1));
    delay(10000);
  }

Funktionen:

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

byte EEPROM_readByte(unsigned int eeaddress) {
  byte rData = 0xFF;

  Wire.beginTransmission(EEPROM_Address);
  Wire.write((int)(eeaddress >> 8));    //MSB
  Wire.write((int)(eeaddress & 0xFF));  //LSB
  Wire.endTransmission();

  Wire.requestFrom(EEPROM_Address, 1);
  if (Wire.available()) rData = Wire.read();
  return rData;
}

void EEPROM_intToByte(unsigned int integer, unsigned int startAdr) {
  // convert from an unsigned int to 2-byte
  // integer = int to save as 2 byte
  // startAdr = address of the first byte
  // int ---> 1111 1111 1111 1111 ---> (1111 1111)byte1, (1111 1111)byte2
  byte a;
  byte b;

  a = (int)((integer >> 8) & 0XFF);
  b = (int)(integer & 0XFF);

  EEPROM_writeByte(startAdr, a);
  Serial.print("a = ");
  Serial.println(a);
  startAdr += 1;
  EEPROM_writeByte(startAdr, b);
  Serial.print("b = ");
  Serial.println(b);
}

int EEPROM_2byteToInt(unsigned int startAd) {
  // convert 2-byte to a unsigned int
  int anotherInt;
  byte c;
  byte d;

  c = EEPROM_readByte(startAd);
  Serial.print("c = ");
  Serial.println(c);
  startAd += 1;
  d = EEPROM_readByte(startAd);
  Serial.print("d = ");
  Serial.println(d);

  anotherInt = int(( (c << 8) + (d) ));

  return anotherInt;
}

Anschluss:

A0, A1, A2, Vss, WP —> Gnd
Vcc —> 5V
SCL —> A5
SDA —> A4

Ich verwende ein Arduino Uno.

Hoffentlich könnt ihr mir helfen,
gruß Steffen

Dafür gibt es auch fertige Makros: http://arduino.cc/en/Reference/WordCast http://arduino.cc/en/Reference/LowByte http://arduino.cc/en/Reference/HighByte

Ist vielleicht sicherer als das selbst zu erledigen und dabei Fehler mit den Datentypen zu machen

Der Cast auf int bei der Adresse ist überflüssig. Außerdem sollte auch Multi-Byte Zugriff möglich sein. Man kann mehr als 1 Byte hintereinander Lesen und Schreiben. Jedes Byte einzelne zu behandeln geht aber natürlich auch.

Hallo,

er kann auch die EEPROM Library nehmen. Noch einfacher.

Doc_Arduino: er kann auch die EEPROM Library nehmen. Noch einfacher.

die ist für den internen EEPROM des AVR, Steffen möchte aber aber einen externen mit I²C ansprechen.

Danke für die Antworten, ich werde es mal mit den makros testen. Man kann auch mit pages schreiben, aber so weis ich nicht genau auf welche Adressen geschrieben wird. Nur die Startaddresse.

stevie1002: Man kann auch mit pages schreiben, aber so weis ich nicht genau auf welche Adressen geschrieben wird. Nur die Startaddresse.

Mehr braucht man auch nicht. Der Integer-Funktion übergibst du ja auch nur die Adresse des ersten Bytes

Wobei ich jetzt auch sehe woher du den Code hast: http://playground.arduino.cc/code/I2CEEPROM Das sollte also demnach funktionieren wenn die Adresse passt

Jetzt klappt alles: Habe ein Delay von 20ms in die EEPROM_writeByte() - Funktion ergänzt und 10k Ohm Pullup's von +5V auf SDA & SCL.

Vielen Dank nochmal für eure Hilfe. Gruß Steffen