"wenn Ausgang != Eingang mach was" - Brett vorm Kopf

[Danny (Gast)]

Hey zusammen, einen schönen Sonntag wünsche ich!

Ich möchte eine Schützüberwachung realisieren, sprich feststellen wenn 
ein angesteuertes Schütz entweder kleben bleibt oder nicht anzieht.

Das Schütz wird mit log.1 angesteuert, der Eingang liefert bei 
Ansteuerung log.0.

Eigentlich ganz einfach dachte ich. Denn wenn beide Signale log.1 sind 
oder beide log.0 sind liegt ein Fehler vor (natürlich wird die 
Ansprechzeit des Schützes berücksichtigt).


Ich dachte diese Zeile wär der Schlüssel zum Erfolg...

if( (PINB & (1<<PB2)) == (PINC & (1<<PC0)) )

...aber die Geschichte klappt nur beim klebenbleiben des Schützes, 
sprich Ausgang=0 und Eingang=0 (angesteuert). Für den entgegengesetzten 
Fall klappt es nicht...

Ich habe alle möglichen Umstellungen, XOR mit Negierung probiert, sehe 
aber nun nach 1,5 Std den Wald vor lauter Bäumen nicht mehr.

Hat jemand von Euch einen Tipp für mich?

Danke und Gruß
Danny

[Michael U. (amiga)]

Hallo,

passt doch alles...

(PINB & (1<<PB2)) ergibt 0x00000100
(PINC & (1<<PC0)) ergibt 0x00000001

warum sollte da ein Vergleich wahr werden?

Ich vermute jetzt mal, Du findest selbst eine Lösung?

Gruß aus Berlin
Michael

[Stefan E. (sternst)]

(PINB & (1<<PB2) ist entweder 0 oder 4, je nach Zustand des Bits.
(PINC & (1<<PC0) ist entweder 0 oder 1, je nach Zustand des Bits.
Jetzt klarer, warum deine Zeile nicht funktioniert?

Wenn du auf logische Gleichheit prüfen willst, muss beides auf 0/1 
reduziert werden.

[Danny (Gast)]

ich war der Meinung bei das beim Vergleich (==) der Ausdruck in den 
Klammern in 0/1 umgesetzt, bzw. so gewertet wird... und nun fragt bitte 
nicht warum :)


wie schaut denn für diesen Fall eine elegante Lösung aus?
Folgendes ist denke ich leicht verständlich und funktioniert aber platt 
gefragt: "macht man das so"?   :)

if( ((PINB & (1<<PB2))>>PB2) == (PINC & (1<<PC0)) )

[Stefan E. (sternst)]

Viele Wege führen nach Rom:

(PINB&(1<<PB2))>>PB2
(PINB&(1<<PB2))?1:0
!!(PINB&(1<<PB2)
(PINB&(1<<PB2))==(1<<PB2)
(PINB&(1<<PB2))!=0
(PINB&(1<<PB2))>0
(_Bool)(PINB&(1<<PB2))

Nimm einfach den, der dir am besten gefällt.

[Sam .. (sam1994)]

Viel andere Möglichkeiten hast du in C nicht (Das meiste von Stefan ist 
umgestellt), außer irgendetwas exotisches:

if((PINB | PINC) & ((1<<PB2)|(1<<PC0)) - 1 >= 4) //PB2 == PC0

[Stefan E. (sternst)]

Samuel K. schrieb:
> Das meiste von Stefan ist umgestellt

Was meinst du damit? Das sind alles Möglichkeiten, um die linke Seite 
des == von 0/4 auf 0/1 zu reduzieren.

[Jim M. (turboj)]

Was spricht dagegen, einfach alles zur 1 zu shiften?

if( (PINB >> PB2)&1) == (PINC >>PC0) &1 )

Das scheint mir die kürzeste Variante zu sein.

[Sam .. (sam1994)]

Stefan Ernst schrieb:
> Was meinst du damit? Das sind alles Möglichkeiten, um die linke Seite
> des == von 0/4 auf 0/1 zu reduzieren.

Das gleiche Prinzip. Das Grundgerüst der Prüfung (=Vergleich der Bits) 
bleibt gleich.

[Stefan E. (sternst)]

Samuel K. schrieb:
> Das gleiche Prinzip. Das Grundgerüst der Prüfung (=Vergleich der Bits)
> bleibt gleich.

Achso. Jedenfalls funktioniert dieses "Grundgerüst" wenigstens, im 
Gegensatz zu deiner Lösung. ;-)

[Danny (Gast)]

Hey,

vielen Dank für Eure schnelle Hilfe!

Ich habe es nun beim >>PB2 gelassen, nun wirds wenigstens ein 
entspannter Abend :)

[Simon K. (simon)]

Leute, Leute, Leute. Code muss selbsterklärend sein!

Was spricht gegen:

if ( ((PINB & (1<<PB2)) &&  (PINC & (1<<PC0)))
 || !((PINB & (1<<PB2)) && !(PINC & (1<<PC0))) )
{ 
    Alles in Ordnung
}else
{   
    Unterschiedlich
}

Ist allerdings ungetestet.

[Sam .. (sam1994)]

Ersetze das && durch || und es funktioniert.

Ich finde es kryptischer. Ich finde Code sollte kurz sein, dann muss man 
weniger lesen.

[Stefan E. (sternst)]

Samuel K. schrieb:
> Ersetze das && durch || und es funktioniert.

Nein, das passt schon so, außer dass das erste ! etwas verrutscht ist.
!(( -> (!(

[Stefan E. (sternst)]

Simon K. schrieb:
> Leute, Leute, Leute. Code muss selbsterklärend sein!

"selbsterklärend" liegt aber zum Teil auch im Auge des Betrachters. ;-)

Ich würde z.B. folgende Variante als noch "selbsterklärender" 
favorisieren:

if ((_Bool)(PINB & (1<<PB2)) == (_Bool)(PINC & (1<<PC0)))

[Sam .. (sam1994)]

Stimmt, ich war irgendwie beim bitweisen &.

Da fällt mir ein: Warum nicht kompliziert? Dann lernt man wenigstens 
komplizierter zu denken.

[Simon K. (simon)]

Stefan Ernst schrieb:
> Simon K. schrieb:
>> Leute, Leute, Leute. Code muss selbsterklärend sein!
>
> "selbsterklärend" liegt aber zum Teil auch im Auge des Betrachters. ;-)
>
> Ich würde z.B. folgende Variante als noch "selbsterklärender"
> favorisieren:
>

if ((_Bool)(PINB & (1<<PB2)) == (_Bool)(PINC & (1<<PC0)))

Und was ist _Bool? Wo gibt es den Datentyp? Und zwar in einer derartigen 
Definition, dass er das von dir gewünschte Verhalten erzeugt?

[Simon K. (simon)]

Samuel K. schrieb:
> Stimmt, ich war irgendwie beim bitweisen &.
>
> Da fällt mir ein: Warum nicht kompliziert? Dann lernt man wenigstens
> komplizierter zu denken.

Aus einem einfachen Grund: Wartbarkeit. Wenn man irgendwann mal wieder 
nach ein paar Jahren was ändern oder debuggen möchte und dann sowas 
sieht:

(PINB&(1<<PB2))>>PB2

Dann ist man erst mal damit beschäftigt das Statement zu verstehen. Da 
das Statement aber nicht viel "Geschäftslogik" in sich verbirgt ist das 
sinnlos verschwendete Lebenszeit.

[Stefan E. (sternst)]

Simon K. schrieb:
> Und was ist _Bool? Wo gibt es den Datentyp? Und zwar in einer derartigen
> Definition, dass er das von dir gewünschte Verhalten erzeugt?

Im C-Standard seit C99.

[Simon K. (simon)]

Stefan Ernst schrieb:
> Simon K. schrieb:
>> Und was ist _Bool? Wo gibt es den Datentyp? Und zwar in einer derartigen
>> Definition, dass er das von dir gewünschte Verhalten erzeugt?
>
> Im C-Standard seit C99.

Okay, dann ist die Variante lesbarer. Vorausgesetzt man kennt den _Bool 
Typen. ;-)

Wenn C99, dann sollte der GCC (das gewählte Subforum) das auch 
unterstützen.

[Peter D. (peda)]

if( !(PINB & (1<<PB2)) == !(PINC & (1<<PC0)) )

Die Erklärung ist, der !-Operator liefert 0 (falsch) oder 1 (wahr) als 
Ausgabe.
Als Eingabe gilt aber 0 = falsch, !0 = wahr.
Er wandelt also int in bool um.

In diesem Fall stört die Negation nicht, da auf beiden Seiten.
Profis schreiben oft auch:

if( !!(PINB & (1<<PB2)) == !!(PINC & (1<<PC0)) )

Damit entfällt die Negation und man wird mit dem Holzhammer drauf 
hingewiesen, das bool rauskommen soll.


Peter