Arrays im Eprom platzieren

[CAnfänger (Gast)]

Hallo, ich möchte 2 Arrays a 10 Datenworte im Eeprom ablegen. Ich hab im 
Tutorial gelesen, daß ich das so definieren kann:

uint16_t werte_a[10] EEMEM
uint16_t werte_b[10] EEMEM

Ich möchte gerne, daß diese Arrays die ersten 40 Bytes meines Eeproms 
belegen  - aber wo stelle ich ein, wo (an welcher Adresse) das Array 
gespeichert wird? Gibt es wirklich nur diesen Workaround, eine Struktur 
drumherumzubauen, die so groß ist wie der gesamte EEPROM, und dann den 
Anfang der Struktur mit diesen Arrays zu füllen, oder geht es auch 
einfacher?

[Matthias L. (Gast)]

>wo (an welcher Adresse)

Warum interessiert dich das denn? Das let der Compiler doch selbst 
fest..

Falls du die trotzdem wissen willst, im map-file legt der Compiler die 
beim Compilieren festgelegten Adressen ab..

[Karl H. (kbuchegg)]

CAnfänger wrote:
> Hallo, ich möchte 2 Arrays a 10 Datenworte im Eeprom ablegen. Ich hab im
> Tutorial gelesen, daß ich das so definieren kann:
>
> uint16_t werte_a[10] EEMEM
> uint16_t werte_b[10] EEMEM
>
> Ich möchte gerne, daß diese Arrays die ersten 40 Bytes meines Eeproms
> belegen  - aber wo stelle ich ein, wo (an welcher Adresse) das Array
> gespeichert wird? Gibt es wirklich nur diesen Workaround, eine Struktur
> drumherumzubauen, die so groß ist wie der gesamte EEPROM, und dann den
> Anfang der Struktur mit diesen Arrays zu füllen, oder geht es auch
> einfacher?

Warum ist es so wichtig, wo der Compiler das im EEPROM ablegt? Wichtig 
ist doch nur, dass du die Daten wiederfindest.

Alternativ, kannst du natürlich die komplette EEPROM Verwaltung selbst 
zu Fuss machen. Letztendlich musst du ja über Spezialfunktionen auf das 
EEPROM zugreifen, denen du die Adresse übergibst, von wo bis wohin 
geschrieben/gelesen werden soll. Und diese Adresse kannst du ja selbst 
vergeben. Du musst dann halt selbst Buch führen, welche Variable wie 
gross ist und dich um die korrekte Adressvergabe kümmern.

[Johannes M. (johnny-m)]

Karl heinz Buchegger wrote:
> Alternativ, kannst du natürlich die komplette EEPROM Verwaltung selbst
> zu Fuss machen. Letztendlich musst du ja über Spezialfunktionen auf das
> EEPROM zugreifen, denen du die Adresse übergibst, von wo bis wohin
> geschrieben/gelesen werden soll. Und diese Adresse kannst du ja selbst
> vergeben.
Wenn er das EEPROM aber vorbelegen möchte, so dass es nicht jedes Mal 
bei der Initialisierung neu geschrieben werden muss (was ja auch noch 
impliziert, dass die Daten zusätzlich noch mal im Flash abgelegt sind!), 
dann geht das natürlich nicht mit den eeprom_write_XXXX-Funktionen. 
Allerdings frage ich mich auch, warum man die Adressvergabe von Hand 
machen möchte...

[CAnfänger (Gast)]

Ich möchte später verschiedene Eprom-Dateien beim Programmieren mit 
einspielen - da wär es schon praktisch, wenn die Daten auf einer 
bestimmten Adresse zu finden sind.. :-)

[Karl H. (kbuchegg)]

Da würd ichs drauf ankommen lassen :-)
Der Compiler verteilt die Daten ja auch nicht willkürlich im EEPROM, 
sondern fängt vorne an und legt sie hintereinander ab. Ich weiß, ich 
weiß. Es gibt keine Garantie dafür. Drum sag ich ja auch: Ich würds 
darauf ankommen lassen. (Oder aber die Adressrechnerei selber machen, 
ist ja auch nicht weiter schwer)

[CAnfänger (Gast)]

Ich hab mir jetzt 2 Funktionen ausgedacht - sollte das so funktionieren?


static uint16_t Werte_a[10];
static uint16_t Werte_b[10];
static uint16_t EEStartAdr EEMEM; // Annahme: Compiler beginnt am Anfang


//###########################################################
void EE_read_array()
{
  for(int i=0; i<10; i++)
  {
    Werte_a[i] = eeprom_read_word( &EEStartAdr + (i*2) );
    Werte_b[i] = eeprom_read_word( &EEStartAdr + (i*2) + 20 );
  }
}

//###########################################################
void EE_write_array()
{
  for(int i=0; i<10; i++)
  {
    eeprom_write_word( &EEStartAdr + (i*2), Werte_a[i] );
    eeprom_write_word( &EEStartAdr + (i*2) + 20, Werte_b[i] );
  }
}

[Michael A. (micha54)]

Hallo,

lege einfach ein Struct fürs eeprom an:

struct {
  uint16_t werte_a[10];
  uint16_t werte_b[10];
  uint8_t filler[236];
} eeprom EEMEM;

Gruß,
Michael

[CAnfänger (Gast)]

Und dann könnte ich einfach mit Zuweisungen wie

eprom.werte_a[3]=0xAA;

den Eprom schreiben? Wozu brauche ich dann eprom_write_word ?

[CAnfänger (Gast)]

0xAABB wäre ein natürlich besseres Beispiel...

[Johannes M. (johnny-m)]

CAnfänger wrote:
> Und dann könnte ich einfach mit Zuweisungen wie
>
> eprom.werte_a[3]=0xAA;
>
> den Eprom schreiben?
Nein, nicht mit AVR-GCC!

> Wozu brauche ich dann eprom_write_word ?
Die Funktionen brauchst Du zum EEPROM-Zugriff mit AVR-GCC immer.

[CAnfänger (Gast)]

also dann doch so, wie ich es mit den 2 Funktionen da oben gemacht habe? 
Würde das so funktionieren?

[Karl H. (kbuchegg)]

Darf ich deine Aufmerksamkeit auf die Funktion eeprom_read_block lenken?
Ideal geeignet um Arrays oder auch ganze Strukturen in einem Aufwasch zu 
lesen und zu schreiben.

[CAnfänger (Gast)]

darfst Du, danke, aber als Anfänger war ich ein bischen abgeschreckt 
davon, weil im Tutorial stand, das wär nicht geprüft.. Mir reichen 
erstmal meine eigenen Baustellen.. :-)

[Andreas V. (tico)]

CAnfänger wrote:
> davon, weil im Tutorial stand, das wär nicht geprüft.. Mir reichen

Die Warnung im Tutorial bezieht sich auf das dort abgebildete Beispiel, 
nicht auf die Funktion eeprom_read_block selbst. Die funktioniert nach 
meiner Erfahrung völlig problemlos. ;)

Gruss
Andreas