boolsche Variable

In C geht das (soweit ich weiß) mangels Operatorüberladung nicht. Du
müsstest also auf (mehrere) Makros ausweichen.

In C++ könnte man zum Beispiel eine Klasse schreiben, die die von dir
verlangten Operatoren überlädt.

> Es gab mal sowas schönes wie boolsche Variable.

Gibt's in C99 übrigens auch.  Anders als in C++ (wo es ein
Standardtyp
ist) muss man in C #include <stdbool.h> machen, danach hat man den Typ
"bool" und die Werte "false" und "true" definiert.

> Die Frage: Wenn ich ein Bit z.B. PORTD,PD7 so z.B. durch eine define
> "vorbereiten", dass es genau so funktioniert, wie "test", wenn
wir
> mal davon ausgehen das die Zuweisung über = erfolgt und der
Vergleich
> über ==

Du meinst sowas?

#define PORTTEST (PIND & _BV(PD7))

...
  if (PORTTEST) {
    ...
  }

(Ich nehme mal an, du wolltest PIND testen und nicht PORTD. ;-)

> geht sowas und wenn ja, wie?

Wie oben geschrieben, mit C geht das nicht.
Der Zuweisungsoperator hat in C eine genau festgelegte Bedeutung. Da es
keine "1-Bit-Variable" gibt (zumindest keinen Zeiger darauf), kann man
nur mit dem Zuweisungsoperator allein kein einzelnes Bit verändern.

Hier mal ein kleines Beispiel, wie es doch funktionieren könnte!
In wie weit das aber Portabel ist, kann ich nicht sagen. Die Idee kam
mir ganz spontan, als ich mich an einen anderen Thread erinnerte.

1

#include <avr/io.h>

2

#include <stdbool.h>

3

4

typedef struct

5

IOPort8Bit_s {

6

        unsigned char pin0:1;

7

        unsigned char pin1:1;

8

        unsigned char pin2:1;

9

        unsigned char pin3:1;

10

        unsigned char pin4:1;

11

        unsigned char pin5:1;

12

        unsigned char pin6:1;

13

        unsigned char pin7:1;

14

} IOPort8Bit_t;

15

16

IOPort8Bit_t *porta_mirr = (IOPort8Bit_t *)(&PORTA);

17

IOPort8Bit_t *pina_mirr = (IOPort8Bit_t *)(&PINA);

18

19

int

20

main(void)

21

{

22

        DDRA = 0xff;

23

24

        porta_mirr->pin1 = true;

25

        porta_mirr->pin2 = false;

26

27

        for(;;)

28

        {

29

                /* if(pina_mirr->pin1) or: */

30

                if(pina_mirr->pin1 == true)

31

                {

32

                        porta_mirr->pin0 ^= 1;

33

                }

34

        }

35

36

        /* NEVEREACHED */

37

        return 1;

38

}

Darum geht es ja nicht, er möchte definitiv nur ein Bit einer Variablen
manipulieren...

Noch ein Detail am Rande. Ich glaube nicht, daß man so:
#define TRUE 1
#define FALSE !TRUE
True und False definieren sollte.

Besser ist:
#define TRUE (1==1)
#define FALSE (1==0)
somit wird TRUE und FALSE genauso definiert wie der Compiler selbst
intern auch die Werte darstellt.

Ist alles Quark. :-)

Unter C99 nimmt man eh' <stdbool.h> (und schreibt boot, true, und
false, also alles klein).

Ansonsten kannst du in de.comp.lang.c nachfragen, warum die
sinnvollsten Definitionen

#define TRUE 1
#define FALSE 0

heißen.

Ok, gut, dann kommt jetzt die Preisfrage an Dich:

  Was passiert in dem von mir eingefügten Code?

> Was passiert in dem von mir eingefügten Code?

Er wird nicht garantiert funktionieren, weil du das volatile
vergessen hast. ;-)  IO-Register (die ja intern erstmal wie
Speicheradressen behandelt werden) müssen volatile sein.

Ansonsten ist ein bit field durchaus eine Möglichkeit dafür, ja.
Allerdings verliert der Compiler durch die zusätzlich eingefügten
Pointervariablen den Überblick, dass es sich um IO-Register handelt,
sodass er keine IO-Befehle mehr optimieren kann (IN, OUT, SBI, ...).
Besser ist daher

1

#define porta_mirr  ((volatile IOPort8Bit_t *)(&PORTA))

2

#define pina_mirr   ((volatile IOPort8Bit_t *)(&PINA))

>Hab ich gesagt, dass Dein Code schlecht, oder falsch ist?

Nein, hast Du nicht.
Bitte nicht gleich wieder unter die Decke gehen ;)

Ich passe den Code mal ein bißchen auf Deine spärlichen Angaben an,
damit Du das evtl. besser verstehst:

1

#include <avr/io.h>

2

#include <stdbool.h>

3

4

typedef struct

5

Register8Bit_s {

6

        unsigned char flag1:1;       /* irgendein flag      */

7

        unsigned char flag2:1;       /* irgendein flag      */

8

        unsigned char transmitter:1; /* transmitter ein/aus */

9

        unsigned char receiver:1;    /* receiver ein/aus    */

10

} Register8Bit_t;

11

12

Register8Bit_t reg;                  /* 'Register' anlegen  */

13

14

int

15

main(void)

16

{

17

        reg.transmitter = true;

18

        reg.receiver = false;

19

20

        for(;;)

21

        {       /* Endlosschleife */

22

                if(reg.flag1 == true)

23

                {       /* wenn flag1 gesetzt dann */

24

                        reg.flag2 ^= 1; /* toggle das andere */

25

                }

26

        }

27

28

        /* NEVEREACHED */

29

        return 1;

30

}

Oha, wie peinlich!

Jörg hat natürlich völlig Recht. Ich habe das 'volatile' auch im
zweiten Code vergessen. Vermutlich würde im 2. Code einfach so ziemlich
alles wegoptimiert...

So wäre besser:

1

volatile Register8Bit_t reg;         /* 'Register' anlegen  */

Ah, ok, ich wusste, daß ich was vergessen/übersehen hatte :-)

In Zeile 12:
Ersetze diese Zeile durch

1

#define reg ((volatile Register8Bit_t *)(&GPIOR2))

Das kostet Dich kein einziges Bit mehr Speicher.
'reg' kannst Du natürlich nach Lust und Laune umbenennen, so lange Du
 keinen bereits vergebenen 'Namen' auswählst.