Hallo,
dieses ist eine sicher nicht allgemeingültig zu beantwortende Frage, und
ich denke hier hat jeder seine ganz eigenen Ansichten zu. Trotzdem frage
ich nach euren Meinungen und der Begründung warum es für euch die beste
Möglichkeit darstellt.
Also zunächst ein bisschen Vorgabe
1 | typedef struct testStruct{
|
2 | uint16_t VarA;
|
3 | uint16_t VarB;
|
4 | ? 8BitField
|
5 | }test_TypeDefSt
|
es geht darum wie am besten dieses 8 Bit Bitfild implementiert wird.
Variante 1:
1 | #define FLAG1 ((uint8_t)0x01U
|
2 | #define FLAG2 ((uint8_t)0x02U
|
3 | #define FLAG3 ((uint8_t)0x04U
|
4 | #define FLAG4 ((uint8_t)0x08U
|
5 | #define FLAG5 ((uint8_t)0x10U
|
6 | #define FLAG6 ((uint8_t)0x20U
|
7 | #define FLAG7 ((uint8_t)0x40U
|
8 | #define FLAG8 ((uint8_t)0x80U
|
9 |
|
10 | typedef struct testStruct{
|
11 | uint16_t VarA;
|
12 | uint16_t VarB;
|
13 | uint8_t BitField;
|
14 | }test_TypeDefSt
|
zugriff dann über Veroderung
Variante 2: wie Variante 1 nur mit einem typedef enum für die Flags
Variante 3:
1 | typedef struct FlagsStruct{
|
2 | uint8_t flag1 :1;
|
3 | uint8_t flag2 :1;
|
4 | uint8_t flag3 :1;
|
5 | uint8_t flag4 :1;
|
6 | uint8_t flag5 :1;
|
7 | uint8_t flag6 :1;
|
8 | uint8_t flag7 :1;
|
9 | uint8_t flag8 :1;
|
10 | }flags_TypeDefSt
|
11 |
|
12 | typedef struct testStruct{
|
13 | uint16_t VarA;
|
14 | uint16_t VarB;
|
15 | flags_TypeDefSt BitField;
|
16 | }test_TypeDefSt
|
zugriff mittels var.BitFild.flagX
ist sichergestellt das der compiler hier nur 8 bit belegt?
gibt es eine einfache Möglichkeit dieses Bielefeld wieder in einem
uint8_t (char) abzulegen und zu senden? ist hier ein cast gefahrlos
möglich?
Variante 4:
eure Ideen
Variante 1 ist sicher der Klassiker, allerdings sieht man beim Debuggen
nicht welche Flags gesetzt sind, was bei größeren Strukturen dann schon
unübersichtlich werden kann.
