Zeiger auf Bitfeld, 11 Bit in unsigned char Feld wandeln

[Henning S. (xtsi)]

Hallo zusammen, ich komme zu keiner schnellen sinnvollen Lösung:

Problem:

ATTiny2313, AVR-GCC, TI TLC5940 über SPI angeschlossen

Der TI möchte gerne PWM bzw DotCorrection Values in 6 bzw 12 Bit haben. 
Über SPI wird dann ein zusammenhängender Block rausgeschoben, also 96 
bzw 192 Byte.
Nun suche ich nach einer Möglichkeit, den rauszuschiebenden Block 
möglichst ohne große Umwege zu "erstellen".

void TLC5940_SPISendBuffer(unsigned char *ucBuffer, unsigned char ucLen);

Nun könnte man sich vorstellen, die Variablen als Bitfelder abzulegen, 
also z.B.

typedef struct
    {
        unsigned int uiPWMValue:12;
    } TPWMValue;

TPWMValue       g_PWM[16];

g_PWM[0].uiPWMValue = 0x0;
g_PWM[1].uiPWMValue = 0x10;

TLC5940_SPISendBuffer((unsigned char*)g_PWM, sizeof(g_PWM));

Nun kommen aber beim Zugriff immer wieder die Einzelbytes raus.

Gewünscht:

Zielbuffer[0] = 0x0
Zielbuffer[1] = 0x0
Zielbuffer[2] = 0x10

und nicht

Zielbuffer[0] = 0x0
Zielbuffer[1] = 0x10
[...]

Irgendwelche spontanen Ideen? Klar, so geht es nicht, aber irgendwelche 
Ideen, wie das schnell gemacht werden könnte?

Gruss,

Henning

[Henning S. (xtsi)]

Meinte natürlich 12 Bit im Betreff :(

[Klaus H. (Gast)]

Geht das nicht mir einer "union"?

[Henning S. (xtsi)]

Theoretisch schon, hab dann folgendes gebaut (Frei nach der 
Codesammlung, nach einigem Suchen):

union DotCorrection {
  struct Dots {
    unsigned char Dot0 : 6;
    unsigned char Dot1 : 6;
    unsigned char Dot2 : 6;
    unsigned char Dot3 : 6;
    unsigned char Dot4 : 6;
    unsigned char Dot5 : 6;
    unsigned char Dot6 : 6;
    unsigned char Dot7 : 6;
    unsigned char Dot8 : 6;
    unsigned char Dot9 : 6;
    unsigned char Dot10 : 6;
    unsigned char Dot11 : 6;
    unsigned char Dot12 : 6;
    unsigned char Dot13 : 6;
    unsigned char Dot14 : 6;
    unsigned char Dot15 : 6;
  } d;
  unsigned char Dots[12];
} z;

function Test()
{
     unsigned char ucInt0;
     unsigned char ucInt1;
     unsigned char ucInt2;
     unsigned char ucInt3;

     z.d.Dot0 = 0x01;
     z.d.Dot1 = 0x10;
     z.d.Dot2 = 0x01;
     z.d.Dot3 = 63;
     z.d.Dot4 = 63;
     z.d.Dot5 = 63;
     z.d.Dot6 = 63;
     z.d.Dot7 = 63;
     z.d.Dot8 = 63;
     z.d.Dot9 = 63;
     z.d.Dot10 = 63;
     z.d.Dot11 = 63;
     z.d.Dot12 = 63;
     z.d.Dot13 = 63;
     z.d.Dot14 = 63;
     z.d.Dot15 = 63;

    ucInt0 = z.Dots[0];
    ucInt1 = z.Dots[1];
    ucInt2 = z.Dots[2];
    ucInt3 = z.Dots[3];
}

Wenn ich nicht völlig falsch gerechnet habe, müsste ich die Werte

ucInt0 = 0x05
ucInt1 = 0x00
ucInt2 = 0x7F
ucInt3 = 0xFF

rausbekommen,

allerdings bekomme ich folgendes:

ucInt0 = 0x01
ucInt1 = 0x14
ucInt2 = 0xFC
ucInt3 = 0xFF

also

00000001 00010100 11111100 11111111

statt

00000101 00000000 01111111 11111111

Wo steckt der Dreher???