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?
>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..
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.
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...
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.. :-)
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)
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] ); } }
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
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 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.
also dann doch so, wie ich es mit den 2 Funktionen da oben gemacht habe? Würde das so funktionieren?
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.
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.. :-)
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
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.