Step 7 Step 7 Parität aus Word, Byte und 4 Bits ermitteln

andrasch · 23 Oktober 2019

Hallo,

Mein Problem: Ich muss die Parität aus einem Word, Byte und 4 Bits im Step 7 ermitteln. Mein Lösungsansatz wäre das Word und Byte im FB in einer temporären Struct umzukopieren und dann mit einem XOR alle Bits zusammen abfragen.

Hättet ihr bessere Vorschläge bzw. ist mein Ansatz überhaupt richtig?

Dankeschön für jegliche Hilfe

MFreiberger · 23 Oktober 2019

Moin andrasch,

wenn es um Paritätsbit geht: das gibt ja Auskunft darüber, ob die Anzahl der Bits in einen Datenbereich, die high sind gerade oder ungerade sind.
Obwohl noch die Frage ist, ob Even-Parity oder Odd-Parity ausgewertet werden soll (also Anzahl 'Einsen' gerade/ungerade oder Anzahl 'Nullen' gerade/ungerade).

Grundsätzlich musst Du zählen, wie oft ein bestimmter Bitzustand ansteht.

Dazu könntest Du z.B. eine Schleife mit x Durchläufen (= Anzahl der Bits) durchlaufen und die Bitfolge immer um eine Stelle weitershiften. Nach jedem recht-Shiften dann zu einem Zählwert das Niederwertigste Bit, je nach Zustand hinzuaddieren. Wenn die Schleife durchgelaufen ist, weißt Du z.B. wie viele TRUE-Bits in dem Datenfeld enthalten sind.

VG

MFreiberger

P.S.: vgl. dazu https://de.wikipedia.org/wiki/Paritätsbit

Peter Wahlen · 23 Oktober 2019

Hallo,

wenn Du eine 1500er hast, könntest Du auch mit BITSUM arbeiten.

Dein Vorschlag mit XOR (alle Bits in einem word / DWord) müsste auch funktionieren.

PN/DP · 23 Oktober 2019

Man muß nicht naiv die Bits zählen, man kann auch das Word + Byte + 4 Bits in ein 32-Bit-DWORD kopieren (oder AT) und dann mit Wordverknüpfung XOW in wenigen Schritten die Bits des DWORD untereinander XOR-verknüpfen.

Algorithmus: "Compute parity in parallel" oder "Compute parity of word with a multiply "
http://graphics.stanford.edu/~seander/bithacks.html#ParityMultiply

Harald

MFreiberger · 23 Oktober 2019

Moin,

Peter Wahlen schrieb:
wenn Du eine 1500er hast, könntest Du auch mit BITSUM arbeiten.

BITSUM gab es auch schon in der 300/400 Klassikwelt. Ich meine das war FC99.

VG

MFreiberger

MFreiberger · 23 Oktober 2019

Moin Harald,

PN/DP schrieb:
Man muß nicht naiv die Bits zählen, man kann auch das Word + Byte + 4 Bits in ein 32-Bit-DWORD kopieren (oder AT) und dann mit Wordverknüpfung XOW in wenigen Schritten die Bits des DWORD untereinander XOR-verknüpfen.

Algorithmus: "Compute parity in parallel" oder "Compute parity of word with a multiply "
http://graphics.stanford.edu/~seander/bithacks.html#ParityMultiply

Harald

Mit dem Bitzählen könnte man aber auch ein Feld mit einer Anzahl an Bits auf Parity prüfen, deren Länge != einer Länge mit 2^n entspricht. Wird man aber wohl selten benötigen und die Funktion mit Shift und XOR ist sicher kürzer und performanter.
In Deinem Link geht man aber ab dem Zeitpunkt, ab dem man nur noch 4 bits (ein Nibble) prüfen will, auf die Lösung mit der Maske 6996 über. Soweit ich das verstehe, ist das nur dafür da, um ein paar Operationen zu sparen, oder? Man könnte doch auch einfach fortfahren mit dem shiften um 2 und um 1 und dann mit 0x1 verunden?

VG

Mario

PN/DP · 23 Oktober 2019

MFreiberger schrieb:
In Deinem Link geht man aber ab dem Zeitpunkt, ab dem man nur noch 4 bits (ein Nibble) prüfen will, auf die Lösung mit der Maske 6996 über. Soweit ich das verstehe, ist das nur dafür da, um ein paar Operationen zu sparen, oder? Man könnte doch auch einfach fortfahren mit dem shiften um 2 und um 1 und dann mit 0x1 verunden?

Ja, das ist eine zusätzliche Abkürzung.

MFreiberger schrieb:
Mit dem Bitzählen könnte man aber auch ein Feld mit einer Anzahl an Bits auf Parity prüfen, deren Länge != einer Länge mit 2^n entspricht.

Die beiden Algorithmen sind nicht auf eine Größe von 2^n Bits festgelegt, sondern können "bis zu" 32 Bits ohne Schleife auswerten. Sollen es weniger Bits sein, dann kann man die nicht benötigten Bits ausblenden/ausmaskieren. Sollen es mehr Bits sein, dann kann man das Bitfeld auf mehrere DWord aufteilen. Der Vorteil der beiden Algorithmen ist die parallele Verarbeitung mehrerer Bits - sie brauchen für n Bits viel weniger als n Operationen, z.B. nur ca. 13 AWL-Anweisungen für 32 Bits bei der Variante mit der Multiplikation.
Bitzählen benötigt für n Bits mindestens x*n Operationen (x >= 1)

Ungetestet:

Code:

[COLOR="#008000"]// http://graphics.stanford.edu/~seander/bithacks.html#ParityMultiply
// Compute parity of word with a multiply
// unsigned int v; // 32-bit word
// v ^= v >> 1;
// v ^= v >> 2;
// v = (v & 0x11111111U) * 0x11111111U;
// return (v >> 28) & 1;[/COLOR]

[COLOR="#008000"]// FUNCTION "Parity32_A" / VAR_IN: v : DWORD / RET_VAL : BOOL[/COLOR]

[COLOR="#008000"]// v ^= v >> 1;[/COLOR]
      L     #v                [COLOR="#008000"]//IN: DWORD[/COLOR]
      PUSH
      SRD   1
      XOD

[COLOR="#008000"]// v ^= v >> 2;[/COLOR]
      PUSH
      SRD   2
      XOD

[COLOR="#008000"]// v = (v & 0x11111111U) * 0x11111111U;[/COLOR]
      UD    DW#16#11111111    [COLOR="#008000"]//oder etwas kürzer:[/COLOR]
      L     DW#16#11111111    [COLOR="#008000"]//L DW#16#11111111 / TAK / UD / *D[/COLOR]
      *D

[COLOR="#008000"]// return (v >> 28) & 1;      //Bit 28 isolieren[/COLOR]
      SRD   29                [COLOR="#008000"]//oder "SLD 4" oder "UD DW#16#10000000"[/COLOR]
      U     >0                [COLOR="#008000"]//Statusbit A1 --> VKE[/COLOR]
      =     #RET_VAL          [COLOR="#008000"]//BOOL[/COLOR]

Harald

PN/DP · 23 Oktober 2019

Der Vollständigkeit halber hier noch der Parallel-Algorithmus in AWL
(ungetestet)

Code:

[COLOR="#008000"]// http://graphics.stanford.edu/~seander/bithacks.html#ParityParallel
// Compute parity in parallel  
// unsigned int v;  // word value to compute the parity of
// v ^= v >> 16;
// v ^= v >> 8;
// v ^= v >> 4;
// v &= 0xf;
// return (0x6996 >> v) & 1;[/COLOR]

[COLOR="#008000"]// FUNCTION "Parity32_B" / VAR_IN: v : DWORD / RET_VAL : BOOL[/COLOR]

[COLOR="#008000"]// v ^= v >> 16;[/COLOR]
      L     #v                          [COLOR="#008000"]//IN: DWORD[/COLOR]
      PUSH
      SRD   16
      XOD

[COLOR="#008000"]// v ^= v >> 8;[/COLOR]
      PUSH
      SRD   8
      XOD

[COLOR="#008000"]// v ^= v >> 4;[/COLOR]
      PUSH
      SRD   4
      XOD

[COLOR="#008000"]// v &= 0xf;
// return (0x6996 >> v) & 1;  //0x6996 ist Mini-Lookup-Table 0..15[/COLOR]

[COLOR="#008000"]//      UD    DW#16#F
//      L     DW#16#6996
//      SRD                               //SRD AKKU1, n=AKKU2
//      SRD   1                           //Bit 0 --> Statusbit A1
//      U     >0                          //Statusbit A1 --> VKE
//      =     #RET_VAL                    //BOOL[/COLOR]

[COLOR="#008000"]// S7 kürzer:[/COLOR]
      UW    W#16#F
      L     W#16#34CB                   [COLOR="#008000"]//16#6996 SRD 1 --> 16#34CB[/COLOR]
      SRW                               [COLOR="#008000"]//(SRD geht auch)[/COLOR]
      U     >0                          [COLOR="#008000"]//Statusbit A1 --> VKE[/COLOR]
      =     #RET_VAL                    [COLOR="#008000"]//BOOL[/COLOR]

Parallel ohne Lookup-Abkürzung - leichter verständlich:
(ungetestet)

Code:

      L     #v                          [COLOR="#008000"]//IN: DWORD[/COLOR]
      PUSH
      SRD   16
      XOD

      PUSH
      SRD   8
      XOD

      PUSH
      SRD   4
      XOD

      PUSH
      SRD   2
      XOD

      PUSH
      SRD   1
      XOD

      U     >0
      =     #RET_VAL                    [COLOR="#008000"]//BOOL[/COLOR]

Der Parallel-Algorithmus wurde hier schon mal erwähnt: SCL Parität ermitteln ab Beitrag #13

Harald

andrasch · 24 Oktober 2019

Hallo,

Erstmals ein Dankeschön für eure Hilfe.

Wie kopier ich das Word + Byte + 4 Bits im Step7 in ein 32-Bit-DWORD? Ich bin leider noch nicht so sattelfest bei solchen Bitoperationen und wäre daher für jeden Code sehr dankbar.

PN/DP · 24 Oktober 2019

Welche Step7-Version und welche SPS-CPU hast Du denn?
Brauchst Du die Parity-Berechnung mehrmals oder nur einmal?
Liegen das Word + Byte + 4 Bits eventuell schon zusammen in einem STRUCT? Wie sieht der STRUCT aus?
Liegen das Word + Byte + 4 Bits in den Instanzdaten eines FB oder wo kommen die her?
Wo Du die Parity-Berechnung aufrufen willst: Ist der Baustein (FB?) in AWL oder SCL programmiert?

Harald

MFreiberger · 24 Oktober 2019

Moin andrasch,

Deine Variablen haben ja absolute Adressen.
Dazu muss man wissen, wie die Byte- und Bitadressen in einem DWORD verteilt sind. Die Byteadresse wird von links nach rechts aufwärts gezählt, die Bitadresse von rechts nach links.

D.h. Du kannst dein DWORD einfach in seine Adressbereiche zerlegen und diese direkt mit Deinen Daten beschreiben.

Ein paar Beispiele:
- Das Merkerwort MW100 besteht aus den Merkerbytes MB100 und MB101.
- Das Merkerdoppelwort MD10 besteht aus den Merkerworten MW10 und MW12 oder aus den Merkerbytes MB10, MB11, MB12 und MB13

DWORD: 100 |
33222222222211111111110000000000 Bitadresse im DWORD 10er
10987654321098765432109876543210 Bitadresse im DWORD 1er

WORD: 100 | 102 |
11111100000000001111110000000000 Bitadresse im WORD 10er
54321098765432105432109876543210 Bitadresse im WORD 1er

BYTE: 100 | 101 | 102 | 103 |
76543210765432107654321076543210 Bitadresse im BYTE 1er

Du Könntest als z.B.
Das Word in das MW102 transferieren, das Byte in das MB101 und die vier Bits einzeln in diese Merker schreiben: M100.0, M100.1, M100.2, M100.3
Dann sind Deine Daten alle im Merkerdoppelwort MD100 zusammengefasst.

Du kannst die vier Bits in den kleinsten Adressbereich laden, um 8 nach links schieben, das Byte hinzuaddieren, um 16 nach links schieben und das Word hinzuaddieren (Wenn Du symbolisch, ohne absolute Adresse arbeitest geht es nicht anders. Also z.B. optimiert im TIA-Portal).

VG

MFreiberger

Warum wurde die Schriftart Courier New nicht übernommen bzw. warum sind die Satzzeichen nicht alle gleich lang? Bzw. anscheinend sind die Leerzeichen nicht passend.

PN/DP · 24 Oktober 2019

MFreiberger schrieb:
Warum wurde die Schriftart Courier New nicht übernommen bzw. warum sind die Satzzeichen nicht alle gleich lang? Bzw. anscheinend sind die Leerzeichen nicht passend.

Tip: Nimm eine Code-Box, da fummelt die Forum-Software nicht dran 'rum. Da ist automatisch Courier New und alle Zeichen gleich breit und mehrfach-Leerzeichen werden nicht entfernt.

Code:

DWORD:               100              |
       33222222222211111111110000000000 Bitadresse im DWORD 10er
       10987654321098765432109876543210 Bitadresse im DWORD 1er

 WORD:        100     |      102      |
       11111100000000001111110000000000 Bitadresse im WORD 10er
       54321098765432105432109876543210 Bitadresse im WORD 1er

 BYTE:    100 |   101 |  102  |  103  | 
       76543210765432107654321076543210 Bitadresse im BYTE 1er

Harald

PN/DP · 24 Oktober 2019

andrasch schrieb:
Wie kopier ich das Word + Byte + 4 Bits im Step7 in ein 32-Bit-DWORD?

Beispiel für Step7 classic AWL:

Code:

VAR_TEMP
  TestStruct : STRUCT
    Word_1 : WORD ;
    Byte_1 : BYTE ;
    Bit_0 : BOOL ;
    Bit_1 : BOOL ;
    Bit_2 : BOOL ;
    Bit_3 : BOOL ;
    Bit_4 : BOOL ;
    Bit_5 : BOOL ;
    Bit_6 : BOOL ;
    Bit_7 : BOOL ;
  END_STRUCT ;
[COLOR="#008000"]//  ParityDW AT TestStruct : DWORD ;  //geht nicht in AWL :([/COLOR]
  ParityDW : DWORD ;
  Parity_is_Odd : BOOL ;
END_VAR

Code:

[COLOR="#008000"]//Word + Byte + 4 Bits in 32-Bit-Struktur kopieren[/COLOR]
      L     #myWord
      T     #TestStruct.Word_1

      L     #myByte
      T     #TestStruct.Byte_1

      U     #myBit_A
      =     #TestStruct.Bit_0
      U     #myBit_B
      =     #TestStruct.Bit_1
      U     #myBit_C
      =     #TestStruct.Bit_2
      U     #myBit_D
      =     #TestStruct.Bit_3
      CLR                               [COLOR="#008000"]//unbenutzte Bits auf 0[/COLOR]
      =     #TestStruct.Bit_4
      =     #TestStruct.Bit_5
      =     #TestStruct.Bit_6
      =     #TestStruct.Bit_7

[COLOR="#008000"]//DWord umkopieren, weil es in AWL kein "AT" gibt[/COLOR]
      LAR1  P##TestStruct
      L     LD [AR1,P#0.0]
      T     #ParityDW

[COLOR="#008000"]//Parität ermitteln[/COLOR]
      CALL  "Parity32_A"
       v      :=#ParityDW
       RET_VAL:=#Parity_is_Odd

Harald

Heinileini · 24 Oktober 2019

andrasch schrieb:
Wie kopier ich das Word + Byte + 4 Bits im Step7 in ein 32-Bit-DWORD?

Was meinst Du mit "das Word + Byte + 4 Bits"?
Ich hatte das so verstanden: wahlweise WORD oder BYTE oder 4 Bit (= ein halbes Byte).
Wie schaut's mit DWORD (= DoppelWort = 32 Bits)?
Meinst Du etwa ein WORD und ein BYTE und dann noch 4 Bits "hintereinanderhängen" und dann von dem "Sammelsurium" die Parität ermitteln?

Ich bin leider noch nicht so sattelfest bei solchen Bitoperationen ...

Was meinst Du mit BitOperationen?
Bits miteinander verknüpfen?
Oder die "logischen" Verknüpfungen (UND, ODER, Exklusiv-ODER) wortweise bzw. DoppelWort-weise zu verstehen und anzuwenden?
Worin fühlst Du Dich "sattelfest"? Programmierst Du (bevorzugt) in KOP, FUP, AWL, SCL?

PS:
1 Wort, 1 Byte und 4 Bits in den 32-Bit-Akku schaufeln, ganz ohne "DeklarationsTricks":

Code:

      L    byte
      TAW
      L    word
      TAD
      OD
      SET  // optional
      U    Bit0
      SPBN SKP1
      L    1
      OD
SKP1: U    Bit1
      SPBN SKP2
      L    2
      OD
SKP2: U    Bit2
      SPBN SKP3
      L    4
      OD
SKP3: U    Bit3
      SPBN SKP4
      L    8
      OD
// Parity für max. 32 Bit mit XOR und Schieben:    
[LEFT][LEFT][FONT=courier new][COLOR=#222222][COLOR=#222222]SKP4: [/COLOR][/COLOR][/FONT]PUSH       
[/LEFT]
[/LEFT]
      SRD  1  
      XOD  // Akku1.0 = ParityOdd(BiMu.0 .. BiMu.1) 
      PUSH 
      SRD  2  
      XOD  // Akku1.0 = ParityOdd(BiMu.0 .. BiMu.3) 
      PUSH 
      SRD  4  
      XOD  // Akku1.0 = ParityOdd(BiMu.0 .. BiMu.7) 
      PUSH 
      SRD  8  
      XOD  // Akku1.0 = ParityOdd(BiMu.0 .. BiMu.15) 
      PUSH 
      SRD  16  
      XOD  // Akku1.0 = ParityOdd(BiMu.0 .. BiMu.31) 
// Bit0 von Akku1 hinausschieben und abfragen, z.B.:   
      SRD  1              // Bit0 ==> A1, 0 ==> A0 
      U    >0             // auf A1=1, A0=0 abfragen 
      =    ParityOdd      // ungerade Parität

Die Bits 4 .. 7 im Akku sind nach der ZusammenStellung 0.
Wenn es darum geht, anschliessend die Parität zu ermitteln, spielt es keine Rolle, welches der 28 (16+8+4) Bits letztendlich auf welcher Position im Akku landet.

PN/DP · 24 Oktober 2019

Heinileini schrieb:
1 Wort, 1 Byte und 4 Bits in den 32-Bit-Akku schaufeln, ganz ohne "DeklarationsTricks":

Code:

L byte TAW L word TAD OD SET // optional U Bit0 SPBN SKP1 L 1 OD SKP1: U Bit1 SPBN SKP2 L 2 OD SKP2: U Bit2 SPBN SKP3 L 4 OD SKP3: U Bit3 SPBN SKP4 L 8 OD // Parity für max. 32 Bit mit XOR und Schieben: [LEFT][LEFT][FONT=courier new][COLOR=#222222][COLOR=#222222]SKP4: [/COLOR][/COLOR][/FONT][...] [/LEFT] [/LEFT]

Wenn es darum geht, anschliessend die Parität zu ermitteln, spielt es keine Rolle, welches der 28 (16+8+4) Bits letztendlich auf welcher Position im Akku landet.

Für Parität kann man bei der Zusammenstellung auch schon ein wenig "vorverarbeiten":

Code:

      L    byte
      TAW
      L    word
      TAD
      OD

      CLR  // optional, SET oder CLR ist egal
      X    Bit0
      X    Bit1
      X    Bit2
      X    Bit3
      SPBN SKP4
      +    1
// Parity für max. 32 Bit mit XOR und Schieben:    
SKP4: ...

oder

Code:

      L    byte
      L    word
      XOW          //XOD geht auch

      CLR  // optional, SET oder CLR ist egal
      X    Bit0
      X    Bit1
      X    Bit2
      X    Bit3
      SPBN SKP4
      XOW  W#16#1  //oder z.B. OD DW#16#10000
// Parity für max. 32 Bit mit XOR und Schieben:    
SKP4: ...

Harald

Heinileini · 24 Oktober 2019

PN/DP schrieb:
Für Parität kann man bei der Zusammenstellung auch schon ein wenig "vorverarbeiten" ...

... oder sogar vor- und nachverarbeiten:

Code:

CLR        // optional
L    Word
L    Byte
XOD        // XOW    tut's auch
PUSH
SRD  8     // SRW 8  tut's auch 
XOD        // XOW    tut's auch
PUSH
SRD  4     // SRW 4  tut's auch
XOD        // XOW    tut's auch
UD   15    // UW  15 tut's auch
INC  1
L    W#16#6996
SRD        // SRW    tut's auch
U    >0    // X >0   tut's auch
X    Bit0
X    Bit1
X    Bit2
X    Bit3
=    ParityOdd

PN/DP · 24 Oktober 2019

Eine Optimierung kann ich noch

Code:

CLR        // optional (vorsichtshalber)
L    Word
L    Byte
XOD        // XOW    tut's auch
PUSH
SRD  8     // SRW 8  tut's auch 
XOD        // XOW    tut's auch
PUSH
SRD  4     // SRW 4  tut's auch
XOD        // XOW    tut's auch
UW   W#16#F
L    W#16#34CB
SRD        // SRW    tut's auch
U    >0    // X >0   tut's auch
X    Bit0
X    Bit1
X    Bit2
X    Bit3
=    ParityOdd

Harald

Heinileini · 25 Oktober 2019

PN/DP schrieb:
Eine Optimierung kann ich noch

Code:

... UW W#16#F L W#16#34CB SRD // SRW tut's auch U >0 // X >0 tut's auch ...

Kenne ich schon (z.B. aus #8 in diesem Thread), Harald, schliesslich lese ich ja Deine Beiträge besonders gerne!
Funktioniert aber nur, weil das niederwertigste Bit der Konstante W#16#6996 0 ist UND weil A1 und A0 für den Fall des "NichtSchiebens" bereits durch den UW (bzw. UD) passend vorbesetzt werden.
Während bei mir beim Anblick der Konstante 6996hex alias 0110 1001 1001 0110bin bzw. 9669hex alias 1001 0110 0110 1001bin spontan der Groschen nicht nur fällt, sondern geradezu flutscht, passiert ähnliches leider gar nicht, wenn ich 34CBhex alias 0011 0100 1100 1011bin lese.
Ich weiss doch, dass wir beide gleichermassen XOR-Fans sind, deshalb vermute ich, es geht Dir auch so.
Kurzum, kann man so machen (wenn's um Performance um jeden Preis geht und der Code in einer BlackBox verschwinden soll), muss man aber nicht.

Sooo, back to topic und für alle, die jetzt nur noch "Bahnhof" verstanden haben, habe in der "anbei"-pdf die Zellen gelb hinterlegt, die hoffentlich zum Verständnis der Konstanten W#16#6996 bzw. W#16#9669 beitragen ...
Anhang anzeigen Parity.pdf

Gruss, Heinileini

MFreiberger · 25 Oktober 2019

Moin Heinileini,

Heinileini schrieb:
Sooo, back to topic und für alle, die jetzt nur noch "Bahnhof" verstanden haben, habe in der "anbei"-pdf die Zellen gelb hinterlegt, die hoffentlich zum Verständnis der Konstanten W#16#6996 bzw. W#16#9669 beitragen ...

zum Glück konnte ich Euch "Bitschubsern" einigermaßen folgen. Allerdings hilft Deine PDF-Datei sehr für das Verständnis. Vielen Dank dafür!

VG

Mario

Heinileini · 26 Oktober 2019

Danke Mario für die "BitSchubser"-Blumen!
Ich hatte leider die totale BitSchubserBlockade, was das Verständnis der von Harald ins Spiel gebrachten ParityErmittlungsVariante per Multiplikation betrifft.
Heute ist endlich der Groschen gefallen und es ist sooo simpel, dass man gar nicht drauf kommen kann, wenn man zu intensiv darüber nachdenkt.

Im Vorspiel wird durch die Schieberei um 1 und um 2 BitPositionen und die XODERei folgendes vorbereitet:
In jeder Tetrade (Gruppe von 4 Bit) wird im jeweils niederwertigsten Bit (der Tetrade) die OddParity der jeweils 4 Bit gebildet.
Durch die UND-Verknüpfung mit der HEX-Konstante 11111111 werden dann die höherwertigen (Müll-)Bits aller 8 Tetraden gelöscht.
Nun wird noch mit der HEX-Konstante 11111111 multipliziert. Das sorgt dafür, dass jede der 8 (OddParity-)Tetraden durch Schieben nach links genau 1mal in der höchstwertigen Tetrade (Bits 28 .. 31) landet und hier wird die Summe der 8 Tetraden gebildet. Die Multiplikation tut schliesslich nichts anderes, als Bits nach links zu schieben (d.h. mit einer 2er-Potenz zu multiplizieren) und die ZwischenErgebnisse zu ADDIEREN. Da bei beiden Faktoren zwischen den relevanten Bits jeweils 3 Bits 0 sind, kommt es dabei nicht zu störenden Überläufen von einer Tetrade zur nächst höherwertigen.
Die Multiplikation "ZÄHLT" also in der höchstwertigen Tetrade die Anzahl der Einsen aller 8 (OddParity-)Tetraden.
Ist diese Zahl in der höchstwertigen Tetrade ungerade, so liegt OddParity vor. D.h. es muss abschliessend nur noch Bit28 ausgewertet werden.

Langer Vorrede kurzer Sinn: ein Versuch, dies per ExcelTabelle zu erklären wäre noch viel umfangreicher geworden.

Step 7 Step 7 Parität aus Word, Byte und 4 Bits ermitteln

Level-1

Level-3

Level-2

User des Jahres 2011-2013; 2015-2017; 2020-2022

Level-3

Level-3

User des Jahres 2011-2013; 2015-2017; 2020-2022

User des Jahres 2011-2013; 2015-2017; 2020-2022

Level-1

User des Jahres 2011-2013; 2015-2017; 2020-2022

Level-3

User des Jahres 2011-2013; 2015-2017; 2020-2022

User des Jahres 2011-2013; 2015-2017; 2020-2022

Level-3

User des Jahres 2011-2013; 2015-2017; 2020-2022

Level-3

User des Jahres 2011-2013; 2015-2017; 2020-2022

Level-3

Level-3

Level-3

Similar threads

Wir schützen deine Privatsphäre