AVR: Array(s) im EEPROM auf feste Adressen legen

[D. E. (stb)]

Hallo,

ich habe folgendes Problem, ich habe 2 Arrays im EEPROM ligen, die ich 
später außerhalb des AVR modifizieren möchte/muss. Dazu übetrage ich das 
gesamte EEPROM (Mega64 2kByte) via USB Feature Report auf einen PC.

Um jetzt die richtigen Bytes der Arrays zu erwischen müsste ich im 
Quellcode für den AVR festlegen ab welcher Speicherstelle im EEPROM die 
jeweiligen Arrays liegen.

Hat jemand einen Tip, wie man das bewerkstelligen könnte?

Auf dem AVR möchte ich weiterhin mit eeprom_read_byte(&data[]) auf meine 
Daten zugreifen.

Grüße

STB

[... .. (docean)]

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#EEPROM-Variable_auf_feste_Adressen_legen

[D. E. (stb)]

Danke, prinzipiell könnte ich es so machen, allerdings sind die beiden 
Arrays relativ groß. Zu allem Übel enthalten sie auch noch default 
Werte.

Hier ein Beispiel:

unsigned char KeyboardeePROM[35][5] EEMEM ={                                                            
                                              {0x15, 0x15, 0x15, 0x15, 0x15},
                                              {0x52, 0x52, 0x52, 0x52, 0x52},
                                              {0x09, 0x09, 0x09, 0x09, 0x09},
                                              {0x51, 0x51, 0x51, 0x51, 0x51},
                                              {0x07, 0x07, 0x07, 0x07, 0x07},  
                                              {0x50, 0x50, 0x50, 0x50, 0x50},
                                              {0x0A, 0x0A, 0x0A, 0x0A, 0x0A},
                                              {0x4F, 0x4F, 0x4F, 0x4F, 0x4F},
                                              ...}
                                            };

So wie ich das sehe hilft mir das Tutorial da nicht recht weiter oder es hat einfach bei mir noch
nicht klick gemacht...

STB

[Matthias L. (Gast)]

Beitrag "AVR: Problem mit eeprom_read_byte()"

[D. E. (stb)]

Hi !

Das hat mit meinem Problem nichts zu tun, EEPROM auslesen im AVR ist 
kein Problem. Ich will die Daten ausserhalb des AVRs modifizieren, dazu 
muss ich festlegen können wo genau im EEPROM die Daten stehen, damit 
nich bei jedem neu compilieren der AVR Soft. die Adressen in der 
(Windows-) Anwendung geändert werden müssen.

Trotzdem Danke für den Link.

STB

[Matthias L. (Gast)]

>wo genau im EEPROM die Daten stehen

Ja. Geanu darum geht es doch dort. Variablen an fester Adresse im 
EEPROM.

[D. E. (stb)]

Nein, das ist nicht mein Problem. Ich will festlegen abe welcher Adresse 
das Array im EEPROM steht. Natürlich steht das Array im EEPROM immer an 
der gleichen festen Adresse nach dem Compilieren aber diese kann sich 
nach Änderungen am Code und Neukompilierung ändern, dieses möchte 
ich/muss ich verhindern.

Vielleicht bin ich auch nur Blind, wie wäre es mit einem etwas 
aussagekräftigeren Zitat?


Grüße

STB

[Matthias L. (Gast)]

>Vielleicht bin ich auch nur Blind, wie wäre es mit einem etwas
>aussagekräftigeren Zitat?

Ja. bist du. So sollte das gehen:

Strukturtype  Name;

...
//-- für XXX die (feste) Startadresse im EEPROM eintragen
eeprom_read_block(&Name, (uint8_t*)XXX, sizeof(Name) );

[D. E. (stb)]

So blind bin ich dann doch nicht.

So kann man aus festen Adressen im EEPROM lesen, das ist (auch mir) 
nicht neu.

Vielleicht erkläre ich es falsch, ich möchte einem Array mit Name 
"KeyboardeePROM[35][5]" an einer von mir zur Compilierzeit gewählten 
Adresse ablegen. Wie ich das auslese weiss ich.

Der Ansatz aus dem Tutorial s. Zitat von "docean" löst mein Problem 
eigentlich, bis auf die (komfortable) Initialisierung des Arrays.

Grüße

STB

[Henning (Gast)]

Genau das gleich suche ich im Moment auch.

Ziel ist, die Adresse der Daten im Eprom nicht durch dn Kompiler zu 
vergeben. Diese kann schließlich von Programmstand zu Programmstand 
unterschiedlich sein.

uint16_t eeData EEMEM = 1000;

Die 1000 ist dabei der Initialwert (Speicherinhalt), aber die Adresse 
wird vom Compiler verteilt.

Sondern der Compiler soll eine bestimmt Adresse von mir definiert 
bekommen.
Dabei ist aber natürlich wichtig, das der Kompiler die adresse nachher 
nicht nochmal verteilt, und dann zwei Daten nur einer Zelle zugeteilt 
sind.

Vielleicht hat jemand einen Tipp?

Grüße Henning

[Wolfgang (Gast)]

Hallo,

damit habe ich mich auch schon rumgeschlagen. Also: man packt das Array 
in eine extra memory section (z.B. my_eeprom) und weist dieser eine 
Adresse im Linker zu.

Leider hat AVR Studio einen Bug an dieser Stelle: wenn man in project 
settings diesen Speicher anlegt, wird das nicht richtig zum makefile 
durchgereicht. Man muß also das makefile manuell editieren und unter 
anderem Namen abspeichern und dann in den project-settings auf custom 
makefile umschalten.

Servus Wolfgang
www.opendcc.de

[Johann L. (gjlayde)]

Henning wrote:
> Genau das gleich suche ich im Moment auch.
>
> Ziel ist, die Adresse der Daten im Eprom nicht durch dn Kompiler zu
> vergeben. Diese kann schließlich von Programmstand zu Programmstand
> unterschiedlich sein.
>
> uint16_t eeData EEMEM = 1000;
>
> Sondern der Compiler soll eine bestimmt Adresse von mir definiert
> bekommen.

Der Compiler vergibt keine Adressen.

> Vielleicht hat jemand einen Tipp?

Die Adressen macht der Linker. Ergo: Nicht via EEMEM (aka. section 
.eeprom oder so) lokatieren, sondern ne eigene Section anlegen und die 
im Linker-Script beschreiben.

Falls es nur um 1 Object geht, weiß man, daß es an Adresse 0 liegt, weil 
der Linker bei der kleinsten Adersse anfängt.

Falls man doch mit nem ld-script arbeiten will, darauf achten, nicht die 
physikalischen Adressen zu verwenden, sondern (wegen 
Harvard-Architektur) die logischen.

Wenn auf mehrere Objekte so zugegriggen werden soll, dann braucht jedes 
seine eigene Section. Oder man packt alles in einen großen EEPROM-Strukt 
(so mach ich das) und hat damit wieder nur 1 Objekt.

Alternativlösung: Die Adresse ausm map-File rausgreppen und in dem 
externen Tool verwenden.

[Telefonfritze (Gast)]

Oder den AVR dem externen Tool die Anfangsadresse uebermitteln lassen...

Telefonfritze