-
EEPROM - Adresse
Moin
Also folgendes Problem: Ich will auf den EEPROM schreiben und lesen (so ein zufall aber auch...)
Jetzt will ich nach dem Neustart wieder auf die selben Daten zugreifen. Dafür muss ich aber wissen welche Adresse die Daten haben. Und mein Problem ist jetzt, dass ich nciht weiß wie das mit den Adressen aussieht. Das Datenblatt hat mir da irgendwie nicht wirklich geholfen.
Achja und noch was: Wenn ich mit eeprom_wirte_byte(adresse, inhalt) einen Wert schreibe, dann muss doch vorher noch kein Platz definiert sein müssen, oder irre ich mich da? So versteh ich nämlich diese Sonderheiten des EEPROM.
Also meine eigentlcih Frage ums mal auf den Punkt zu bringen: Ich will bei jedem Start zuerst die ersten beiden Bytes im Speicher auslesen, weil ich mir gedacht habe, in diesen zu speichern, wo ich hinten weiter machen kann mit schreiben.
Wenn ich die Daten dann auslese, dann setzte ich diesen "Pointer" wieder auf den Anfang und ich kann den Speicher wieder voll schreiben.
Ich hoffe ihr habt verstanden was ich von euch will. Also wo fängt denn jetzt der Speicher im EEPROM an? Einfach bei 0x00? und ist dann das 2. Byte bei 0x08? oder wie ist das zu verstehen?
Danke
Andun
-
Du kannst
1) Dir die Adressen der Daten selber raussuchen, also etwa schreiben (void*) 0x123
2) Du kannst Daten ins EEPROM lokatieren:
Code:
#define EEMEM __attribute__ ((section (".eeprom")))
foo_t foo_sram;
foo_t foo1 EEMEM;
foo_t foo2 EEMEM =
{
.member1 = 1,
.member2 = 2
};
eeprom_read_block (&foo_sram, &foo1, sizeof (foo_t));
foo_sram.member1 = eeprom_read_word (&foo2.member1);
-
Moin
Danke schon mal für deine Antwort. Ich glaube die habe ich auch verstanden. Allerdings beantwortet das meine Frage glaub ich noch nicht ganz so gut. Das Problem was ich hab, ist dass ich ja auch nach nem RESET wieder auf die selben Daten zugreifen will. Dann hab ich im Speicher die adresse von foo1 und foo2 nicht mehr, oder?
Deswegen dachte ich mir, ich schreib die Ausgangsadresse meiner Daten immer an Speicherposition 0.
Dann les ich dort immer den Pointer aus, wo cih den nächsten Wert im EEPROM hinschreiben muss.
Hab cih da nen Denkfehler drin, oder bin cih nur zu blöd zu merken, dass du mir das schon beantwortet hast?
Danke
Andun
Nachtrag:
Hier mal mein Code bis jetzt:
Code:
adress = eeprom_read_word(0x00);
#if DEBUG
uart_puts("Ich werde bei "); PrintInt(adress); uart_puts(" anfangen in den EEPROM zu schreiben.");
#endif
eeprom_write_byte((uint8_t*)adress, sek[0]); adress += 8;
eeprom_write_byte((uint8_t*)adress, min[0]); adress += 8;
eeprom_write_byte((uint8_t*)adress, hour[0]); adress += 8;
eeprom_write_byte((uint8_t*)adress, date[0]); adress += 8;
eeprom_write_byte((uint8_t*)adress, mon[0]); adress += 8;
eeprom_write_byte((uint8_t*)adress, Sensordaten.luftdruck); adress += 8;
eeprom_write_byte((uint8_t*)adress, Sensordaten.feuchte_komp); adress += 8;
eeprom_write_byte((uint8_t*)adress, Sensordaten.temperatur_lin); adress += 8;
eeprom_write_word(0x00, adress);
-
foo1 und foo2 stehen im EEPROM, die Adressen werden zur Compilezeit festgelegt, oder was meinst du?
Wenn du so was machen willst, würde ich dir anraten, ne Struktur zu machen, wo das ganze Zeug drin ist, anstatt die Daten überall zu verstreuen.
Zudem belegt ein Byte nur ein Byte im EEPROM, nichte derer 8.
Evtl musst du auch was für die Konsistenz überlegen, wenn mitten im Schreiben des Saft ausgeschaltet wird.
Daten kannst du auch im SRAM einen RESET überstehen lassen, wenn es kein PowerOn-RESET oder so ist. Beispiele dazu gibt es im GCC-Artikel.
-
Code:
typedef struct
{
uint8_t sec;
uint8_t min;
uint8_t hour;
uint8_t mon;
uint8_t year;
} time_t;
typedef struct
{
uint16_t luftdruck;
uint16_t feuchte_komp;
uint16_t temperatur_lin;
} sensor_data_t
typedef struct
{
time_t time;
sensor_data_t sensor;
} mess_data_t;
mess_data_t data;
mess_data_t * pdataEE;
pdataEE = (mess_data_t*) 0x2;
eeprom_write_block (&data, pdataEE, sizeof (data));
pdataEE++;
-
Also, stimmt. Das mit den 8 Byte war ein denkfehler ... ich hab irgendwie in Bit gedacht ... ???
Ne Struktur zu machen, ginge auch, hast recht. Aber mir geht es im Moment gar nciht um Sicherheit, ich will eigentlcih erstmal nur was funktionierendes auf die Beine stellen, da ich es etwas eilig habe. (Normalerweise würde ich das auch ordentlicher machen)
Also, die Daten im SRAM überleben zu lassen ist mir nicht sicher genug, da die Daten bzw. die Adressen der Daten auch nach einer kompletten Trennung vom Strom noch da sein sollen.
Also generell die Frage: Ist das denn möglich, so einfach bei 0x00 die Adresse zu hinterlegen und dann so zu benutzen?
(Achja, ist der cast zu den Pointern so richtig mit (uint8_t*)adress ?)
Danke
Andun
-
SO wie du adress benutzt, sollte es ohnehin vom Typ uint8_t* sein. Ansonsten kannst du bös auf die Nase fallen mit adress++ oder adress+=10. Zwar merkst du das nicht, weil du den Fehler beim Lesen und Schreiben machst, aber du hast dann viele "Löcher" in der EEPROM-Nutzung.
Den EE-Routinen sollte es egal sein, da müsste auch ein void* gehen.
-
Aha, ok. Ich werde das ganze jetzt erstmal in ein Struct bauen, scheint doch irgendwie sicherer, aber muss ich jetzt eigentlcih die adress immer um 1 weiter zählen um zum nächsten byte zu kommen oder um 8? Also geht das in Byte oder Bit?
Ich werde das ganze, aber dann jetzt gleich auch einfach mit adress += sizeof(struct Messung) machen. Dass sollte doch dann gehen, oder?
In die Struktur tu ich dann die 8Bytes mit der Uhrzeit und den Messdaten.
Andun
-
Die Semantik von
blah_t * pointer;
int n;
pointer += n; // Das ist (wenn man pointer als int ansieht) pointer += n*sizeof (blah_t)
Ist Pointer also ein Zeiger auf long und steht pointer auf 0x9, dann steht er nach point++ auf 0xd (zumindest auf avr).
-
Achsoooooo, also zeigt der Pointer wenn ich ihn um 1 hochzähle auf den nächsten Wert, wenn man annimmt, dass alle gleich groß sind.
(Mein Satz klingt wahrscheinlich bescheuert, aber ich bin mir sicher, dass ich es verstanden habe. Erklären können muss cih es ja nciht unbedingt :D)
Gut, dann leg ich jetzt die Struktur an und speichere diese und erhöhe dann den Pointer (der ein Pointer auf diese Struktur ist) um 1. Dann zeigt der zeiger direkt hinter die Struktur im Speicher.
So, das ist doch endlcih richitg verstanden oder?
