Richtig XORen

Das Problem ist mit AND bekomme ich meine 0, jedoch nie wieder eine 1.
Was ich suche ist die Möglichkeit festzustellen ob ein Bit in den 4 
Eingangsbytes gekippt ist und wenn ja soll diese Bitposition im 
Staatusbyte getoggelt werden.

MFG Peter

1

status = byte1 & byte2 & byte3 & byte4;

würde genau das machen, was du oben in der Tabelle hast. Wenn du alle 
stellen, die in mindestens einem der vier Bytes 0 ist, nur toggeln und 
nicht auf 0 setzen willst, dann könntest du sowas machen:

1

status ^= ~(byte1 & byte2 & byte3 & byte4);

Allerdings bin ich auch der Meinung, dass ein einfaches AND genau das 
ist, was du suchst.

Ich versuch es nochmal genauer zu beschreiben.
Ich beschränke mich jetzt mal auf 2 Byte...

1.Fall das 6.Bit in Byte 1 ist 0 geworden.

Byte1  10111111
Byte2  11111111   mit AND lösbar
Status 10111111

2.Fall das 6.Bit in Byte 1 ist 1 geworden.

Byte1  111111111
Byte2  101111111  nicht mit AND lösbar
Status 111111111

Ich möchte sozusagen auswerten ob ein Bit 0 oder 1 wird und genauso soll 
das Bit im Statusbyte kippen.

MFG
Peter

Darum steht dort ja auch nicht mit AND lösbar

Also willst du im Statusbyte nur die Nullen aus Byte1 haben und nicht 
aus Byte2? Ich verstehe einfach nicht, warum in deinem zweiten Beispiel 
im zweiten Fall das Statusbyte komplett auf 1 sein soll.

Schreib doch mal exakt auf, was du möchtest bisher sehe ich folgende 
Funktion:

1

Byte1 | Byte2 | x

2

------+-------+-----

3

    0 |     0 | dont care

4

    0 |     1 | 0

5

    1 |     0 | 1

6

    1 |     1 | dont care

7

8

--> x = Byte1

Peter schrieb:
> Das Statusbyte soll also die Nullen in den 4 Einzelbytes finden, ist
> keine 0 vorhanden soll alles 1 sein.

Hier schreibst du, dass wenn keine 0 ist, dann soll alles 1 sein.

Peter schrieb:
> 2.Fall das 6.Bit in Byte 1 ist 1 geworden.
>
> Byte1  111111111
> Byte2  101111111  nicht mit AND lösbar
> Status 111111111

Hier macht du ein beispiel, wo trotz 0 alles 1 ist. Also irgendwie ist 
da noch ein hänger drin.

So wie ich dich verstanden habe, möchtest du Veränderungen im 
Eingangszustand feststellen. Dazu benötigst Du auf jeden Fall 
Zwischenspeicher, musst also irgend welchen vorausgegangenen Zustände 
speichern (sonst lässt sich ja keine Veränderung feststellen).

OK, so weit so gut. Wir können das Problem ja einfach auf eine Bitfolge 
reduzieren (entspricht einer Bitspalte in Deinen Darstellungen).

Wenn ich jetzt Deine Anforderungen richtig verstanden habe, soll, falls 
ein beliebiges Bit 0 wird, das Statusbit auch 0 werden. Wenn noch 
zusätzliche Bits 0 werden, soll das Statusbit 0 bleiben. Wenn hingegen 
irgend ein Bit seinen Zustand auf 1 wechselt, soll das Statusbit 
ebenfalls 1 werden.

So lange keine Änderungen im Eingangszustand auftreten, soll der Status 
ebenfalls unverändert bleiben.

Habe ich die Aufgabe so richtig verstanden?

Was machst Du dann, wenn ein Bit von 0 auf 1 wechselt, ein anderes dafür 
jedoch von 1 nach 0?

Das wäre noch zu klären.

Mhh es gibt 32 Eingänge diese sind in 4 Gruppen a 8 Inputs aufgeteilt.

Byte1 = 1. Gruppe
Byte2 = 2. Gruppe
Byte3 = 3. Gruppe
Byte4 = 4. Gruppe

Diese 32 Inputs sollen 8 Ausgänge schalten. Dabei soll die Funktion 
ähnlich eines Stromstossrelais sein.
Da die 4 Gruppen sich untereinander nicht unterhalten können, muss der 
µC die Zustände synchronisieren.

Die Schalter besitzen eine eigene Elektronik und liefern die Zustände 
zurück, die sie seit dem letzten Auslesen gespeichert haben.

Jetzt sollen alle 4 Gruppen auf einen Stand gebracht werden.
Der µC liest alle 4 Gruppen aus und soll die Änderungen seit dem letzten 
auslesen feststellen. Daraus soll der aktuellen Stand ermittelt werden, 
diesen Zustand schickt er dann an die 4 Gruppen zurück, da diese die 
Zustände visualisieren.

Wenn mich nicht alles täuscht möchtest du die Flanken erkennen und den 
Status entsprechend der Richtung setzen, falls eine aufgetreten ist.
Wenn ich mich nicht vertan habe:

1

status = (byte1 & status) | (~old_byte1 & ~byte1 & status) | (~old_byte1 & byte1 & ~status);

2

old_byte1 = byte1;

3

status = (byte2 & status) | (~old_byte2 & ~byte2 & status) | (~old_byte2 & byte2 & ~status);

4

old_byte2 = byte2;

5

...

bzw.

1

edge1 = old_byte1 ^ byte1;

2

status &= ~(edge1); // clear all edges

3

status |= (edge1 & byte1); // set all positive edges

4

old_byte1 = byte1;

5

6

edge2 = old_byte2 ^ byte2;

7

status &= ~(edge2); // clear all edges

8

status |= (edge2 & byte2); // set all positive edges

9

old_byte2 = byte2;

10

...

Wenn du nur 1-en übertragen willst und auf
fehlerhafte o-en prüfen musst, dann ist das doch
Quatsch. Erzeuge die 1-en doch gleich im Empfänger.

Normalerweise prüft man nicht, ob aus einer 1 mal
eine 0 geworden ist, sondern, ob sich Bits geändert
haben.

Das hat man mal mit Quer- und Längsparität gemacht,
heute wird CRC bevorzugt.

Wenn bei dir aber 0 & 1 nicht das gleiche Ergebnis
hat, wie 1 & 0, dann ist da ein Problem auf der
Platine,  ... oder es sitzt davor.