EEPROM Struct mit read und write block kopieren?

[Vorn N. (lufthackn)]

hallo,
ich möchte z.B. nur die Struktur "Bar[1]" einer grossen Struktur ins 
EEPROM schreiben ohne immer die gesamte Strukur kopieren zu müssen.

Meine Struktur:

typedef struct
  {
    struct
      { int32_t foo   ; // Foo Struct Member
        int32_t bar   ; // "
        int32_t baz   ; // "
      } Foo           ; // 
    struct
      { char foobits:2, // Bar Struct Member
             barbits:2, // "
             bazbits:4; // "
      } Bar[10]       ; // Array aus 10 mal Bar Struktur
  } Speicherdaten     ; //

Speicherdaten RAM_Data      ; // RAM_Data = Struktur im RAM
Speicherdaten EEP_Data EEMEM; // EEP_Data =Struktur im EEPROM

Am Anfang wird die komplette Struktur aus dem eeprom ins ram geladen...

eeprom_read_block(&RAM_Data,&EEP_Data,sizeof(Speicherdaten));

das klappt scheinbar auch.

Um nun nur die "Foo" Struktur ins EEPROM zu schreiben benutze ich 
folgende Codezeile:

eeprom_write_block(&RAM_Data,&EEP_Data,sizeof(((Speicherdaten*)0)->Foo));

klappt ebenfalls, allerdings nicht mit der Array-Struktur "Bar"...

eeprom_write_block(&RAM_Data,&EEP_Data,sizeof(((Speicherdaten*)0)->Bar[1]));

Ergebniss, die Struktur "Bar[1] wird scheinbar nicht gespeichert.
mach ich einen fehler beim write block zugriff auf die array struktur 
oder soll ich den fehler woanders suchen?

ps, ich bin kein mensch der sich alles gern alles vorkauen lässt, aber 
da ich die eeprom write block codezeile mit dem
-> und den sternchen^^ und so nicht ganz kapiere werde ich hier wohl 
nich zu potte kommen, ist irgendwie frustrierend...

liebe grüsse, Lufthackn

[Karl H. (kbuchegg)]

Vorn Nachn schrieb:

> Meine Struktur:
>

> typedef struct
>   {
>     struct
>       { int32_t foo   ; // Foo Struct Member
>         int32_t bar   ; // "
>         int32_t baz   ; // "
>       } Foo           ; //
>     struct
>       { char foobits:2, // Bar Struct Member
>              barbits:2, // "
>              bazbits:4; // "
>       } Bar[10]       ; // Array aus 10 mal Bar Struktur
>   } Speicherdaten     ; //
> 
> Speicherdaten RAM_Data      ; // RAM_Data = Struktur im RAM
> Speicherdaten EEP_Data EEMEM; // EEP_Data =Struktur im EEPROM
>

> Um nun nur die "Foo" Struktur ins EEPROM zu schreiben benutze ich
> folgende Codezeile:
>

> eeprom_write_block(&RAM_Data,&EEP_Data,sizeof(((Speicherdaten*)0)->Foo));
>

> klappt ebenfalls, ...

sei hier ein bischen expliziter. Das geht davon aus, dass der Foo Anteil 
in der struct Speicherdaten am Anfang liegt. Es schadet nichts, wenn man 
an dieser Stelle explizit hinschreibt was man haben möchte und nicht 
implizit durch die Längensteuerung das Gewünschte erreicht.

  eeprom_write_block( & RAM_Data.Foo,
                      & EEP_Data.Foo,
                      sizeof( RAM_Data.Foo ) );

> allerdings nicht mit der Array-Struktur "Bar"...
>

> eeprom_write_block(&RAM_Data,&EEP_Data,sizeof(((Speicherdaten*)0)->Bar[1]));
>

siehst du. Hier hast du dich mit dem vorhergehenden selbst ausgetrickst, 
indem du dort einen Zusammenhang ausgenutzt hast, den du hier nicht mehr 
benutzen kannst.
Bist du hier aber genauso explizit, fügt sich eines ganz natürlich zum 
anderen

  eeprom_write_block( & RAM_Data.Bar[1],
                      & EEP_Data.Bar[1],
                      sizeof( RAM_Data.Bar[1] ) );

> da ich die eeprom write block codezeile mit dem
> -> und den sternchen^^

Das sind Pointer.
Und in deinem speziellen Fall völlig unnötig. Das kann man auch ganz 
logisch ohne so ein windiges Konstrukt schreiben.

  write_block will:

           Adresse von wo
           Adresse wohin
           Wieviele Bytes

das ist mehr oder weniger alles.
Der Rest (mit den Sternchen und so) findet sich in jedem C Buch

[Peter D. (peda)]

Ich schreibe immer die gesamte Struktur.
Mein Trick ist aber, daß meine Schreibroutine erst prüft, ob ein 
Schreiben notwendig ist:

http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=91306

Obendrein ist der Code auch deutlich schlanker als die GCC-Funktionen, 
die sich irgendwann extrem aufgebläht haben (indirekter Call).


Peter

[Vorn N. (lufthackn)]

Karl heinz Buchegger schrieb:

> ...Pointer.
> Und in deinem speziellen Fall völlig unnötig. Das kann man auch ganz
> logisch ohne so ein windiges Konstrukt schreiben.
>
>   write_block will:
>
>            Adresse von wo
>            Adresse wohin
>            Wieviele Bytes
>

>

>   eeprom_write_block( & RAM_Data.Bar[1],
>                       & EEP_Data.Bar[1],
>                       sizeof( RAM_Data.Bar[1] ) );
>

> das ist mehr oder weniger alles.
> Der Rest (mit den Sternchen und so) findet sich in jedem C Buch

Oi, vielen dank herr buchverkäufer^^


@ H.Danneger,

mal sehn wie ich das jetzt handhabe und wie oft ich die codezeile 
schreiben muss..., sollte sich eine Funktion zum speichern anbieten 
werde ich mir das mal genauer angucken.

liebe grüsse