Unions in C

[Mike R. (thesealion)]

Moin,

angenommen ich habe folgende Strukturen

struct dummy
   {
   unsigned char foo;
   int           baa;
   float         something;
   char          many[9];
   } head;

In der Struktur sollen verschiedenste Paramter abgelegt
und diese später in einem EEPROM gespeichert werden.

Zum Speichern erzeuge ich eine Union, die mein Struktur 3fach (um Fehler 
auszuschließen) enthält und zusätzlich noch ein Array von char. Mit 
diesen
Char konnte ich bisher die Daten relativ einfach abspeichern und wieder 
laden.

union{
  struct
  {
    head            block[3];
  } dat;

  unsigned char     test[48]; 
} eeval;

Mein Problem ist jetzt, daß ich den Controller wechseln muß und der neue
ist ein 16bit Conrtoller. Also hat selbst der unsinged char eine breite 
von 16bit. Kann ich die vorherige Version auch auf einem 16bit 
Controller benutzen oder gibt es eine bessere Lösung um Daten in ein 
EEPROM (das EEPROM hat weiterhin eine Datenbreite von 8bit. zu 
schreiben?

Mike

[Christian (Gast)]

char hat wirklich eine Datenbreite von 16 Bit? Selber ausprobiert? Es 
muss doch auch einen 8-Bit-Datentyp geben. Ist "char" nicht sogar 
definitionsgemäß 8 Bit breit?

[Mike R. (thesealion)]

Die Hilfe der Programmierumgebung sagt 16 Bit. Genau ermitteln konnte 
ihc es nicht, da ich bisher nur das Programm schreiben kann. Die PLatine 
für den Conrtoller braucht noch ein paar Wochen, bis sie hier ist.

Ich hab zu char bisher nur gefunden, das er mindestens 8Bit haben muß. 
Er kann aber auch mehr haben.

[Oliver (Gast)]

>Also hat selbst der unsinged char eine breite
>von 16bit.

Wer sagt das?

Ansonsten musst du halt dafür sorgen, daß das Feld in der Union 
weiterhin genausogroß ist, wie die structs, und daß da byte-Zugriffe auf 
das eeprom stattfinden. Wie sich der 8-bit breite Datentyp dann 
allerdings nennt, wenn ein unsigned char schon 16 bit hat, musst du in 
deinem Compiler-Manual ergründen.

Ich glaub da nicht dran.

Oliver

[Willi W. (williwacker)]

Eines der Probleme in C ist ja nun mal, dass es plattformabhängig ist.

Das mit den 16 bit für ein char kann gut sein. Vielleicht kennt Dein 
Compiler ein "byte", sonst kannst du es Dir mit einem

unsigned short char

selbst eines basteln

Ciao
Helmut

[Klaus F. (kfalser)]

Du könntest sizeof(head) verwenden um ein Array anzulegen das genauso 
groß ist wie deine struct.

[Mike R. (thesealion)]

Ok,

dann werd ich mal suchen, ansonsten muß ich sehen, wie ich meine 
Strukturen am besten anpassen kann. Wenn ich dne Controller schon 
hätte, könnte ich es testen, aber ohne kann ich das Programm zwar 
schreiben und kompilieren, aber nicht starten oder debuggen :-(

Für alle, die es nicht glauben, hier ist der Auschnitt aus der Hilfe,
Alles (selbst short) hat mindestns 16Bit.

Mike

Edit:
Mein Problem ist eigentlich, das die Größe des Array vorgegeben ist und 
nur die Größe der Struktur für verschiedene Daten variieren kann. Dann 
muß ich nur noch sehen, wie ich auf die High und lowbyte eines char 
zugreifen kann um die in ein 8bit EEPROM zu packen.

[yalu (Gast)]

Ach, ein DSP. Bei denen ist es durchaus üblich, dass ein char größer
als 8 Bit ist. Aber auch wenn es nur 8 Bit groß wäre: Damit das
darauffolgende int n der Struktur nicht über eine 16-Bit-Wortgrenze
ragt, fügt der Compiler nach dem char ein (ungenutztes) Füllbyte in
ein, was die Struktur insgesamt vergrößert.

Wie Datentypen intern dargestellt werden, ist stark prozessor- und
compilerabhängig. In deinem Fall würde ich folgendermaßen vorgehen:

  struct daten_t {
    ...
  } daten;

  unsigned char *sptr;
  int i;

  // Struktur in EEPROM speichern
  sptr = (unsigned char *)&daten;
  for(i = 0; i < sizeof daten; i++) {
    write_eeprom(*sptr, i); // Datenbyte an Adresse i schreiben
    sptr++;
  }

Das sollte unabhängig von der internen Darstellung funktionieren.

Möchtest du die Anzahl der Füllbytes  und damit den belegten
Speicherplatz im EEPROM minimieren, kannst du in der
Strukturdeklaration die einzelnen Elemente nach Typgröße in
absteigender Reihenfolge sortieren, also in der Reihenfolge double,
float, int, short und char. In deinem Fall:

  struct dummy {
    float something;
    int baa;
    unsigned char foo;
    char many[9];
  } head;

Nochmal zurück zu den DSPs: Ich hatte mal einen, da war

  sizeof (double) == 1

Das hat mich zunächst arg gewundert, denn die berechneten Ergebnisse
waren etwa 7 Stellen genau =8-O, bis es mir dann wie Schuppen von den
Augen fiel (s. o.).