Header- Files ind EEprom

[jens (Gast)]

hey

müsste ein HeaderFile im EEPROM meines AtMega32 ablegen. Im HeaderFile 
befindet sich ein normales Feld.
Jetzt habe ich im GCC-Tutorial nachgeguckt, werd aber daraus nicht 
schlau.
Was genau ist das eeFooByteArray und was lese ich auf dieses 
eeFooByteArray aus?
Meine Variable, die ich schreiben möchte, ist myByteBuffer, oder? Warum 
wird da dann nach dem Schreiben ins EEPROM wieder was ausgelesen?
Werd aus den Comments dort auch nicht schlau.

jens

[Karl H. (kbuchegg)]

jens schrieb:
> hey
>
> müsste ein HeaderFile im EEPROM meines AtMega32 ablegen.

Das glaub ich .... nicht.

Ich glaube nicht, das du ein Header File  IM  EEPROM eiens AtMega32 
speichern willst.

> Jetzt habe ich im GCC-Tutorial nachgeguckt, werd aber daraus nicht
> schlau.
> Was genau ist das eeFooByteArray und was lese ich auf dieses
> eeFooByteArray aus?

Du solltest vielleicht den Abschnitt EEEPROM von Anfang an lesen und 
auch ein wenig hin und her scrollen. Manchmal beziehen sich einzelne 
Teilabschnitte aufeinander

uint8_t eeFooByteArray1[] EEMEM = { 18, 3 ,70 };

definiere ein Feld namens eeFooByteArray1. Dieses Feld liegt nicht im 
SRAM, so wie alle anderen Variablen, sondern es möge irgendwo im EEPROM 
angeordnet werden (daher das EEMEM)

und das auslesen passiert hier

myByte = eeprom_read_byte(&eeFooByteArray1[1]);

Lies 1 Byte von der Speicheradresse, die definiert ist als das 1 
Arrayelement von eeFooByteArray1


> Warum
> wird da dann nach dem Schreiben ins EEPROM wieder was ausgelesen?

Wo denn.
Könnte es sein, dass es sich um ein Tutorial handelt, das neben dem 
Schreiben von Werten auch das Auslesen von Werten zeigt. Und das 
vielleicht sogar in ein und demselben Programm?

[Jörg W. (dl8dtl) (Moderator)]

jens schrieb:

> müsste ein HeaderFile im EEPROM meines AtMega32 ablegen.

Warum das, willst du auf dem armen ATmega32 etwa einen GCC laufen
lassen?

> Was genau ist das eeFooByteArray

Letztlich weiter nichts als eine Platzhalter-Definition, damit der
Linker in der section .eeprom den notwendigen Platz einräumt und dir
ein Symbol definiert, das die Anfangsadresse (im EEPROM) bezeichnet.
Außerdem füllt der Linker die Initialisierungsdaten (die du vermutlich
in deinem Headerfile angibst) ins object file, von wo aus du sie
mittels avr-objcopy extrahieren und mit deinem Programmer in den
EEPROM laden kannst, wenn du willst.

> und was lese ich auf dieses
> eeFooByteArray aus?

Die Initialisierungsdaten, wenn du sie denn auf diese Weise
hingeschafft hast, oder die später geänderten Daten (es wird ja einen
Grund haben, warum du sie in den EEPROM legen willst).

> Meine Variable, die ich schreiben möchte, ist myByteBuffer, oder?

Zum Beispiel, oder auch ganz anders -- woher sollen wir das denn
wissen, wie du deine Varaiblen nennst?

> Warum
> wird da dann nach dem Schreiben ins EEPROM wieder was ausgelesen?

Weil die CPU die Daten im RAM (oder in einem Register) braucht, um was
damit anfangen zu können, und weil der Zugriff darauf nicht über eine
normale Speicheradresse erfolgt (*), sondern über ein paar Aktionen
auf zwei IO-Registern.  Allerdings sagt natürlich niemand, dass du das
ganze Array auf einmal in den RAM lesen musst, du kannst das auch in
beliebig kleinen Teilstücken machen.

(*) Der Xmega kann optional auch memory-mapped den EEPROM lesen, dann
könntest du das rücklesen auch beliebig mit einem Zeiger machen.
Dauert halt nur einen Takt länger als beim RAM.

[Gerhard (Gast)]

Ein bisschen am Original-Poster vorbei, wenn ich mir im Tutorial das 
Beispiel mit der Union anschaue, macht das hier wirklich Sinn, die Float 
Variable in eine Union zu packen?

Würde nicht:

  float myFloat = 12.34;
 
  float r;
 
   r = myFloat;
   
   /* float in EEPROM */
   eeprom_write_block(&r,&eeFooFloat,sizeof(float));
 
   /* float aus EEPROM */
   eeprom_read_block(&r,&eeFooFloat,sizeof(float));
   /* r wieder 12.34 */

genau so funktionieren?

Gerhard

[jens (Gast)]

Karl heinz Buchegger schrieb:
> Ich glaube nicht, das du ein Header File  IM  EEPROM eiens AtMega32
> speichern willst.
Das war jetzt falsch ausgedrückt. In meiner Header- Datei ist ein Feld 
und das möchte ich ein den EEPROM speichern.

Karl heinz Buchegger schrieb:
> uint8_t eeFooByteArray1[] EEMEM = { 18, 3 ,70 };
Und was bedeuten hier die Zahlen? Habe gerade dieses Tutorial 
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Bytes_lesen.2Fschreiben
durchgelesen, da steht nichts zu den Zahlen.

Die Vorgangsweise ist also, einen Platzhalter zu definieren und dann 
kann schon das Schreiben folgen?

Und noch eine Frage: Wenn ich mein Feld aus der HeaderDatei ins EEPROM 
speichern will, schreibe ich den Code dazu dann auch in das HeaderFile?

jens

[Michael R. (dj_motionx)]

Hallo Jens.
Ich rate mal du willst genau das gleiche machen wie ich gestern abend 
gemacht hab ;-). Ich denke mal du willst einfach ein großes Array 
dauerhaft im EEPROM ablegen. Das speichern eines *.h files im EE macht 
für mich auch wenig Sinn. Hier meine Lösung:

1. Ich lege mein Array so an, dass der compiler einen Speicherbereich im 
EE resaviert. A la tutorial:

 unsigned char eeMem[EESIZE] EEMEM;

In meinem Fall fülle ich mit meinem Array das ganze EEPROM aus und 
"zwinge" den Compiler dazu dass mein 0. Arrayelement auch an der Adresse 
0 im EE liegt.

2. In einer initialisierungsroutine beschreibe ich mein Array im EE 
einmal. Alle Arraybytes werden mit folgender funktion ins EEAray 
geschoben.

void EEWriteByte(uint16_t Address, uint8_t Data) {
  eeprom_write_byte(eeMem+Address,Data);
}

Nach dem Vorgang kann die Initfunktion auskommentiert werden, die daten 
sind ja jetzt nicht flüchtig im EE.

3. Zugriff auf die Arraydaten erfolgt mit Funktion:

 
uint8_t EEreadByte(uint16_t Address) {
  return eeprom_read_byte(eeMem+Address);
}

L.g. Michi

[Michael R. (dj_motionx)]

jens schrieb:
> Und was bedeuten hier die Zahlen?

Die Zahlen in den geschwungenen Klammen sind die Initialisierungswerte 
für das Array. Siehe standard C Kapitel Arrays.

jens schrieb:
> Und noch eine Frage: Wenn ich mein Feld aus der HeaderDatei ins EEPROM
> speichern will, schreibe ich den Code dazu dann auch in das HeaderFile?

Nein. Codedefinitionen kommen grundsätzlich nicht in die Headerdatei. 
Mach dir ein kleines Modul. eeprom.c und eeprom.h und da kommen die 
EEPROM zugriffsfunktionen hinein.

Rest der erklärung siehe mein vorheriger post.

L.g. Michi