Kann mir jemand diesen Code erklären?

[Andi80 (Gast)]

Hallo habe einen Code von einem Kollegen bekommen den ich nicht verstehe 
kann mir jemand weiter helfen? Hier ist der Code:

#define EventBit(a) (a&0x1F)
typedef uint32 StatusType[2];

static StatusType ActualEvents;

void Status(EventType EventCode )
{
 if( EventCode < NUMB_OF_EVT )
 {
   ActualEvents[ EventCode >> 5] &= ~(1UL<<(EventBit(EventCode)) );
 }
return;
}

EventType ist ein enum das bis 56 geht.

[Peter II (Gast)]

warum fragst du deinen Kollegen nicht?

Bei welcher Zeile kommt du denn nicht weiter?

[Andi80 (Gast)]

Weil mein Kollege für 3 Wochen im Urlaub ist und ich mich nun in seine 
Sachen einarbeiten soll.

[Jens M. (dl4aas)]

Moin Andi80,

in ActualEvents, das aus zwei 32bit-Zahlen besteht, wird das Bit 
gelöscht, das die Nummer der Eventcodes hat. ActualEvents[1] ist für die 
Bits 55..32 zuständig, [0] für 31..0.

Gruß
Jens

[Andi80 (Gast)]

Ok das mit dem ersten Teil habe ich verstanden aber den Teil hinter der 
Klammer nicht ganz.Wie würde das ganze aussehen wenn ich es in mehreren 
Schritten mach?

[Jens M. (dl4aas)]

Hinter welcher Klammer?

Mal die Kernzeile:

ActualEvents[ EventCode >> 5] &= ~(1UL<<(EventBit(EventCode))

Könnte man als

 index = EventCode >> 5;  // die Bits 7..5 des Eventcodes als Index
 bitindex = EventBit(EventCode); // die Bits 4..0 als Bitnummer
 bitmask = 1UL << bitindex; // bitmaske mit einem Bit gesetzt erstellen
                            // je nach Bitnummer
 invbitmask = ~bitmask;   // bitmaske invertieren, denn ich will ja loeschen
 ActualEvents[index] = ActualEvents[index] & invbitmask;
                          // in ActualEvents das eine nicht gesetzte bit 
                          // durch ver-und-en loeschen

schreiben.

Wird das so klarer?

[Oliver (Gast)]

Lies mal hier nach:

http://www.mikrocontroller.net/articles/Bitmanipulation

Oliver

[Andi80 (Gast)]

Alles klar super jetzt habe ich es verstanden. Besten dank.

[Tom K. (ez81)]

Hallo Andi,
tu Dir bitte selbst den Gefallen und klammere das a in dem #define noch 
zusätzlich ein. Sonst hängt die Evaluierung des ganzen von der 
Operatorrangfolge in C ab, was spätestens beim unteren Beispiel 
danebengeht, da der "?:"-Operator schwächer bindet als das "&". Genau 
dieser Fehler eines Experten hat mich Stunden meines Lebens gekostet.

#include <stdio.h>
#include <stdbool.h>
#define EventBit(a) (a&0x1F)

int main(void)
{
    for (int i=0xF0; i < 0xFF; ++i)
    {
        int defaultForUnEven = 0x02;
        // "ungerade" events durch default ersetzen:
        bool isEven = (i % 2 == 0);
        int foo = EventBit(isEven ? i : defaultForUnEven);
        printf("EventBit (eigentlich mit 0x1F maskiert): 0x%02X\n", foo);
    }
    return 0;
}

Grüße,
Tom

[Karl H. (kbuchegg)]

Tom K. schrieb:

> tu Dir bitte selbst den Gefallen und klammere das a in dem #define noch
> zusätzlich ein.

> #define EventBit(a) (a&0x1F)


Du bist aber dann hoffentlich gleich noch einen Schritt weiter 
gegegangen und hast noch eine zusätzliche Klammerebene eingezogen?

#define EventBit(a) ((a)&0x1F)

[Tom K. (ez81)]

Hallo Karl Heinz,

ich schon, aber der Kollege von Andi anscheinend nicht. Das Beispiel 
sollte demonstrieren, was passieren kann, wenn man die Klammern 
weglässt. Das habe ich nicht deutlich genug beschrieben.

Wie man an der Ausgabe sieht, ist das einzige, was mit 0x1F maskiert 
wird, die defaultForUneven-Variable:

EventBit (eigentlich mit 0x1F maskiert): 0xF0
EventBit (eigentlich mit 0x1F maskiert): 0x02
EventBit (eigentlich mit 0x1F maskiert): 0xF2
EventBit (eigentlich mit 0x1F maskiert): 0x02
[...]

Grüße

[Karl H. (kbuchegg)]

Tom K. schrieb:
> Hallo Karl Heinz,
>
> ich schon, aber der Kollege von Andi anscheinend nicht. Das Beispiel
> sollte demonstrieren, was passieren kann, wenn man die Klammern
> weglässt.

Ah, ok. Passt.

Ich war schon etwas in Eile und hab mir das Beispiel nicht näher 
angesehen.

Mein Standardbeispiel für diesen Fehlertypus sieht so aus

#define TIMES2(x)    2*x


   j = TIMES2( 3 + 2 )


aus dem Code würde man beim schnellen Lesen ein Ergebnis von 10 
erwarten. Tatsächlich ist das Ergebnis aber 8

Warum? Weil die Makroersetzung zu

   j = 2*3 + 2

führt, und das was anderes ergibt als

   j = 2*(3 + 2)

so wie es ursprünglich gedacht war.

#define TIMES2(x)    (2*(x))


In Makros kann man fast nie genug Klammern haben. Und selbst dann ...