Zugriff auf einzelne Bits in einem Register

ist immer vom Chip und Assembler abhängig. Bein 8051 kann man zB. Set
Px.x schreiben. Dann wird bit X im Port x gesetzt.
mit CPL Px.x wird das Bit negiert.

Mann kann SetB Bit Adr. setzt ein Bit an Adresse nehmen.

Man kann einem Bit auch einen "Namen" geben und dann setzten oder
zurücksetzen. zB.

LED EQU P3.1
setb LED ; LED an
clr LED  ; LED aus  Beides wirkt auf das Pin Port 3.1.
Anstelle von Ports können auch RAM adressen dienen.

Nein, das funktioniert nicht.
Schon mal deshalb nicht, weil du einer Variablen die
der Compiler anlegt, nicht einfach eine andere Adresse
zuweisen kannst.

Wie wärs denn einfach mit einem Makro (Setbit,Clearbit) was du dir
selber machst, und was deine von dir als "unschönes Shiften und
Maskieren von Bits" bezeichnete Vorgehensweise weitgehend verdrängt.

Naja, mit einem Pojnter auf eine derartige Struktur lässt sich das schon
hinbekommen:

  struct RegisterBitfeld
  {
    unsigned char bit0 : 1;
    unsigned char bit1 : 1;
    unsigned char bit2 : 1;
  //etc.
  };

  struct RegisterBitfeld *pRegister;

  pRegister = (struct RegisterBitfeld *) ((void *) 0xDEADFACE);

  pRegister->bit0 = 1;
  pRegister->bit1 = 1;
  pRegister->bit2 = 0;

Wie effizient der vom Compiler erzeugte Code in diesem Falle ist, das
gilt es allerdings zu untersuchen.

Da Bitfelder an sich vom Typ int sind, wäre obendrein zu untersuchen,
ob der gegebene Compiler "struct RegisterBitfeld" so interpretiert,
daß

  sizeof (struct RegisterBitfeld) == 1

ist. Ist das nicht der Fall, so sollte man weitere Versuche
einstellen.
Oder sich auf überaus erfreuliche Seiteneffekte einstellen ...

Tandaradei, singt der Debugger

@Rufus: Vielleicht wäre es sogar sinnvoll, eine Union statt struct zu
nehmen. Man könnte dann auch die 8 bit in einem Rutsch schreiben, wenn
man möchte.

Mit Macros geht das beim AVR-GCC z.B. so:

1

#define RESET(x)        _XRS(x)

2

#define SET(x)          _XS(x)

3

4

#define _XRS(x,y)       x &= ~(1<<y)

5

#define _XS(x,y)        x |= 1<<y

6

7

#define LED_I2C         PORTD,5

8

9

#define LED_ERR         PORTC,3

10

11

// Code:

12

13

 if( Error )

14

   RESET( LED_ERR );

15

 else

16

   SET( LED_ERR );

Die Verschachtelung ist nötig, damit die Aufteilung in 2 Argumente
keinen Fehler erzeugt (wird nur bei der ersten Macroexpansion
geprüft).


Peter

Der springende Punkt ist, dass du eben nicht
das Makro _XRS direkt benutzt. Ambesten vergist du
gleich wieder, dass dieses Makro existiert.
Als Programmierer benutzt du immer nur die Makros
SET und RESET

Wo liegt das Problem?


0xDEADFACE   ist zunächst mal einfach nur eine Zahl. Allerdings
in hexadezimaler Schreibweise. Der Rest ist einfach nur
casting.
(void*) 0xDEADFACE
weist den Compiler an, er möge doch bitte so tun, als ob die
Zahl eine Adresse in den Speicher wäre. Das castet also den
int um in einen Pointer. Noch ist keine Aussage darüber gefallen
was man sich denn  im Speicher unter der Adresse 0xDEADFACE vorstellen
soll. Liegt dort ein int, oder ein double oder ...
niemand weis es. Bisher ist nur von einem Pointer die Rede.

Aber das aendert sich jetzt:
(struct RegisterBitFeld*) ( ... )

Das sagt jetzt dem Compiler, dass er mal davon ausgehen soll,
dass er an der angegebenen Speicheradresse eine struct
RegisterBitfeld vorfinden wird. Hier wird also eine konkrete
Aussgae darüber getroffen wie die Bytes die an der angegebenen
Adresse zu finden sind zu interpretieren sind.

> pRegister = (struct RegisterBitfeld *) 0xDEADFACE;
> nicht genausogut? Testcompilierung läuft jedenfalls anstandslos
> durch.

Ja, klar, ginge auch.

Ein cast ist die Anweisung an den Compiler:
"Vergiss jetzt mal dein Typsystem. Ich als Programmierer
sag die jetzt wo's langgeht und du hältst dich da raus.
Wenn ich ich dir sage, dass das so ist, dann ist das so.
Aus, ende, basta!"

-> Ein cast ist eine Waffe!

> Wird denn auch an Adresse 0xDeadFace

:-)
DEADFACE benutzt man in Beispielen wenn man eine Hex-Zahl
braucht, bei der der Wert an sich keine Rolle spielt, sondern
man ein Prinzip illustrieren möchte. Ein anderes Beispiel
wäre zb. foo.  foo wird als Funktionsname genommen, wenn man
einfach nur eine Funktion braucht, wobei es auf die Funktion
an sich nicht ankommt. Bsp. Funktionspointer. Die eigentliche
Funktion ist völlig irrelevant. Alles was man braucht ist
irgendeine Funktion:

  typedef void (*Fnct)( void );

  void foo()
  {
  }

  Fnct FunctionPointer = foo;

0xDEADFACE hat natürlich den Charme ein Wort zu ergeben und
trotzdem eine gültige 32 Bit Zahl zu sein :-)

> Ne - ich mag nicht vergessen das es dieses Makro gibt

Das sollst du aber.
Alle Makros die mit '_' beginnen, gehen den
Programmierer nichts an :-) '_' ist reserviert
für den Compiler workspace.

> und eben da komme ich nicht weiter

Dann musst du mal nachlesen, nach welchen Regeln
der Präprozessor Makro-Expansionen macht. Vor allen
Dingen nicht vergessen: Makro Expansionen sind reine
Textersetzungen! Sonst steckt da nichts dahinter:

  SET( LED_ERR )

expandiert durch das Makro
#define SET(x)          _XS(x)

zu
  _XS( LED_ERR )

danach werden die Argumente selbst expandiert und LED_ERR ersetzt

  _XS( PORTC,3)

somit ist das SET Makro (inkl.Argumente) selbst komplett ersetzt
und es wird versucht ob es weitere Makro-Ersetzungen mit diesem
(Zwischen-)Ergebnis gibt.
Gibt es, _XS ist selbst ein Makro

#define _XS(x,y)        x |= 1<<y

wird es angewendet, so ergibt sich

   PORTC |= 1 << 3