Bitoperationen mit Strukturen

[Taylor (Gast)]

Hi,
mein Problem ist zwar nicht AVR-Speziell aber vielleicht kann mir ja
doch wer hier helfen.
Und zwar möchte ich zwei 16-Bit Strukturen mit einander vergleiche und
auswerten.
Dazu möchte ich sie gern zum Beispiel "verunden". Wie sieht dabei
meine Syntax aus ?
Wenn ich die komplette Struktur mit einem Hex Wert vergleichen will
mach ich es so, dass ich einen 16 Bit Zeiger darauf lege.

*((u16*)&Struktur_A) == 0x80

Die Bitstrukturen habe ich vorher definiert.

So, wie kann ich nun zb Struktur_A mit Struktur_B verunden und das
ergebnis dann einer Struktur_C zuweisen. Bzw, kann man überhaupt in
eine Bitstruktur direkt einen Wert einprägen ??

gruß Taylor

[Stefan B. (Gast)]

Hallo Taylor!

Was ist eine 16-Bit Struktur bzw. was verstehst Du darunter?

also allgemein in C würde das für Variablen mit einem einfachen &
aussehen, also:

   VarC = VarA & VarB;

wobei VarA, VarB und VarC die Variablen sind.

Ich hoffe Dir damit weitergeholfen zu haben!

Stefan B.

[Taylor (Gast)]

Hi, ja bei Variablen ist das klar, nur ich bruache das bezogen auf
Bitstrukturen.
Die Struktur sieht dann so aus:

typedef struct
{
 u16 Wert1: 1;
 u16 Wert2: 1;
 u16 Wert3: 1;
 u16 Wert4: 1;
 ... usw
}TypStruktur

Bei der Deklaration dann so:

Typstruktur Struktur_A, Struktur_B, Struktur_C;

Nun möchte ich die Strukturen_A und _B verunden und die dann Struktur_C
zuweisen.

[Patrick D. (oldbug)]

Der einfachste Weg dazu wird die sogenannte 'union' sein.

Beispiel:

#include <stdio.h>

typedef struct bitfield_s
{
        unsigned flag1:1;
        unsigned flag2:1;
        unsigned flag3:1;
        unsigned flag4:1;
        unsigned flag5:1;
        unsigned flag6:1;
        unsigned flag7:1;
} bitfield_t;

typedef union bitsnbytes_u
{
        unsigned int val;
        bitfield_t bits;
} bitsnbytes_t;

bitsnbytes_t structA, structB, structC;

int
main(void)
{
        structA.bits.flag1 = 1;
        structB.bits.flag2 = 1;

        structC.val = structA.val | structB.val;

        printf("structC.val = %d\n", structC.val);

        return 0;
}

[Marcus (Gast)]

stimmt... mit union legst du fest, das es entweder die eine, oder die
andere struktur sein kann (also der komplette wert der
struktur/variablen angesprochen wird oder halt eben bitweise).
so kannst du mit .val die komplette struktur vergleichen und mit .flagX
bitweise drauf zugreifen.

[Taylor (Gast)]

Danke,
werd ich gleich mal probieren. Super Forum hier.
Wahnsinn wie schnell man hier ne hilfreiche Antwort bekommt.

gruß Taylor

[Taylor (Gast)]

Super,
klappt genau so wie ich es haben wollte. Besten Dank