Vereinfachung bei der Bitauswertung

Kuen Gast #911674
Lesenswert?
• ▲
▼ 
Hi,

ich lese mir gerade ein Signal über den externen Interrupt ein. Das 
Signal besteht aus 4 Bytes. Die 4 Bytes kriege ich ohne Probleme und 
korrekt eingelesen. Die 4 Bytes werden in eine Array abgelegt und sollen 
später weiterverarbeitet werden.

Nun möchte ich aus diesen Bytes die einzelnen Bits auswerten. Das mache 
ich folgendermaßen:

1
  typedef struct

2
{

3
  unsigned char T1;

4
  unsigned char T2;

5
  unsigned char T4;

6
  unsigned char T5;

7


8
  unsigned char K1;

9
  unsigned char K2;

10
  unsigned char K3;

11
  unsigned char K4;

12
  

13
}Byte;

14


15


16


17
int main(void)

18


19
{

20
  DDRB  = 0x03;           

21
  PORTB = 0x0B;

22


23
  DDRD  = 0x00;

24
  PORTD = 0x00;

25


26
  //clkI/O/8 (From prescaler)

27
  TCCR0B |= (1 << CS01);

28


29
  //falling edge of INT0 generates an interrupt request

30
  EICRA |= (1 << ISC01);

31
  //External Interrupt Request INT0 Enable

32
  EIMSK |= (1 << INT0);   

33


34
  Byte byte1;

35


36
  sei();

37


38
  while (1){

39


40
        signal_routine();

41


42
        byte1.K1 = (IR_buffer[0] & 0x01);

43
        byte1.K2 = (IR_buffer[0] & 0x02);

44
        byte1.K3 = (IR_buffer[0] & 0x04);

45
        byte1.K4 = (IR_buffer[0] & 0x08);

46
        byte1.T5 = (IR_buffer[0] & 0x10);

47
        byte1.T2 = (IR_buffer[0] & 0x20);

48
        byte1.T4 = (IR_buffer[0] & 0x40);

49
        byte1.T1 = (IR_buffer[0] & 0x80);

50


51
        //test = button_byte.T4;        

52
       }

53
    

54
}


Meine Frage ist ob man diese Auswertung nicht etwas vereinfachen kann? 
Der Code funktioniert, kommt mir halt nur etwas umständlich vor.


Gruß,
Kuen
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Jörg X. Gast #911737
Lesenswert?
• ▲
▼ 
Evtl. geht sowas (ähnliches):
1
struct _bits{

2
        unsigned char T1:1;

3
        unsigned char T4:1;

4
        unsigned char T2:1;

5
        unsigned char T5:1;

6


7
        unsigned char K4:1;

8
        unsigned char K3:1;

9
        unsigned char K2:1;

10
        unsigned char K1:1;

11
    };

12
/* Du musst selber ausprobieren, welches struct korrekt ist ;)

13
struct _bits{

14
        unsigned char K1:1;

15
        unsigned char K2:1;

16
        unsigned char K3:1;

17
        unsigned char K4:1;

18


19
        unsigned char T5:1;

20
        unsigned char T2:1;

21
        unsigned char T4:1;

22
        unsigned char T1:1;

23
    };

24
*/    

25


26
typedef union {

27
    struct _bits bits;

28
    unsigned char raw_byte;

29
    } Byte;

30


31
//in main....    

32
    Byte theByte;

33
    theByte.raw_byte = IR_buffer[0];

Probleme: ich weiß nicht, ob die Reihenfolge der Felder im Bitfeld 
feststeht (oder Architektur-/Compilerabhängig ist).
Und ich weiß nicht, ob du nicht vielleicht tatsächlich 8 Bytes pro 
"Byte" brauchst...

hth. Jörg
ps.: Vielleicht könntest du verraten, was du für ein Signal einliest 
(UART, I2C, SPI, PWM, ....)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Kuen Gast #911802
Lesenswert?
• ▲
▼ 
Hallo Jörg,

Danke für den Tip. Viel einfacher wird es dadurch aber wohl auch nicht 
werden. Vielleicht versuch ich es mit einer Maske anstatt einem Bitfeld.

Die 8 Bits pro Byte brauch ich leider. Das Signal stammt von einer 
Infrarot Fernbedienung.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren