Bitanweisung Wert überschreiben

[Samuel (Gast)]

Sehe ich folgendes richtig?

uint8_t val = 0;

val |= 1<<0; // Schreibt eine 1 an das 0. Bit, egal ob der Wert 0 oder 1 war
val |= 0<<0; // macht nichts
val &= ~(1<<0); //Schreibt eine 0 an das 0. Bit, egal ob der Wert 0 oder 1 war

Hintergrund der ganzen Sache, ich würde gerne Leds setzen, ohne aber 
jedesmal abzuabfragen, ob das Bit bereits gesetzt oder nicht ist.

Hier der Pseudo Code. Gäbe es auch eine "schönere" Variante von
val &= ~(1<< 0);
val |= status << 0;
bzw. kürzere?

uint8_t val = 0;
uint8_t status = 1;

val &= ~(1<< 0); // 0. Bit löschen
// 0. Bit ist 0. wurde geloescht
val |= status << 0; // 0. Bit setzen
// 0. Bit ist 1. wurde gesetzt


status = 0;
val &= ~(1<< 0); // 0. Bit löschen
// 0. Bit ist 0. wurde geloescht
val |= status << 0; // 0. Bit setzen
// 0. Bit ist 1. wurde NICHT gesetzt

[Klaus W. (mfgkw)]

Samuel schrieb:
> Gäbe es auch eine "schönere" Variante von...

Schönheit liegt wie immer im Auge des Betrachters.
Hier im Forum sieht man in aller Regel die Bitfummelei, wie sie dir 
nicht gefällt - mir auch nicht.

Man kann sich aber mit Bitfeldern ganz gut behelfen, wenn ich dein 
Anliegen richtig verstehe.

Beispiel:

typedef union
{
  struct
  {
    unsigned bit0:1;
    unsigned bit1:1;
    unsigned bit2:1;
    unsigned bit3:1;
    unsigned bit4:1;
    unsigned bit5:1;
    unsigned bit6:1;
    unsigned bit7:1;
  };
  uint8_t  byte;
} eightbits_t;
...
  eightbits_t   val =
    {
      {
        .bit0 = 0,
        .bit1 = 1,
        .bit2 = 0,
        .bit3 = 1,
        .bit4 = 0,
        .bit5 = 0,
        .bit6 = 1,
        .bit7 = 0
      }
    };

  val.byte = 0;  // alle Bits auf 0
  val.bit0 = 0;  // unterstes Bit auf 0
  val.bit0 = 1;  // unterstes Bit auf 1
...

Wenn man die Variable nicht bitweise, sondern komplett initialisieren 
will, geht das natürlich auch:

...
  eightbits_t   val = { .byte = 0 };
...

Die Frage, ob das jetzt allerdings schöner ist, kann beliebig langes 
Gezeter verursachen.

Auf eine ähnliche Weise mappe ich mir auch Bits oder Bitgruppen in 
Registern auf Bitfelder, wenn mir die übliche Schreibweise mit der 
Bitschieberei auf die Nerven geht.
Dazu kann man mißbrauchen, daß die Register in den Adreßbereich 
eingeblendet sind wie Speicher, und die Registernamen eh nur Makros 
sind, die dann über die Adresse mit etwas Casten aussehen wie Variablen.
Beispiel: in den Headerdateien, die für einen atmega8 verwendet werden, 
steht letztlich etwas wie:

...
#define PORTB    (*(volatile uint8_t *)((0x17) + 0x20))
...

, wenn PORTB an der Stelle 0x37 in den Speicher eingeblendet ist.
Das kann man mißbrauchen, um mit &PORTB wieder an die 0x37 zu kommen und 
sich dort stattdessen ein Bitfeld vorzustellen:

...
// in einer Headerdatei von mir:
#ifdef DDRB
#define ddrb  (*(volatile eightbits_t*)(&DDRB))
#define portb (*(volatile eightbits_t*)(&PORTB))
#define pinb  (*(volatile eightbits_t*)(&PINB))
#endif /* ifdef DDRB */
...
// in einer C++ von mir:
ddrb.bit0  = 0;  // Datenrichtung für LED setzen
portb.bit0 = 0;  // LED aus
portb.bit0 = 1;  // LED ein
...
// oder etwas sprechender:
#define DDR_IN    (0)
#define DDR_OUT   (1)
...
#define MEINELED_PORT portb.bo
#define MEINELED_DDR  ddrb.bo

...
  MEINELED_DDR  = DDR_OUT;  // Datenrichtung für LED setzen
  MEINELED_PORT = 0;        // LED aus
  MEINELED_PORT = 1;        // LED ein
...

Für spezielle Register mache ich mir dann Bitfelder, die nicht unbedingt 
einzelne Bits abbilden, sondern zusammengehörende Gruppen, die auf 
einmal gesetzt werden können.

Beispiel: Wenn ein Register ADMUX laut Datenblatt aus einem 5 Bit langen 
Bereich mux für die Kanalnummer besteht, einem Bit adlar und einem zwei 
Bit langen refs, dann kann man sowas schreiben:

...
typedef union
{
  uint8_t     byte;
  struct
  {
    unsigned int mux:5;
    unsigned int adlar:1;
    unsigned int refs:2;
  };
} admux_byte8bits_t;

#define admux   (*(volatile admux_byte8bits_t*)&ADMUX)
...
  admux.mux = iKanal; // Kanalnummer setzen (5 Bits)
...

Damit will ich jetzt keine Stildiskussion anfachen, sondern zeigen wie 
es technisch gehen kann - wenn man es so will.

[Klaus (Gast)]

Klaus Wachtler schrieb:
> Auf eine ähnliche Weise mappe ich mir auch Bits oder Bitgruppen in
> Registern auf Bitfelder, wenn mir die übliche Schreibweise mit der
> Bitschieberei auf die Nerven geht.

Für die (alle) PICs haben die Microchip Leute das schon mal gemacht und 
in die entsprechenden Header Files geschrieben. Die "Bitschieberei" 
kommt bei mir im Code nicht vor. Da wird ein Interrupt-Flag einfach = 0 
gesetzt und ein Portbit = 1. Da ich das vom Keil 8051 Compiler so 
gewöhnt war, passte das nahtlos für die PiCs.

MfG Klaus

[Stefan F. (Gast)]

Ich benutze gerne diese Makros:

#define writeBit(port,bit,value)   { if ((value)>0) (port) |= (1<<bit); else (port) &= ~(1<<bit); }

#define readBit(port,bit)          (((port) >> (bit)) & 1)

Anwendung:

// LED einschalten
writeBit(DDRB,3,1);
writeBit(PORTB,3,1);

Wenn bit und value eine konstant ist, kostet das keinen einzigen 
Taktzyklus overhead.

In der Praxis abstrahiere ich I/O Zugriffe häufig noch eine Stufe 
weiter, damit ich sprechende Schlüsselwörter im Quelltext habe und die 
Pin-Zuordnung an einer zentralen Stelle vornehmen kann:

#define LED_AN  { writeBit(DDRB,3,1); writeBit(PORTB,3,1); }
#define LED_AUS writeBit(PORTB,3,0);

[Peter D. (peda)]

Klaus Wachtler schrieb:
> Hier im Forum sieht man in aller Regel die Bitfummelei, wie sie dir
> nicht gefällt - mir auch nicht.

Mir auch nicht.
Für IO-Ports habe ich mir daher die sbit.h geschrieben:

Beitrag "Re: LED1 OK. aber LED2 blinkt nicht mit voller Helligkeit"

[Klaus (Gast)]

Stefan Us schrieb:
> Ich benutze gerne diese Makros:#define writeBit(port,bit,value)   { if
> ((value)>0) (port) |= (1<<bit); else (port) &= ~(1<<bit); }
>
> #define readBit(port,bit)          (((port) >> (bit)) & 1)

Was ein aber nicht hindert, nicht vorhandene Bits auf den falschen 
Adressen zu beschreiben. Wenn man konsequent alle SFRs und Ports als 
Bitfelder (am besten mit den Namen aus dem Datenblatt) beschreibt, kann 
der Compiler schon mal die blödesten Fehler abfangen.

MfG Klaus

[Ralf G. (ralg)]

Samuel schrieb:
> Hintergrund der ganzen Sache, ich würde gerne Leds setzen, ohne aber
> jedesmal abzuabfragen, ob das Bit bereits gesetzt oder nicht ist.
Ähm..., ich würde sagen: dann frag' doch einfach nicht und setz' das 
Bit!
(Hier sind ja schon einige Antworten, aber ich verstehe den Satz vom 
TO nicht.)
>
> Hier der Pseudo Code. Gäbe es auch eine "schönere" Variante von
> val &= ~(1<< 0);
> val |= status << 0;
> bzw. kürzere?

Siehe oben:

//val &= ~(1<< 0);
val |= status << 0;

(??) ^^

[Karl H. (kbuchegg)]

Ralf G. schrieb:
> Samuel schrieb:
>> Hintergrund der ganzen Sache, ich würde gerne Leds setzen, ohne aber
>> jedesmal abzuabfragen, ob das Bit bereits gesetzt oder nicht ist.
> Ähm..., ich würde sagen: dann frag' doch einfach nicht und setz' das
> Bit!
> (Hier sind ja schon einige Antworten, aber ich verstehe den Satz vom
> TO nicht.)


Ich denke, mit 'setzen' war nicht direkt das 'auf 1 setzen' gemeint, 
sondern einfach nur 'auf einen neuen Wert, egal ob 1 oder 0'