Wie speichere ich verschiedene Variablen in ein "Array" von Bytes

[Master S. (snowman)]

Hallo zusammen

Ich verwende den XC32 im Zusammenhang eines PIC32. Ich habe wiedermal 
Mühe, was der Compiler macht:

typedef struct {
    unsigned char timeH;
    unsigned char timeM;
    unsigned char weekdays;
    unsigned int W;
    unsigned int R;
    unsigned int G
    unsigned int B;
    unsigned char power;
} LightElement;

- "sizeof LightElement" ist ageblich 24
- jedoch 0xA00044B4 - 0xA00044A0 = 0x14 = 20 (siehe Attachment)
- LightElement hat aber nur 12 Bytes Nutzdaten

Das verstehe ich mal nicht, muss es aber so hinnehmen.


Eigentlich habe ich ein höheres Ziel: Ich habe verschiedene solcher 
strucs, die ich in einer Page (256 Bytes) eines EEPROMs abspeichern 
möchte. Ich möchte gleich eine ganze Page schreiben und nicht 
"Bytemanipulatorisch". Das heisst es wäre schön wenn ich ein 
übergeordneter "Container" hätte, der genau 256 Bytes gross ist (und 
auch 256 Bytes Nutzdaten hätte), den ich dann in einer Page ablegen 
könnte. Ich hatte an sowas gedacht, was aber (siehe oben) nicht 
funktioniert.

typdef struct {
  ...
} StructA; // 64 Bytes gross

typdef struct {
  ...
} StructB; // 64 Bytes gross

typdef struct {
  ...
} StructC; // 64 Bytes gross

typdef struct {
  ...
} StructD; // 64 Bytes gross


struct {
   StructA ElementA;
   StructB ElementB;
   StructC ElementC;
   StructD ElementD;
} StructAllesZusammen; // 256 Bytes gross

Frage: Wie mache ich das am besten und leserlichsten, dass ich innerhalb 
des Programms (code) auf die einzelnen Variablen zugreiffen kann und 
diese doch in einem 256 Byte grossen Array sind?

Vielen Dank für Tips

[Bitflüsterer (Gast)]

#pragma packed

[Marc S. (marc_s86)]

Bitflüsterer schrieb:
> #pragma packed

http://www.catb.org/esr/structure-packing/

hier noch die Erklärung dazu

es gibt noch die Möglichkeit nur einzelne structs zu packen:

struct my_struct { 
uint8_t field1; 
uint16_t field2; 
} __attribute__((packed));

http://digitalvampire.org/blog/index.php/2006/07/31/why-you-shouldnt-use-__attribute__packed/

[Master S. (snowman)]

OK, vielen Dank - habe wieder was gelernt :-)

[S. R. (svenska)]

Zu deinem LightElement:
- Sortiere mal die drei "unsigned char" an das Ende der Struktur. Das 
spart dir vermutlich dreimal Padding ein, ohne Tricksereien.
- Wie kommst du auf 12 Bytes Nutzdaten? Auf einer 32-Bit-Plattform 
sollte ein "unsigned int" 32 Bit = 4 Byte haben, und damit wären das 20 
Bytes Nutzdaten. Dann passt das auch mit dem sizeof von 24 Bytes (ein 
Padding-Byte hinter jedem unsigned char).

[Markus D. (mowlwurf)]

Master Snowman schrieb:
> Frage: Wie mache ich das am besten und leserlichsten, dass ich innerhalb
> des Programms (code) auf die einzelnen Variablen zugreiffen kann und
> diese doch in einem 256 Byte grossen Array sind?

Ich würde es mit einer union machen:

typedef union
{
   unsigned char aucBuffer[256];
   struct {
     LightElement ElementA;
     LightElement ElementB;
     LightElement ElementC;
     LightElement ElementD;
   } StructAllesZusammen;
} MeineUnion;

Grüße,
Markus

[Master S. (snowman)]

@ S. R.: ja du hast recht, ich habe int als 2 Bytes gerechnet (anstatt 4 
Bytes)
@ Markus D.: funktioniert das dann auch, wenn der struct 
zugriffsoptimiert im RAM liegt und nicht speicheroptimiert? (letzteres 
wird ja vom Compiler per default gemacht)

[Markus D. (mowlwurf)]

Da ich den XC32-Compiler nicht kenne, kann ich dir die Frage leider 
nicht beantworten.
Beim GCC ist es so, dass eine globale Variable vom Typ MeineUnion in der 
.data section landet und damit zugriffsoptimiert im RAM liegt.

Ich verstehe auch nicht so ganz, was du mit "speicheroptimiert" meinst.

Grüße,
Markus