bit Datentyp erzeugen

Hi!

Ich weiss nicht ganz wie du das meinst, aber vieleicht hilft das.

Sind zwar direkt 8 Bits die du dann hast aber wir wollen ja keinen
Platz verschwenden :). Bei nem 16-Bitter würde man dann wohl 16 Bits
definieren bei nem 32-Bitter....

typedef struct _BITS{
    unsigned bit0:1;
    unsigned bit1:1;
    unsigned bit2:1;
    unsigned bit3:1;
    unsigned bit4:1;
    unsigned bit5:1;
    unsigned bit6:1;
    unsigned bit7:1
} BITS;

dann kannst du dir einfach ein Bitfeld machen mit

BITS bitfeld;

und ansprechen mit

bitfeld.bit1 = 0;
bitfeld.bit2 = 1;

bei

bitfeld.bit2++;

würde bitfeld.bit2 zu 0

dann kann man noch so schöne Sachen machen wie

unsigned char * p_bitfeld = (unsigned char *) &bitfeld;

und dann mit

*p_bitfeld = 0;

alle Bits löschen oder mit

*p_bitfeld = 0xff

alle setzen oder was du auch immer willst.

Hoffe geholfen zu haben. Ansonsten kannste es ja vieleicht auch für was
anderes brauchen.




und

Bitfelder sind eine schöne Sache, aber brauchen leider sehr viel mehr
Code als Bitsetzbefehle mittels or ect. zB.

#define Set_Bit(Byte,Pos)     Byte |= (1<<Pos)  //Bit setzen (Macro)


Josef

@Josef

Kann sonicht verallgemeinert werden, denn es ist compilerabhängig.

Beim avr_gcc ergibt die ganze sache z.B. genau den gleichen Code.

Ein kleines Testprogramm:

typedef struct _BITS{
    unsigned bit0:1;
    unsigned bit1:1;
    unsigned bit2:1;
    unsigned bit3:1;
    unsigned bit4:1;
    unsigned bit5:1;
    unsigned bit6:1;
    unsigned bit7:1;
} BITS;

BITS bitfeld;
unsigned char bitfeld_set;

int main(void){

  bitfeld.bit1 = 1;
  bitfeld.bit2 = 0;

  bitfeld_set |= 1<<1;
  bitfeld_set &= ~(1<<2);


}

Ergebnis aus dem .lst File

test.c        **** int main(void){
  42                 .LM1:
  43                 /* prologue: frame size=0 */
  44 0000 C0E0          ldi r28,lo8(__stack - 0)
  45 0002 D0E0          ldi r29,hi8(__stack - 0)
  46 0004 DEBF          out _SP_H_,r29
  47 0006 CDBF          out _SP_L_,r28
  48                 /* prologue end (size=4) */
  19:test.c        ****
  20:test.c        ****   bitfeld.bit1 = 1;
  50                 .LM2:
  51 0008 8091 0000     lds r24,bitfeld
  52 000c 8260          ori r24,lo8(2)
  21:test.c        ****   bitfeld.bit2 = 0;
  54                 .LM3:
  55 000e 8B7F          andi r24,lo8(-5)
  56 0010 8093 0000     sts bitfeld,r24
  22:test.c        ****
  23:test.c        ****   bitfeld_set |= 1<<1;
  58                 .LM4:
  59 0014 8091 0000     lds r24,bitfeld_set
  60 0018 8260          ori r24,lo8(2)
  24:test.c        ****   bitfeld_set &= ~(1<<2);
  62                 .LM5:
  63 001a 8B7F          andi r24,lo8(-5)
  64 001c 8093 0000     sts bitfeld_set,r24
  25:test.c        ****
  26:test.c        ****
  27:test.c        **** }

Hi,

ich lege mir nie ein struct dafuer an. Ich mache sowas ueber eine
gloable Variable und ein paar defines.


#define ERROR_FLAG  0
#define BUSY_FLAG   1
#define READY_FLAG  2
usw.


volatile unsigned char statusbyte;

setzen , loeschen , togglen mache ich ganz normal

statusbyte |= (1<<ERROR_FLAG);

statusbyte &= ~(1<<ERROR_FLAG);

statusbyte ^= (1<<BUSY_FLAG);

while(!(statusbyte |= (1<<BUSYFLAG);

sollte ich von meiner weise abweichen und es per struct machen?

Gruß,

Dirk

Ich finde die Sache mit den structs n bissel "schicker" und
übersichtlicher. Da hat man die Beschreibung der Variable und die
ganzen  Bedeutungen der Bits zusammen. Ausserdem kannst du in einem
char dann auch so sachen machen wie eine übersichtliche TimerControl
Struktur:

typedef struct _TIMER_CONTROL{
    unsigned value:3;
    unsigned reload:3;
    unsigned expired:1;
    unsigned start:1;
} TIMER_CONTROL;

TIMER_CONTROL timer_control;

Man hat ein paar Bits die man ansprechen kann und noch "kleinere
Variablen", die in diesem Fall von 0 bis 7 gehen und einfach
anzusprechen sind und die Sach ist derbe übersichtlich .

timer_control.reload = 3;
timer_control.start = 1;

usw.

zu beachten ist, dass in solch einem struct die Bits von LSB nach MSB
belegt werden.