verschiedene

[Leon (Gast)]

hallo liebe leut
ich habe mehrere structs [in c], welche ich im eeprom speichern möchte.
Jetzt habe ich bisher für jede structur eine neue Funktion gemacht.
z.B.

void writeParam(struct1 const* param, uint32 address)
{
  struct
  {
    uint16 checkSumme;
    uint16 free;
    struct1 param;
  }write;
  
  write.param = *param;
  write.free = 0xFFFF;
  write.checkSumme = calcChecksumme((uint8*)&write.param, sizeof(write.param));
  
  eepromWrite(adress, (uint8*)&write, sizeof(write))
}

gleiches für struct2, struct3 and struct4
Diese Structuren sind komplett unterschiedlich

Gibt es da einen weg, nur eine Funktion für verschiedene structuren zu 
benutzen?

Habe es versucht mit

void writeParam(void const* param, uint16 address)

Aber dann habe ich probleme mit der structur (write) in der funktion.

[Wegstaben V. (wegstabenverbuchsler)]

mach dir mal Gedanken über den Betreff deines Beitrages, insbesondere ob 
du damit die von dir angestrebte Zielgruppe adressieren kannst.

[wendelsberg (Gast)]

Leon schrieb:
> ich habe mehrere structs [in c], welche ich im eeprom speichern

Eeprom PC ?

wendelsberg

[Teo D. (teoderix)]

wendelsberg schrieb:
> Eeprom PC ?

BIOS!

[S. R. (svenska)]

Du musst sowohl den Zeiger auf die struct als auch die Länge der struct 
mit übergeben, dann kann deine Funktion die Inhalte übergeben.

Der Prototyp sieht dann so aus:

void writeParam(void* param, size_t size, uint32_t address);

Innerhalb von writeParam() darfst du dann natürlich nirgends mehr ein 
"struct1" oder so stehen haben. Das heißt, deine temporäre Struktur 
kannst du irgendwie so zusammenbauen:

void writeParam(void* param, size_t size, uint32 address)
{
  __attribute__((packed)) struct s_write
  {
    uint16 checkSumme;
    uint16 free;
    uint8_t param[];
  };

  size_t writesz = size + 4;
  struct s_write* write = (struct s_write*)alloca(writesz);
  
  memcpy(&write->param, param, size);
  write->free = 0xFFFF;
  write->checkSumme = calcChecksumme((uint8_t*)param, size);
  
  eepromWrite(adress, (uint8*)write, writesz)
}

Bugs sind meine, ich hab den Code hier im Forum geschrieben. Betrachte 
es als Ideengrundlage. :-)

[A. S. (Gast)]

Leon schrieb:
> write.param = *param;
>   write.free = 0xFFFF;
>   write.checkSumme = calcChecksumme((uint8*)&write.param,
> sizeof(write.param));
>
>   eepromWrite(adress, (uint8*)&write, sizeof(write))

Ich vermute Du möchtest malloc vermeiden. Dann mach dir Gedanken 
eepromWrite neu zu schreiben oder zu wrappen. Es macht wenig Sinn, ein 
Datenfeld unbekannter Größe an ein paar Bytes zu pappen. Übergibt die 
beiden Parameter einfach mit.