Bits eines Ports abfragen

[Holle (Gast)]

Hallo zusammen, ich hab ein problem mit meinem code und finde den fehler
nicht.

if ( ( PIND & (1<<PIND1) ) & ( PIND & (1<<PIND2) ) )
{
}
der soll quasi in die schleife springen, wenn pin1 und pin2 von port D
1 ist. macht er aber nicht.

schreibe ich statt dem & ein oder, dann spingt bei pin1 oder pin2 in
die schleife.
if ( ( PIND & (1<<PIND1) ) | ( PIND & (1<<PIND2) ) )
{
}

wie man im anhang sieht hab ich das auch mit dem bit_is_set und einem
strckt versucht, aber immer ohne erfolg.

bin für jede hilfe dankbar

[Peter D. (peda)]

&&

Peter

[Holle (Gast)]

ohmann, da hätte ich auch selber drauf kommen müssen. mal wieder den
wald vor lauter bäumen nicht gesehen.

[Rolf Magnus (Gast)]

Ich würd's gleich so schreiben:

if (PIND & ((1 << PIND1) | (1 << PIND2)))
{
}

[johnny.m (Gast)]

> if (PIND & ((1 << PIND1) | (1 << PIND2))){}

Das wird aber auch ausgeführt, wenn nur einer der beiden Pins gesetzt
ist.
Holle will aber nur, wenn beide gesetzt sind...

[Rolf Magnus (Gast)]

>> if (PIND & ((1 << PIND1) | (1 << PIND2))){}
>
> Das wird aber auch ausgeführt, wenn nur einer der beiden Pins
> gesetzt ist.

Nein.

> Holle will aber nur, wenn beide gesetzt sind...

Genau das tut es auch. Der einzige Unterschied ist, daß bei meiner
Variante das Lesen des Registers atomar ist, weil nur ein einziger
Lesezugriff stattfindet, während Holle zwei getrennte Lesezugriffe hat
und damit nicht testet, ob die Bits gleichzeitig, sondern kurz
nacheinander 1 sind.

[johnny.m (Gast)]

Hallo Rolf,
(1 << PIND1)|(1 << PIND2) gibt 0b00000110. Und das mit PIND verundet
gibt auch dann etwas logisch wahres, wenn nur PIND1 oder PIND2
gesetzt ist!

(Beispiel: Wenn PIND 0b00000100 ist (PIND2 gesetzt und PIND1 nicht)
gibt die Verknüpfung mit 0b00000110 -> 0b00000100 und das ist logisch
wahr, also wird das was in den {} steht ausgeführt!!!)

Wenn Du schreibst
if((PIND & ((1 << PIND1) | (1 << PIND2))) == ((1 << PIND1) | (1 <<
PIND2))){}
dann stimmts, ist aber ein bisschen länglich...

[Rolf Magnus (Gast)]

> (1 << PIND1)|(1 << PIND2) gibt 0b00000110.

Ja.

> Und das mit PIND verundet gibt auch dann etwas logisch wahres,
> wenn nur PIND1 oder PIND2 gesetzt ist!

Hmja, hast recht. Ich hab Blödsinn erzählt. Weiß nicht, wie ich darauf
gekommen bin.

> Wenn Du schreibst
> if((PIND & ((1 << PIND1) | (1 << PIND2))) == ((1 << PIND1) | (1 <<
> PIND2))){}
> dann stimmts, ist aber ein bisschen länglich...

Allerdings. Dafür ist es dann aber wirklich atomar.

[Holle (Gast)]

struct {
unsigned char Fahrstatus:4; // 4 Bit für 4 Fahrbefehle in verschiedenen
kombinationen
unsigned char ES1vorne:1; // 1 Bit für Endschalter 1 vorne belegt
...
    } x;

  x.Fahrstatus = PIND; // soll pin0 bis pin3 beinhalten, was auch geht
  x.ES1vorne = ( PIND & (1<<PIND4) ); // soll den wert von pin4 haben
  ...


if  ((x.Fahrstatus == 1) && !(x.ES1vorne))
// so hätte ich das gerne, aber (x.ES1vorne) spricht nicht an
    {...}


if  ((x.Fahrstatus == 1) && !( PIND & (1<<PIND4) ))
// diese variiante läuft zwar, will ich aber eigendlich nicht
    {...}

wäre nett wen ihr mir da nochmal helfen könnt. ist wahrscheinlich
wieder nur so ein kleiner denkfehler

[Karl heinz B. (kbucheg)]

Was hältst du von ein bischen Macro-Woodo

#define Fahrstatus ( PIND & ( ( 1 << PIND0 ) |  \
                              ( 1 << PIND1 ) |  \
                              ( 1 << PIND2 ) )

#define ES1vorne ( PIND & ( 1 << PIND4 ) )


dann kannst du schreiben

  if( Fahrstatus == 1 && ! ES1vorne ) {
    ...
  }

Wahrscheinlich würde ich mir dafür aber einfach nur Funktionen
machen:

unsigned char Fahrstatus()
{
  return PIND & ( ( 1 << PIND0 ) |
                  ( 1 << PIND1 ) |
                  ( 1 << PIND2 ) );
}

unsigned char ES1vorne()
{
  return PIND & ( 1 << PIND4 );
}

und dann schreiben

   if( Fahrstatus() == 1 && !ES1vorne() ) {
     ...
   }

Dadurch, dass der Compiler die Funktionen wahrscheinlich
sowieso auflöst, ensteht zur Laufzeit keine Mehrbelastung
und die Wartbarkeit ist auf lange Sicht besser.