Bitfield Array

Sorry, I didn't catch the nuance of your last printf() and I forgot to shift the mask.

        :
        :
        printf("%u\n",i);
        mask >>= 1;
    }
    while(1){}
}

Dear Dan,
thank for your prompt reply.
After finding my own solution i'been proud.
This last's only for about five minutes.
After i've seen growing the ARM's Data when i enlarged the array-size it brings my feets back to the ground.
C can make you feel as if there are bitfield-array's.
But internaly C uses more than a bit for each bit.
You only have the comfort to handle with bit's.
The price is waste of memory.
Now my (weird) solution:

//try "const struct" to see ARM7 in Abort-Mode :-)
struct
{
unsigned char red                       :1;
unsigned char orange            :1;
unsigned char yellow            :1;
unsigned char green                     :1;
unsigned char blue                      :1;
unsigned char violett           :1;
}color[8]={
1,0,1,0,1,0,
0,1,0,1,0,1,
0,0,0,0,0,0,
0,0,0,0,0,0,
1,1,1,1,1,1,
1,1,1,1,1,1,
};
//***************************************************************************
int main (void)
{
//***************************************************************************
        unsigned int i;
        PLL_init();
        RS232_init(115200);
        printf("Bitfield array in C\n");
        for(i=0;i<8;i++)
        {
                color[i].orange = ~color[i].red;//"~" or "!" which i correct?
                color[i].yellow = !color[i].red;
        }
        for(i=0;i<8;i++)
        {
                printf("%u ",color[i].red);
                printf("%u ",color[i].orange);
                printf("%u ",color[i].yellow);
                printf("%u ",color[i].green);
                printf("%u ",color[i].blue);
                printf("%u ",color[i].violett);
                printf("\n");
        }
        while(1){}
}

Another side effect:
Defining struct as const and altering it afterwards, brings ARM7 into Abort-Mode. There's no compiler warning.

Question which is right:
My_bit_a = ~My_bit_b;
My_bit_a = !My_bit_b;

Which operator? ~ or !

"Question which is right:
My_bit_a = ~My_bit_b;
My_bit_a = !My_bit_b;

Which operator? ~ or !"

For single bits the result is the same. For bitfields wider than one bit, use '~'.

But internaly C uses more than a bit for each bit.
You only have the comfort to handle with bit's.
The price is waste of memory.

That's quite universally wrong. Almost all existing C implementations use exactly one bit for a one-bit bitfield. But that doesn't change that the smallest actaully adressable unit of memory is still one byte. Which means that no, you can't have a pointer to a single bit, nor an array of bits, and yes, there will be padding between bitfields and non-bitfield parts of a struct. There may even be padding inside bitfields.

Bitfields are for giving names to parts of a byte (or bigger integer type). As long as controllers arr 8-bit, 16-bit or wider, C can't point to a single bit in any portable fashion.

And one byte is not guaranteed to be 8 bits large. Only to be _at least_ 8 bits. If the machine have 36-bit word size (some older IBM mainframes), it may have 9-bit bytes.

There are no required standard for the placement of bit or byte paddings (except that specific operating systems defines byte padding standards for access to OS system calls) and bit-fields may be stored left-aligned, right-aligned or in the middle of an integer.

The bit-fields where not invented for mapping of physical bits in microcontrollers, but for creating small (signed or unsigned) integers for better packing of data when the full numeric range of the native integer sizes wasn't needed.

When using bit fields, it is very important to remembered that two-complement storage means that a 1-bit signed bit field can only store the values -1 and 0. Testing the bit field for the value ==1 is one of the most common errors.

As long as the software doesn't performs binary writes of the bitfields to processor registers, to files or over communication channels, there are no compatibility problems with them.

When fiddling with bits in a microcontroller, the bit operations (& | ~ << >> ^) are normally used instead, since they are portable between compilers.