Warning bei eeprom_write_word und eeprom_read_word

[Sebastian F. (sebbi99)]

Hallo zusammen,
ich habe eine Frage zu den Lese- und Schreibfunktionen des EEPROMs. 
Aktuell habe ich die Speicheradresse für das EEPROM in einer uint16_t 
gespeichert und übergebe diese an die eeprom_write_word und 
eeprom_read_word. Das funktioniert auch, allerdings wirft der Compiler 
ein Warning, dass er einen Pointer erwartet und keinen Integer Wert 
(siehe Anhang). Ich habe leider keine Ahnung, wie ich die 
Speicheradresse als Pointer übergeben kann. Hat da vielleicht jemand 
eine Idee?

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

Sebastian F. schrieb:
> Ich habe leider keine Ahnung, wie ich die Speicheradresse als Pointer
> übergeben kann.

Mit einem typecast.

Übrigens kann man textuelle Meldungen auch ganz ohne Screenshots mit 
copy&paste zitieren. ;-)

[Sebastian F. (sebbi99)]

Vielen Dank für die schnelle Antwort:)
Folgendes habe ich bereits probiert, allerdings wird mir da der selbe 
Fehler angezeigt.

uint16_t adress = 0x00;
uint16_t *p_adress = &adress;
uint16_t value = 0;

value = eeprom_read_word(*p_adress);

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

Wie wäre es einfach mit

value = eeprom_read_word((uint16_t *)42);

um etwas von EEPROM-Adresse 42 zu lesen?

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

Sebastian F. schrieb:
> value = eeprom_read_word(*p_adress);

Das hätte übrigens mit

value = eeprom_read_word(p_adress);

funktioniert, denn dann übergibst du wieder einen Zeiger. So aber 
dereferenzierst du den Zeiger wieder, womit du auf dessen Inhalt 
zugreifst. Das ist nicht, was du willst.

Aber die Zwischenvariable ist schlicht nicht nötig.

Die Idee, warum diese Funktionen Zeiger nehmen und keine Zahlen ist, 
dass man EEPROM-"Variablen" anlegen kann:

uint16_t some_eeprom_value EEMEM;

// ...

    uint16_t current_val = eeprom_read_word(&some_eeprom_value);

In diesem Falle überlässt man Compiler und Linker die tatsächliche 
Adressaufteilung des EEPROMs.

[Sebastian F. (sebbi99)]

?‍♂️ es kann manchmal so einfach sein...
Vielen Dank für die schnelle Lösung meines Problems!

[Einer K. (Gast)]

Oder so (falls AVR):
(das EEMEM Makro ist schnell gebaut, wenn dein System das nicht kennt)

uint16_t eeprom_read_word(uint16_t *dummyptr) // dummyfunktion
{
  (void)dummyptr; 
  return 42; 
}

uint16_t imEeprom EEMEM = 4711; // section .eeprom / landet in *.eep
uint16_t imRam = 0 ;


int main() 
{

  imRam = eeprom_read_word(&imEeprom);
}

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

Wenn man allerdings Wert auf eine bestimmte Reihenfolge der Elemente im 
EEPROM legt (weil man sie beispielsweise auch von außen über den 
Programmer lesen oder modifzieren können möchte), dann ist es das 
sinnvollste, dass man alle EEPROM-Daten in einer einzigen Variablen als 
struct hinterlegt. Ansonsten kann einem der Linker die Adressen 
irgendwie nach seinem Gusto sortieren.

[Einer K. (Gast)]

Jörg W. schrieb:
> Ansonsten kann einem der Linker die Adressen
> irgendwie nach seinem Gusto sortieren.
Ja, das tut er.

Jörg W. schrieb:
> in einer einzigen Variablen als struct
Dafür wurde offsetof() erfunden, um dann noch einzelne Werte da raus 
picken zu können.


Ansonsten:
Ich spreche mich klar gegen das händische berechnen der EEPROM Adressen 
aus.
Denn Kompiler und Linker machen da keine Flüchtigkeitsfehler.
Menschen schon.
Auch hat die gewonnene Typsicherheit einiges an Vorteilen gegenüber 
Pointercasts.

Mantra:
> Jeder vermeidbare Cast, ist ein böser Cast.
> Jeder vermiedene Cast, ist ein guter Cast.