Um nun nicht jedesmal alle Bits vom Eingang testen zu müssen, ist es sinnvoll, abzufragen, ob überhaupt eine Änderung stattgefunden hat. Dies erledigt eine Function und liefert die Bits, die sich geändert haben.
Wir brauchen uns nur merken, wie der alte gelesene Wert war. Für die nun kommenden Prüfungen benötigen wir weitere globale Variable
Delphi-Quellcode:
Old_In_Val : Byte; // In CreateForm wird Wert 0 zugewiesen
Event_Byte : Byte; // In CreateForm wird Wert 0 zugewiesen
Event_Flag_High : Byte; // In CreateForm wird Wert 0 zugewiesen
Event_Flag_Low : Byte; // In CreateForm wird Wert 0 zugewiesen
Und für die Abarbeitung und Anzeige ein paar Strings
Delphi-Quellcode:
High_Flag_Str : string; // In CreateForm wird Wert '00000000' zugewiesen
Low_Flag_Str : string; // In CreateForm wird Wert '00000000' zugewiesen
Und nun geht es los. Mit der Function
Bit_Changed bekommen wir die geänderten Bits, unabhängig von der Signallage;
Delphi-Quellcode:
function Bit_Changed(Old_Byte, New_Byte: Byte): Byte;
var
Ausg: Byte;
begin
Ausg := (Old_Byte xor New_Byte);
Bit_Change := Ausg;
end;
Beispiel:
Code:
alt = '10011011'
neu = '10101100'
Xor – Wahrheitstabelle:
Code:
Bit A Bit B Ergebnis
------------------------------
0 0 0
1 0 1
0 1 1
1 1 0
Anhand der Wahrheitstabelle erkennt man, wie's funktioniert: nur ungleiche Bit ergeben eine '1'. Bei der Anweisung
Old_Byte xor New_Byte werden beide Bytes Bit für Bit verglichen.
Und so sieht's aus:
Code:
alt = '10011011'
neu = '10101100'
---------------------
geändert = '00110111'
Mit dem Aufruf
Bit_Is_Changed ( alter gelesenen Wert , EventByte) erhalte ich die Bits 1 nach 0
sowie mit
Bit_Is_Changed ( neuer gelesenen Wert , EventByte) erhalte ich die Bits 0 nach 1
Delphi-Quellcode:
function Bit_is_Changed(Change_Byte, Ref_Byte: Byte): Byte;
var
Ausg: Byte;
begin
Ausg := Change_Byte and Ref_Byte;
Bit_is_Changed := Ausg;
end;
Auch hier wieder die Erklärung:
And – Wahrheitstabelle:
Code:
Bit A Bit B Ergebnis
------------------------------
0 0 0
1 0 0
0 1 0
1 1 1
Erinnern wir uns:
Code:
alt = '10011011'
neu = '10101100'
geändert = '00110111'
Schauen wir mal
Code:
was ist von '0' nach '1' und von '1' nach '0' gewechselt:
neu = '10101100' alt = '10011011'
geändert = '00110111' geändert = '00110111'
--------------------- ---------------------
Ergebnis = '00100100' Ergebnis = '00010011'
Logisch, da 5 Bit geändert wurden muss Ergebnis Änderung '0' -> '1' und '1' -> '0' in der Summe 5 ergeben.
Also 2 Änderungen '0' -> '1' und 3 Änderungen '1' -> '0'.
Passt !
Also, das neue Bit mit '1' und dem zugehörigen Änderungs – Bit mit '1' muss einen Wechsel von
logisch '0' nach '1' und das alte Bit mit '1' und dem zugehörigen Änderungs – Bit mit '1' muss einen Wechsel von
logisch '1' nach '0' gehabt haben.
Diese Ergebnisbytes lassen sich nun abarbeiten und die auf '1' gesetzten Bit nach Bearbeitung löschen.
Dadurch reagiere ich nur auf die Ereignisse und kann mir ständige if... then ... Anweisungen sparen.