Electrónica Digital · Tema 26

Paridad y errores

Un bit que vigila a los demás: detecta el que se da vuelta, se rinde ante dos.

01 · Punto de partida

El bit que se dio vuelta solo

Ruido en el cable voltea un bit (1011 → 1001) y nadie avisa. La paridad agrega un testigo: XOR de todos. Si el total deja de ser par, algo cambió. Detecta 1, 3, 5 errores; 2 se le escapan.

  • ¿Cómo se calcula P?
  • ¿Cómo chequea el receptor?
  • ¿Qué chip lo hace?
  • ¿Qué no puede detectar?

02 · Generar

XOR de todos

1011 tiene tres unos (impar): P = 1 para total par (4). Trama: 1011+1. Receptor: XOR de los 5 debe dar 0 (par); si da 1, error.

datos → XOR →P agregado → canal →XOR: 0 ok, 1 error

03 · 74HC280

9 bits vigilados

74HC280 (paridad par/impar simultáneas).
Entradas (unos)ΣparΣimpar
3 (impar)10
4 (par)01

Da ambas salidas: Σpar = P para paridad par, Σimpar para impar. UART 8E1/8O1 lo usa en serie (un bit más por byte).

Paridad

1 bit, barato

Detecta impares. Suficiente en cables cortos y UART con reintento.

Hamming/CRC (idea)

Más bits, más poder

Hamming corrige 1 bit (ECC); CRC caza ráfagas (curso 9). Misma idea, más matemática.

04 · Límites

Lo que no ve

Doble error
Dos bits volteados = paridad intacta: pasa sin avisar. En cables ruidosos se usa CRC.
No corrige
Avisa “hay error”, no dice dónde: la corrección es reintentar (UART) o Hamming.
Convención compartida
Par o impar lo acuerdan ambos extremos: mezclarlos marca error en todo lo sano.

05 · Paridad en código

Generar, romper, detectar

Transmisor + canal ruidoso + receptor, con trampa de doble error.

Python en tu navegador. Volteá 2 bits y engañá al receptor.

def paridad(bits):
    p = 0
    for b in bits:
        p ^= b
    return p


datos = [1, 0, 1, 1]
p = paridad(datos)
print(f"datos={datos} P={p} (total {sum(datos)+p} unos: par)")
recibido = datos + [p]
print("chequeo sano:", paridad(recibido) == 0)

P=1, total 4 (par), chequeo 0 = OK. ¿Qué P daría paridad impar?

Romper el canal

def romper(trama, posiciones):
    r = list(trama)
    for i in posiciones:
        r[i] ^= 1
    ok = paridad(r) == 0
    print(f"errores en {posiciones}: {'PASA (no detecta!)' if ok else 'ERROR detectado'}")
    return ok


trama = datos + [p]
romper(trama, [1])
romper(trama, [1, 3])

06 · Analogía programador

Dígito verificador

  1. 1
    Paridad = checksum de 1 bit.

    Como el dígito del DNI o el CRC: redundancia que delata corrupción.

  2. 2
    Doble error = colisión.

    Dos errores que se cancelan: como dos bugs que se tapan. Más bits, menos colisiones.

  3. 3
    Reintento = TCP.

    Detectar + pedir de nuevo: el protocolo hace con software lo que el bit no puede.

07 · Exploración

Laboratorio: canal ruidoso

Armá 4 bits + paridad par/impar, inyectá 1 o 2 errores y mirá si el receptor los caza.

LABORATORIO 26

Canal ruidoso

1011+P=1 · sano

Trama TX1011+1
Trama RX1011+1
Chequeo0 · OK ✓
Errores0

Trama sana: chequeo 0.

Preguntas para explorar

  1. Inyectá 1 error 3 veces. ¿Chequeo? ¿El receptor sabe dónde?
  2. Inyectá 2 errores. ¿Chequeo? ¿Qué demuestra?
  3. Cambiá datos a 0000. ¿P? ¿Trama? ¿Por qué es el caso más frágil?
Ver respuestas sugeridas
  1. 1 = ERROR siempre; no dice el bit (solo que hay). Reintentar, no adivinar.
  2. 0 = PASA (falso negativo): pares se cancelan. El límite en vivo.
  3. P=0, trama 00000: un error a 1 se detecta igual; frágil porque “todo cero” también es “silencio”.

08 · Comprensión

Confusiones frecuentes

«Paridad corrige»

Solo detecta cantidad impar: corregir pide Hamming (más bits) o reintento. Avisar ≠ arreglar.

«Dos errores se detectan»

Se cancelan y pasan: el peor caso del esquema. Ráfagas piden CRC (curso 9).

«Par o impar da igual»

Da igual cuál, pero ambos extremos usan la misma: mezclar par/impar rompe todo lo sano.

«El bit P va aparte»

Viaja con los datos (9.º bit): sin él no hay chequeo. Contarlo en el baud rate.

09 · Práctica guiada

Ejercicios de vigilancia

Ejercicio 1: trama a mano

Datos 0110, paridad par e impar. ¿P en cada caso? ¿Tramas? Verificá con paridad().

Ver solución razonada

Par: P=0 (dos unos, ya par). Impar: P=1 (total 3). Tramas 0110+0 y 0110+1.

Ejercicio 2: UART 8E1

Byte 0x41 ('A' = 1000001, dos unos). ¿P par? ¿Trama de 9 bits? ¿Overhead?

Ver solución

P=0 (ya par): trama 1000001+0. Overhead 1/8 = 12,5 % por detección simple.

Ejercicio 3: montar 280

74HC280 con 4 bits en switches, Σpar a LED. Recorré 0–15 y anotá cuándo prende.

Ver solución

Prende con cantidad impar de unos (P=1): 1, 2, 4, 7, 8, 11, 13, 14. La mitad exacta.

10 · Síntesis

Ideas para recordar

  • P = XOR de todos; chequeo 0 = sano.
  • Impares se cazan; pares se escapan.
  • 74HC280: 9 bits, par e impar a la vez.
  • Detectar ≠ corregir: reintento o Hamming.
  • Convención compartida siempre.

Testigo entendido. Ahora a operar: en el próximo tema, ALU elemental.