MINT lernen

Fehler erkennen: Paritätsbit

Ein einziges Zusatzbit verrät, dass unterwegs etwas gekippt ist — aber nicht immer.

1

Ein Bit zur Kontrolle

Im Kanal kann ein Bit kippen (8.3.1). Der Sender hängt deshalb ein Prüfbit an, das die Nachricht selbst nicht braucht — gezielte Redundanz.

  • Paritätsbit:ein zusätzliches Bit, das die Anzahl der Einsen im ganzen Codewort auf eine vereinbarte Parität bringt.
  • Gerade Parität:Einsen insgesamt gerade: 1011001 hat 4 Einsen → p = 0 → 1011001 0.
  • Ungerade Parität:Einsen insgesamt ungerade: 1011001 → p = 1.
  • Prüfen:der Empfänger zählt alle Einsen, auch das Paritätsbit; passt die Parität nicht, fordert er das Wort erneut an.

Klicke Bits des Senders an, die im Kanal kippen sollen (Tastatur: ←/→ und Enter). Tippe dann, ob der Empfänger einen Fehler meldet, und starte die Übertragung mit ▶. Probiere ein, zwei und drei gekippte Bits.

Merkt der Empfänger den Fehler?

Halte fest: Jedes gekippte Bit ändert die Anzahl der Einsen um eins. Kippen zwei Bits, stimmt die Parität wieder — der Fehler bleibt unbemerkt.

2

Was die Parität kann — und was nicht

Warum genau die ungeraden Fehlerzahlen auffallen, zeigt eine kurze Überlegung.

Herleitung:
\(E_{\text{neu}}=E\pm1\)
| 1 Bit kippt
Aus 0 wird 1 (eine Eins mehr) oder aus 1 wird 0 (eine Eins weniger).
\(E_{\text{neu}}=E+a-b,\quad a+b=k\)
| k Bits kippen
\(a\) Bits von 0 auf 1, \(b\) Bits von 1 auf 0.
\(E_{\text{neu}}-E=k-2b\)
| b = k − a
\(2b\) ist gerade — es ändert die Parität nicht.
\(E_{\text{neu}}\bmod 2\ne E\bmod 2\;\Leftrightarrow\;k\text{ ungerade}\)
Ergebnis
Erkannt werden 1, 3, 5, … gekippte Bits, übersehen 2, 4, … gekippte Bits.
  • Keine Korrektur:der Empfänger weiß nicht, welches Bit gekippt ist — er kann das Wort nur neu anfordern (Quittung aus 8.3.2).
  • Aufwand:1 Prüfbit auf \(n\) Datenbits, Anteil \(\tfrac{1}{n+1}\): bei 7 Datenbits 12,5 %.
  • Kreuzparität:Paritätsbits je Zeile und je Spalte eines Bitblocks: fehlerhafte Zeile und Spalte kreuzen sich im gekippten Bit — ein Einzelfehler wird korrigierbar.
public static int paritaetsbit(int[] bits) {
    int einsen = 0;
    for (int i = 0; i < bits.length; i++) {
        einsen = einsen + bits[i];          // Einsen zählen
    }
    return einsen % 2;                      // gerade Parität
}

public static boolean fehlerErkannt(int[] empfangen) {
    return paritaetsbit(empfangen) == 1;    // Einsen ungerade → Fehler
}

Aufruf: paritaetsbit(new int[] {1, 0, 1, 1, 0, 0, 1}) liefert 0; das empfangene Wort 1 0 0 1 0 0 1 0 ergibt fehlerErkannt(…) == true.

Merke

Paritätsbit (gerade Parität): \(p=E \bmod 2\) mit \(E\) = Anzahl der Einsen der Daten. Der Empfänger meldet einen Fehler, wenn die Einsen des ganzen Codeworts ungerade sind — erkannt wird jede ungerade Anzahl gekippter Bits.

3

Allgemeine Hinweise

Das Paritätsbit mitzählen

Gerade Parität bezieht sich auf das ganze Codewort. Wer beim Prüfen nur die Datenbits zählt, meldet bei korrekten Wörtern mit p = 1 einen Fehler.

Keine Meldung heißt nicht fehlerfrei

Zwei gekippte Bits heben sich auf. Bei Bündelfehlern, die mehrere benachbarte Bits treffen, versagt ein einzelnes Paritätsbit oft.

Rest bei Division durch 2

Einsen zählen und % 2 rechnen liefert das gerade Paritätsbit. Für ungerade Parität gilt \(1-p\).

Videos