uint16_t in den EEPROM scheiben

Der original Codeschreiberling einer WriteEeprom(uint16_t address, String value) function schreibt Integers als String in den EEPROM.
12678 belegen in diesem Fall 5 Byte.

const uint16_t EepromAdress[] = {ssid_Address, password_Address, localip_Address, enablestaticip_Address, subnetip_Address, gatewayip_Address, dnsip_Address, intvalAddress};
  
const uint16_t EepromLength[] = {32, 32, 15, 1, 15, 15, 15, 5};


uint16_t GetStartingPos(uint16_t StartAddress) {
  static uint16_t SizeOfArr = (sizeof(EepromAdress) / 2) - 1;
  uint16_t i = 0;
  uint16_t StartingPos = 0;
  for (i = 0; i < SizeOfArr; i++) {
    if (EepromAdress[i] == StartAddress) {
      StartingPos = i;
      break;
    }
  }
  return StartingPos;
}

void WriteEeprom(uint16_t StartAddress, String value = "") {
  uint16_t ArrPos = GetStartingPos(StartAddress);
  uint16_t i = 0;
  //Clear EEPROM first
  for (i = StartAddress; i < (StartAddress + EepromLength[ArrPos]); i++) {
    EEPROM.write(i, 0);
  }
  uint16_t bytePos = StartAddress;
  for (i = 0; i < value.length(); i++) {
    EEPROM.write(bytePos, value[i]);
    bytePos++;
  }
  // Commit changes to EEPROM
  EEPROM.commit();
}

Wie kann ich das gleiche Resultat mit 2 Bytes im EEPROM erzielen?

void EepromWriteInt(uint16_t StartAddress, uint16_t value) {
  uint16_t ArrPos = GetStartingPos(StartAddress);
  uint16_t i = 0;
  
  //Clear EEPROM first  
  for (i = StartAddress; i < (StartAddress + EepromLength[ArrPos]); i++) {
    EEPROM.write(i, 0);
  }

  uint16_t bytePos = StartAddress;

  //hier fehlt mir der Code, um value als 2 Bytes in den EEPROM zu schreiben
  .
  .
  .

  // Commit changes to EEPROM
  EEPROM.commit();
}

Warum sagst du nicht, dass du einen ESP verwendest?

Tipp:
EEPROM.put()
EEPROM.get()

Sorry, habe ich nicht erwähnt: Ich will in den ESP8266 und ESP32 EEPROM schreiben.
Die Arduino Reference spricht so:
EEPROM.put(address, value);

Wenn value zu groß ist und nicht in 2 Bytes passt, wird der Wert der nächsten Variable im EEPROM ohne wenn und aber teilweise überschrieben.

Kann man nicht den uint16 _t in 2 Bytes zerlegen und dann schreiben, dass wirklich nur 2 Bytes geschrieben werden?

Warum sollten für ein unt16_t mehr als 2 Byte geschrieben werden?
Wie kommst du überhaupt auf solch eine absurde Idee?
(ist sie wirklich SO absurd?)

Tausche bitte deine Informationsquellen aus!

Tipp:
Mit Strukturen und offsetof() kannst du auf die fehlerträchtigen händischen Adressberechnungen vollständig verzichten. Alles dieses dem Compiler überlassen.

Aufgegeben, oder angewendet?

Nicht aufgegeben

//This function will write an integer to the eeprom at the specified address
void EepromWriteInt(uint16_t StartAddress, uint16_t value) {
  const unsigned char high = ((value >> 7) & 0x7f) | 0x80;
  const unsigned char low  = (value & 0x7f);

  EEPROM.write(StartAddress, high);
  EEPROM.write(StartAddress+1, low);
  
  // Commit changes to EEPROM
  EEPROM.commit();
}

//This function will read an integer from the eeprom at the specified address
uint16_t EepromReadInt(uint16_t StartAddress) {
  const unsigned char high = EEPROM.read(StartAddress);
  const unsigned char low = EEPROM.read(StartAddress+1);

  return (((high & 0x7f) << 7) | low);
}

Funktioniert 1A für uint16_t. Größere werden durch den Sketch eh nicht in den EEPROM geschrieben.

Hi

Verstehe Deine Bit-Schieberei nicht - dort wird kein 16bit-Wert gespeichert.
Dort speicherst Du die unteren 7 Bit (0…127) in low - Da gehören die unteren 8 Bit rein.
Um diese 7 Bit schiebst Du die Ausgangs-16bit nach Rechts und behälst davon ebenfalls nur die unteren 7 Bit.
Nun haben wir, unterm Strich, 14 Bit.
Du kannst damit Werte 0 … 16383 im EEprom verewigen.

Wenn Du um 8 Bit verschiebst (<<8 >>8 ) und mit 0xFF maskiers und die | 0x80 weg lässt (warum sind Die Da drin?), bekommst Du als Wertebereich 0…65535 - Das ist die 4-fache Menge (eben 2 Bit mehr, 2 hoch 2=4).

Selbst, wenn Du in diesem Sketch auch mit 16000 klar kommst - die Funktion ist so nicht wirklich wiederverwendbar.

Dein Krampf mit |0x80 (setze 7.tes Bit) ergibt keinerlei Sinn - dieses Bit wird beim Zusammenbau wieder komplett ignoriert.

Ändere Deine 0x7F in 0xFF, die <<7 wie die >>7 jeweils in 8 und nimm die |0x80 raus.
Du wirst keinen Unterschied sehen, wenn diese Funktion bis jetzt für Dich funktioniert hat, aber DANN speichert Die auch einen 16bit-Wert, ohne Diesen vorher zu kastrieren.
(wobei hier ja Oben was abgeschnitten wird, nicht Unten oder gar in der Mitte)

MfG

Edit >>8) → >>8 )

Verstehe Deine Bit-Schieberei nicht -

Und ich bin frustriert....

Hier, und auch im Nachbarthread....

Kann ich es so schlecht erklären?
Habe ich die gänzlich falsche Sichtweise auf die Dinge?
Oder ist das Thema, an sich, so schwierig/abstrakt, dass es so wenig zugänglich ist?

Gerade im Bereich EEPROM tauchen die, meinem Urteil nach, absurdesten Dinge auf.
Und gerade auf diese Absurditäten wird beharrt.

  • händisches berechnen der EEPROM Adressen
  • händisches zerlegen und zusammenfügen der Daten

Ich will nicht sagen, dass das unbedingt falsch ist.
Aber es ist fehlerträchtig.
Mehr Schreiberei.
Und dazu noch unübersichtlich.

Selbst einen eigenen Thread habe ich mal dafür eröffnet.
OK, da dreht sich es um AVR EEPROM. Aber das Interface der jeweiligen EEPROM Klasse ist sehr ähnlich, so ähnlich, dass die Strukturvariante übertragbar ist.

Dummerweise habe ich die Empfindung, die Sache recht tief durchdrungen zu haben, kann mich aber kaum mitteilen. Zumindest nicht so, dass es Früchte trägt.
Wo klemmt es, in der Sache?
Was mache ich falsch?

Wer nach 270 Posts immer noch nicht geschnallt hat, dass ein uint16_t nicht größer als 2 Byte werden kann, der sollte evtl. aber auch mal seine Grundeinstellung zum Erlenen elementarster Grundkenntnisse überdenken.

Gruß Tommy

Schraub deine Erwartungshaltung bezüglich deinem Gegenüber hinunter. Erklärs empfängergerecht. Wenn du nicht weißt wer gegenüber sitzt, geh von einem 8jährigen aus.

Ja, da hapert es!

Mein Problem ist wohl hier recht gut beschrieben: Kompetenzstufenentwicklung

Nehmen wir mal den totalen Anfänger als Beispiel:

Meiner Erfahrung nach, können sich nur Personen auf benachbarten Stufen wirklich erfolgreich miteinander verständigen.

Ich fühle mich in Sachen EEPROM auf Stufe 4, komme runter auf Stufe 3, wenn ich es erklären möchte.
Mein Gegenüber müsste sich im Gegenzug von Ebene 1, Richtung Ebene 2 bewegen.
Schon wären wir benachbart.
Das würde dann z.B. zielgerichtete Nachfragen erlauben...

Witzig ist, dass das bei anderen Themen oftmals recht gut klappt.
Aber dieses EEPROM Thema, naja, da will es nicht gelingen.

Mein Versuch mich von 4 zu 3 zu bewegen mag nicht perfekt sein.
Aber auf 2 komme ich nicht mehr runter.
So viele Substanzen kann ich mir gar nicht auf die Platine gießen.

Als wenn es da eine (Erkenntnis) Hürde gibt, wo ich vermutlich drüber bin, und andere wie ein Ochs vorm Berge stehen.
Leider sehe ich diese Hürde nicht.
Auch wenn ich zurückblicke, sehe ich sie nicht.
Siehst du diese Hürde?

Hi

Habe schon für eBay eine Liste ... Das jetzt noch hier einzuführen (also für mich) ... ich lese eh Alles, habe für mich aber mittlerweile entschieden, daß nur User mit einem halbwegs vernünftigem Nick 'Es auch wert' sind, zumindest fielen 'die Anderen' bisher regelmäßig durch.
Ausnahmen wird Es auch hier geben - ich will aber nicht wiederholt meine Zeit in einen User versenken, Der Es halt zuvor schon ein Mal 'nicht wert' war, Es also keine oder nur arg seltsame Früchte trug.

Wenn die Kompetenz zum Automatismus geworden ist, ist's halt vorbei mit 'drüber nachdenken' - der Kram wird irgendwie gefühlt, ist in Fleisch und Blut.
Dann wird's auch schwer zu begründen, warum man Etwas so und so macht ... weil's halt einfach so gehört ... hilft dem Fragendem halt nicht weiter, wenn's halt aber auch so ist :slight_smile:

MfG

Ja, ach ....
Ich möchte eigentlich nicht so gerne urteilen...

Ja, das vereinfacht vieles.
Ist aber auch schnell mal eben ungerecht.
Gerade wenn man es dem Bauch überlässt.
Sicherlich, in akuten Notlagen genau das richtige.
Aber im übrigen Leben eher nicht.
Naja...

der sollte evtl. aber auch mal seine Grundeinstellung zum Erlenen elementarster Grundkenntnisse überdenken.

Etwas grob formuliert, trifft aber den Punkt.

Die Frage "Wie im EEPROM speichern und draus lesen?"

Bedingt, dass man sich ein Bild davon machen kann wie diese Daten im Speicher rum dümpeln.
Im Kern benötigt man nur zwei mal Größe und Ort, und ein paar Funktionen/Methoden für den Transport zwischen den Speicherbereichen.

Da wären dann schon Grundlagen über das Thema "C++ Datentypen" sehr wichtig.
Und sei es auch nur, um zu erfahren, dass man das mit der Größe und Adressierung, durch Strukturierung, quasi vollständig dem Compiler überlassen kann.

Am Rande:
Ich finde den Aufbau der AVR Arduino EEPROM Lib recht interessant.