bits GELICHZEITIG setzen und löschen als Einzeiler?

So sollte das funktionieren:
FLAGS = (FLAGS | ((1<<BIT5) | (1<<BIT1)) & ~((1<<BIT3) |(1<<BIT2))
(Einfach klammern, wie in der Mathematik...)

Ich finde das allerdings deutlich weniger übersichtlich als die
"ausführliche" Variante. Im compilierten Code ergeben sich damit
sicher auch keine Vorteile.

> GPS_STATUS musste ich als 'volatile' deklarieren, sonst hat der
> Compiler schlicht weg garnichts gemacht.

Dann hast du das Ergebnis wohl nicht weiter benutzt.

Das geht kompakter:

   if (((GPS_STATUS & (1<<RMC_OK)) == (1<<RMC_OK)) && ((GPS_STATUS &
   (1<<GGA_OK))== (1<<GGA_OK)))

kann auch als

   if ((GPS_STATUS & (1<<RMC_OK)) && (GPS_STATUS & (1<<GGA_OK)))

geschrieben werden. Da in beiden Teilausdrücken GPS_STATUS mit nur
einem Bit verANDet wird, genügt es, auf != 0 abzufragen.

Das macht das doch schon ein bisschen lesbarer, oder?

> Ja, ich hatte die Variable noch nicht "in Verwendung".

Dann ist der Compiler wirklich eifrig im Wegoptimieren.  volatile kann
dagegen helfen, man sollte nur dran denken, es wieder rauszuwerfen,
wenn der Code fertig ist.

> Ich werde mir mal die Bitfields (hiess doch so?) ansehen. Damit
> gehts vielleicht einfacher.

Ja, für derartige Flags nehme ich gern mal bit fields.

> Bin noch am lernen. sprintf für Debugausgaben ist ja wohl der
> Hammer!  Da platzt mein kleiner Mega48 ja sofort aus allen Nähten
> :-((

Debuggen sollte man auch nicht auf einem ATmega48.  Fürs Debuggen kann
man nie genug Ressourcen frei haben.  Nimm einen ATmega168, der ist
pin- und funktionskompatibel bei deutlich mehr Speicher.

printf() ist halt vom Prinzip her riesig, da die Entscheidung, was von
den Möglichkeiten wirklich benötigt wird, erst zur Laufzeit feststeht.

> Dabei wollte ich unterwegs nur Grad, Minuten und sekunden
> (Länge/Breite) in eine ganzzahl wandeln und mit der von Zuhause
> vergleichen. Das kann ich mir wohl in "C" und mit dem Mega48
> abschminken - schade...

Oder halt mit itoa() arbeiten, da hast du eben nur keine netten Dinge
wir Vornullen etc.

Zahlenausgabe :P


http://www.mikrocontroller.net/forum/read-4-46127.html#new

> Das geht kompakter:
>
>    if (((GPS_STATUS & (1<<RMC_OK)) == (1<<RMC_OK)) && ((GPS_STATUS &
>    (1<<GGA_OK))== (1<<GGA_OK)))
>
> kann auch als
>
>  if ((GPS_STATUS & (1<<RMC_OK)) && (GPS_STATUS & (1<<GGA_OK)))

Oder noch ne Variante:
Wenn man Schreibarbeit sparen möchte, kann man sich oft mit einem
Makro helfen (auch wenn ich nicht so ein Fan von Makros bin, na ja
von C++ halt 'verdorben' )


#define BIT_SET( Where, What ) ( Where & (1<<What) == (1<<What) )

Dann schreibst du

   if( BIT_SET( GPS_STATUS, RMC_OK ) &&
       BIT_SET( GPS_STATUS, GCA_OK ) )

Wobei ich sagen muss, dass ich solche && oder || verknüpfte
logische Ausdrücke überhaupt gerne auf 2 Zeilen aufteile.

Warum so umständlich?

  #define BIT_SET( Where, What ) ( Where & (1<<What) == (1<<What) )

Den Vergleich kann man sich hierbei schenken

  #define BIT_SET( Where, What ) ( Where & (1<<What))

da nur ein Bit abgefragt wird.

Ein blöder Compiler macht daraus womöglich einen richtigen Vergleich,
statt einfach auf 0 bzw. Nichtnull zu testen.

Ich würde allerdings bei der Namenswahl auch noch etwas länger
nachdenken, es geht ja nicht darum, ein Bit zu setzen, sondern um zu
testen, ob es gesetzt ist. Das nur am Vertauschen von "bit" und
"set" festzumachen ...

> Warum so umständlich?

:-)

Weil es immer wieder Programmierer gibt, die sich in den
Fuss schiessen.
Im Ernst. Ich hab vor Jahren den Vergleich mal weggelassen.
Prompt hat ein Kollege das hier gebaut (sinngemaess):


  int NrBitsSet = BIT_SET( PORTA, 2 ) +
                  BIT_SET( PORTA, 3 ) +
                  BIT_SET( PORTA, 4 );

  if( NrBitsSet > 1 )  // wenn mindestens 2 von 3 gesetzt sind

> BIT_IS_SET klingt gut

Meist zieht man das IS vor:

  IS_BIT_SET

Alle Dinge die mit 'IS' beginnen sind 'Prädikate' (liefern
also eine Ja/Nein Aussage). Ist aber nur so eine Konvention.

> C++ ist sogar noch viel cooler.

Da steh ich voll drauf :-)

> Man kann doch nicht einfach so eine neue Zeile anfangen?
> Nun, offensichtich doch -

Klar kann man.
Wenn dein Compiler deinen Source Code in die Finger
kriegt (nach dem Präprozessor), dann ist das erste
was er macht: Er ersetzt den sog. 'Whitespace' durch
genau ein Leerzeichen. Whitespace sind Sequenzen, die
nur aus Leerzeichen, Tabulatoren, Zeilentrenner bestehen.
Oh. Vorher werden, glaub ich, noch Kommentare durch ein Leerzeichen
ersetzt.

d.h. Dein Compiler macht aus dem hier

   int i;
   int j;
   for( i = 0; i < 8; ++i )
     j = 5;

das hier:

  int i; int j; for( i = 0; i < 8; ++i ) j = 5;

Gibt auch keinen Grund das nicht zu tun. Der Compiler
wird durch die C Grammatik udnd die ';' geleitet
und nicht durch die Zeilentrenner.

Fortran ist da noch konsequenter: Alle Leerzeichen (natuerlich
nicht in Strings) werden entfernt bevor die Anweisung
übersetzt wird.
d.h. man kann in Fortran auch so schreiben:

      I N T E G E R * 4   ALPHA
      R E A L * 8         BETA

      BETA = A L P H A  *  2

man kann aber auch so schreiben :-)

      INTEGER*4ALPHA
      REAL*8BETA
      BETA=ALPHA*2

> das hier:
>
>  int i; int j; for( i = 0; i < 8; ++i ) j = 5;

Na ja. Er macht es nicht wirklich. Aber er tut so als ob.

Dazu fällt mir nur noch ein:

Real programmers can program FORTRAN in any language.

:-)