Array mit AVR Studio fest in den EEPROM brennen

[Thomas S. (thomass)]

@all,

ich versuche ein Array fest in den EEPROM zu brennen.
In diesem Array sind Daten abgelegt die nach dem Abschalten wieder 
verfügbar sein sollen.
Leider habe ich es noch nicht geschaft den EEPROM direkt mit den Daten 
zu brennen. Schreibend und lesend auf den EEPROM zuzugreifen mit den 
Funktionen von eeprom.h eeprom_read_byte und eeprom_write_byte 
funktioniert jedoch die Daten direkt mit AVR Studio draufzuschreiben 
scheidert kläglich.
Ich habe die Beschreibung

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#EEPROM-Speicherabbild_in_.eep-Datei
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Exkurs:_Makefiles

schon mehrmals gelesen doch verstehen tu ich es nicht so recht zumindest 
nicht was ich einstellen muss um eine eep Datei zu erhalten.

Ich benutze folgendes.

- AVR Studio 4.13 mit AVR Gcc
- einen MK 2 zum programmieren
- einen ATMEGA 128

Ich hoffe mir kann jemand sagen was ich unter AVR Studio einstellen 
muss.

Danke

Thomas

[Niels H. (monarch35)]

Du definierst ein Array z.B.

uint8_t test[] EEMEM="test";

Wenn du die Quelle kompilierst, kommt unter anderem eine .eep Datei 
herraus, die du mit avrdude, oder was auch immer, direkt in das EEPROM 
des Kontrolers flashen kannst.

Das Auslesen des EEProms funktioniert dann über die von dir genannten 
Funktionen. Entweder liest du es Byte-für-Byte aus und behandelst jedes 
Zeichen einzeln oder du liesst dir die Zeichenkette erstmal komplett in 
einen Buffer im SRAM.

Direkt darauf zuzugreifen funktioniert allerdings nicht.

[Fred S. (Gast)]

Hallo Thomas,

Deine Frage ist mir nicht 100% klar, da Du sowohl das Erzeugen der 
*.eep-Datei als auch das eigentliche Brennen ansprichst.

Sofern Deine *.c bzw. *.asm Datei so angelegt ist, dass EEPROM-Daten 
definiert sind, erzeugt AVR-Studio auch die zugehörige *.eep Datei (z.B. 
im Unterordner "default").

Hier ein Beispiel aus meinem aktuellen Projekt in C:

///////////////////////////////////////////////
// 2 Float-Werte werden ins EEPROM geschrieben
// EEPROM data

float eelat   EEMEM = 53.5;
float eelongit   EEMEM = 13.3;
///////////////////////////////////////////////

Je nach Programmierer-Hardware muss dann eingestellt werden, welche 
*.eep-Datei gebrannt werden soll. Manche Programmiersoftware kann auch 
die *.elf-Datei mit allen Definitionen übernehmen.

Viele Grüße

Fred

[Thomas S. (thomass)]

@Niels,

Danke für Deine schnelle Antwort.

Ich glaube ich habe das Übel gefunden was nicht funktioniert.

Ich initialisiere 2 Arrays wie folgt eines im EEPROM eines im RAM.

unsigned char eeFooByteArray1[5][5] EEMEM =  {
                                              {0x01,0x01,0x01,0x01,0x01},
                                              {0x02,0x02,0x02,0x02,0x02},
                                              {0x03,0x03,0x03,0x03,0x03},
                                              {0x04,0x04,0x04,0x04,0x04},
                                              {0x05,0x05,0x05,0x05,0x05},
                                             };
unsigned char eeFooByteArray2[5][5] =  {
                                        {0x00,0xFF,0x00,0xFF,0x00},
                                        {0x00,0xFF,0x00,0xFF,0x00},
                                        {0x00,0xFF,0x00,0xFF,0x00},
                                        {0x00,0xFF,0x00,0xFF,0x00},
                                        {0x00,0xFF,0x00,0xFF,0x00},
                                       };

Nun lese ich eeFooByteArray2 ein und gebe die Werte per printf aus alles 
OK.
Nun schreibe ich die Werte von Array eeFooByteArray1 ins Array 
eeFooByteArray2.

eeFooByteArray2 [r][i] = eeprom_read_byte(&eeFooByteArray1[r][i]);

Lese ich nun das Array eeFooByteArray2 aus stehen zwar geänderte Werte 
im Array jedoch nicht die von eeFooByteArray1.

Nun schreibe ich die ausgelesenen Werte zuerst in eine Variable und 
speichere diese dann in eeFooByteArray2 dann stimmen die Werte.

t = eeprom_read_byte(&eeFooByteArray1[r][i]);
eeFooByteArray2 [r][i] = t;

Verstehen kann ich dies nicht, eventuell hat es etwas mit der Funktion 
zu tun.

Gruß

Thomas

[Thomas S. (thomass)]

@Fred,

ja die eep Datei wird erzeugt da aber die Werte nie stimmten dachte ich 
das die eep Datei nicht richtig erzeugt wird jedoch lag es am auslesen 
siehe OBEN.

Thanks


Thomas

[Fred S. (Gast)]

Versuch's doch mal mit

eeprom_read_block(
 (void *)&eeFooByteArray2, (const void *)&eeFooByteArray1, 25 );

Gruß

Fred

[Niels H. (monarch35)]

Thomas S. wrote:

>

> t = eeprom_read_byte(&eeFooByteArray1[r][i]);
> eeFooByteArray2 [r][i] = t;
>

Das holen von Adressen eines einzelnen Elementes aus einem 
Zweidimensionalen Array ist ätzend. Die Pointer-Arythmetik, die sich 
dahinter verbirgt habe auch ich nie verstanden, jedenfalls hab ich sie 
auch nie sauber zum funktionieren gebracht, wenn man es, so wie du es 
gemacht hast, logisch ausschreibt.

 Ich habe allerdings positive erfahrungen mit einfachen Adresszählern 
gemacht:

uint8_t idx=0;
for (x=0;x<5;x++)
{
    for (y=0;y<5;y++)
    {
        t=eeprom_read_byte((&eeFooByteArray1)+idx);
        idx++;
    }
}