4. bitfield, array

bitfield, array

  • S

    Servus,

    ich spiele gerade mit meinem AVR herum und möchte da einzelne Ports setzen.

    Es funktioniert so einwandfrei:

    typedef struct  {
        int     p0: 1; int     p1: 1; int     p2: 1; int     p3: 1;
        int     p4: 1; int     p5: 1; int     p6: 1; int     p7: 1;
        } T_BF;
...

((T_BF*)&PORTD)->p5 ^= 1; // kippt mir das Bit nicht um

    Ich habe das dann mal so probiert:

    typedef struct  {
        int bit[8]:1;
        } T_BF;
...

((T_BF*)&PORTD)->bit[5] ^= 1; // kippt mir das Bit um

    Der Compiler meckert nicht, es funktioniert aber auch nicht.
    PORTD ist die Hardwareadresse des I/O-Ports.

    Das alles ist mit WinAVR (GCC) kompiliert. Den Assembler-Output habe ich
    mir angesehen, werde aber nicht schlau draus.

    Grüße Joe

    0
  • Mod

    Zumindest streng nach Standard kann man keine Arrays von Bitfeldern machen. Ob der GCC hier eine tolle Erweiterung hat, weiß ich nicht, das ist zu exotisch. Jedenfalls findest du, wenn überhaupt, in der Doku des GCC etwas da drüber.

    Falls du nicht immer pX schreiben möchtest, sondern eine Variable als Adresse nehmen möchtest, dann schreib dir Funktionen, die die gewünschten Änderungen an einem durch Funktionsparameter gegebenen Index vornehmen.

    0
  • D

    Oder benutz einfach kein Bitfeld...

    typedef unsigned char byte_t;
byte_t b;

// n. Bit toggeln
b ^= (1 << n);
    0
  • S

    Danke !

    0
  • K

    Moin,

    Kennst du vielleicht schon, aber ist sehr hilfreich für AVR:
    http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial

    Gruß
    Karsten

    0
  • S

    Moin Karsten,

    da hbe ich mich schon durchgewühlt. Im Moment finde ich es einfach faszinierend,
    mal etwas mit 2 kB Programm und 128 Byte RAM zum Laufen zu bringen - nicht immer
    so Speicherorgien 🤡

    Grüße Joe.

    0
  • S

    DrakoXP schrieb:

    Oder benutz einfach kein Bitfeld...

    typedef unsigned char byte_t;
byte_t b;

// n. Bit toggeln
b ^= (1 << n);

    Ich wollte die Ports in einer Schleife auslesen bzw. nach
    einem übermittelten Wert setzen.

    Das ginge mit einem Array halt einfacher.

    zB

    int adr = 4;
int data = 1;

((T_BF*)&PORTD)->bit[adr] = data
    0
  • D

    kA, wo dein Problem is :S

    // n. Bit setzen
*(byte_t*)(&PORTD) |= (1 << n);

// n. Bit testen
int is_set = (*(byte_t*)(&PORTD) & (1 << n)) ? 1 : 0;

// n. Bit toggeln
*(byte_t*)(&PORTD) ^= (1 << n);

    Bei Bitfeldern macht der Compiler im Hintergrund höchstwahrscheinlich gar nichts anderes,
    nur dass es eben für den Programmierer vllt syntaktisch schöner aussieht.

    Abgesehen von der evtl schöneren Syntax bringt dein Bitfeld-Array hier Performance-technisch sicher keine Vorteile,
    da es innerhalb eines Bytes wohl eher nicht zu Cache-Misses kommt xD

    0
  • S

    Merci. Irgendwie programmiert das Auge halt mit ... 😉

    0
Anmelden zum Antworten