Comunicación serie: síncrona y asíncrona

01 · Punto de partida

Por qué comunicar en serie

Hasta ahora, cada señal ocupaba un pin: un LED, un pulsador, un sensor analógico. Pero una pantalla gráfica necesita transmitir miles de bytes, una tarjeta SD, millones, y un módulo GPS envía líneas de texto. Si cada bit usara su propio pin, no alcanzarían los pines del chip ni los cables entre placas. La solución es enviar los bits uno detrás de otro por una misma línea, en el tiempo: es la comunicación serie.

Casi todo lo que vas a conectar a un microcontrolador habla en serie: el monitor del Arduino (por USB), los sensores de temperatura, humedad y presión, las pantallas OLED, las memorias, los módulos GPS, Bluetooth y WiFi, los controladores de motores y las tarjetas SD. Entender el principio común te permite aprender cualquier protocolo nuevo con su hoja de datos.

El problema es de ingeniería de mensajes: ¿cómo sabe el receptor cuándo empieza un bit, cuándo empieza un byte y si lo que recibió es correcto? Cada respuesta es una decisión de diseño con un precio.

02 · Cuántos cables

Serie frente a paralelo

En una comunicación paralela los 8 (o 16, o 32) bits de un dato viajan a la vez, cada uno por su cable. Es muy rápida por ciclo y simple de programar: escribís el byte en un puerto. Así funcionaban las impresoras antiguas y las memorias externas de los primeros sistemas.

Pero tiene tres problemas. Necesita muchos cables y pines. Los bits pueden llegar en instantes ligeramente distintos (el skew), y el efecto crece con la velocidad y la longitud. Y los cables vecinos se interfieren entre sí (diafonía). Por eso, en cuanto las velocidades suben, se pasa a pocos cables rápidos: USB, SATA, PCI Express y Ethernet son todos seriales.

El precio de la comunicación serie es la lógica extra: hay que convertir el byte en bits (serializar) y viceversa (deserializar), y ponerse de acuerdo sobre el ritmo. Los microcontroladores traen periféricos de hardware que lo hacen sin intervención de la CPU, de modo que el programa solo escribe y lee bytes.

03 · Cuándo mirar la línea

El problema del reloj

El receptor tiene que saber cuándo leer la línea. Hay dos soluciones.

En la comunicación síncrona, el emisor (o uno de los dos, el «maestro») entrega una línea adicional con un reloj. Cada flanco del reloj indica «ahora hay un bit válido». Es preciso: la velocidad puede cambiar de un instante a otro y el receptor sigue sin problemas, porque su ritmo es el del reloj. El precio es un cable más y el hecho de que alguien tiene que generar ese reloj. Son síncronos SPI e I2C.

En la comunicación asíncrona no hay reloj compartido. Cada extremo tiene el suyo, y ambos se ponen de acuerdo de antemano en la velocidad (los baudios). Como los relojes nunca son idénticos, el receptor necesita una marca para sincronizarse al comienzo de cada trama: el bit de inicio. Es el esquema de la UART. Se ahorra un cable, a costa de bits de sobrecarga y de exigir que las velocidades coincidan dentro de un margen.

Una analogía de programación: la comunicación síncrona es como un productor y un consumidor que se pasan un testigo (un semáforo, un evento) para cada dato; la asíncrona es como dos procesos que acuerdan una tasa fija de muestreo y confían en que la mantienen. La primera es robusta ante los cambios de ritmo; la segunda, económica pero más frágil.

04 · Una trama asíncrona

Anatomía de una trama asíncrona

Una UART mantiene la línea en alto mientras está ociosa. Para enviar un byte, baja la línea durante un bit (el bit de inicio), envía los bits de datos empezando por el menos significativo (LSB primero), opcionalmente agrega un bit de paridad y termina con uno o dos bits de parada en alto, que dejan la línea lista para el próximo flanco descendente.

La configuración se abrevia con tres símbolos. 8N1 significa 8 bits de datos, ninguna paridad (none) y 1 bit de parada. Es la más usada. Cada byte útil ocupa 10 bits en la línea, así que la eficiencia es del 80 %. Con paridad par y 2 bits de parada (8E2) serían 12 bits, el 67 %.

La velocidad se mide en baudios: símbolos por segundo. En una línea binaria, un símbolo es un bit, de modo que 9600 baudios son 9600 bits por segundo y cada bit dura 104,17 µs. Un byte en 8N1 tarda 10 × 104,17 µs = 1,04 ms; en una línea de 9600 baudios caben unos 960 bytes por segundo. Las velocidades habituales son 9600, 19 200, 38 400, 57 600 y 115 200 baudios.

El receptor detecta el flanco de bajada, espera medio bit para quedar en el centro del bit de inicio, y luego muestrea cada bit un período más tarde, siempre en su centro, donde la señal es más estable. Muchas UART muestrean 16 veces por bit y toman la mayoría de tres muestras centrales para filtrar el ruido. Al final comprueba que el bit de parada sea 1: si es 0, hay un error de trama.

La paridad añade un bit para que el total de unos (en datos más paridad) sea par (paridad par) o impar. Detecta cualquier error de un bit, pero ninguno de dos, y no puede corregir nada: es la protección mínima.

05 · Relojes imperfectos

Cuánto pueden diferir los relojes

Sin reloj compartido, cada extremo mide el tiempo con el suyo. Si el del receptor es un poco más rápido o más lento, su muestreo se desplaza respecto del centro de los bits de la trama. El desplazamiento se acumula bit a bit, pero se «reinicia» con el flanco de inicio de la trama siguiente: solo importa que no se acumule demasiado en una sola trama.

Sea d la diferencia relativa entre la duración del bit del receptor y la del emisor. El receptor muestrea el bit k en el instante (k + ½) bits de su propio reloj, es decir, desplazado (k + ½) · d bits del centro real. Para que el último bit de una trama de N bits se lea correctamente, ese desplazamiento debe ser menor que medio bit:

Para 8N1 (N = 10) resulta ±5,26 %. En la práctica el margen real es la mitad o menos: los flancos tienen ruido, el receptor detecta el inicio con una incertidumbre de una fracción de bit y los dos relojes aportan error a la vez. La regla de oro es mantener el desacuerdo total por debajo de 2 a 3 %.

Esto explica una historia clásica de la electrónica: los osciladores RC internos de los microcontroladores (con ±10 % de tolerancia) no sirven para una UART sin calibración, mientras que un cristal (±0,005 %) sobra. También explica por qué algunas velocidades «no cierran» con ciertos cristales: el divisor entero de la UART no siempre da la velocidad exacta. Por ejemplo, con 16 MHz, 115 200 baudios solo puede aproximarse con un error de −3,5 % (con el modo normal), cerca del límite. El tema 32 lo resuelve.

06 · Quién habla con quién

Dúplex y topologías

Un enlace puede ser:

• Símplex: en un solo sentido (un sensor que solo transmite).
• Semidúplex (half duplex): en ambos sentidos, pero no a la vez; alguien habla y los demás escuchan. Es el caso de I2C y de RS-485 de dos hilos.
• Dúplex completo (full duplex): ambos sentidos al mismo tiempo, con líneas separadas. La UART usa una línea de transmisión (TX) y otra de recepción (RX) cruzadas: el TX de un extremo va al RX del otro. SPI también transmite y recibe a la vez, con MOSI y MISO.

Y las topologías:

• Punto a punto: dos dispositivos, un enlace. Es la UART típica.
• Bus con maestro y esclavos: un maestro inicia las conversaciones y varios esclavos responden. Hay que decidir a quién habla el maestro: en I2C, con una dirección de 7 bits dentro del mensaje; en SPI, con una línea de selección de chip (CS) por cada esclavo.
• Multimaestro: varios dispositivos pueden iniciar una conversación y hay que arbitrar (I2C lo permite; CAN lo hace con prioridad).

Una consecuencia práctica de TX y RX cruzados: si conectás dos placas, el TX de una va al RX de la otra, y las masas deben unirse. Es el error de cableado más frecuente: conectar TX con TX.

07 · Los voltios

Niveles eléctricos y distancia

El protocolo define los bits; el nivel eléctrico define cómo se ven en el cable:

La señal diferencial de RS-485 transmite el mismo bit por dos cables con tensiones opuestas. El receptor mira solo la diferencia, de modo que el ruido que afecta a los dos cables por igual desaparece. Es la técnica de las líneas largas y ruidosas (automatización industrial). CAN y Ethernet también usan pares diferenciales.

Para unir sistemas de 5 V y 3,3 V hace falta un adaptador de nivel. En una dirección (de 5 V a 3,3 V) basta un divisor de resistencias (por ejemplo 1 kΩ y 2 kΩ); en la otra, los 3,3 V suelen alcanzar para ser un «1» válido de un chip de 5 V (umbral de 0,6 Vcc = 3 V), pero no siempre. Los buses bidireccionales como I2C usan conversores de nivel con transistores.

08 · Fiabilidad y formato

Detectar errores y delimitar mensajes

La UART entrega bytes y poco más. Para que dos programas se entiendan hace falta una capa de mensajes por encima, con dos preguntas: ¿dónde empieza y termina cada mensaje? ¿Llegó sin errores?

Delimitar

• Texto con terminador: cada mensaje es una línea que termina en \n (el modo de los módulos GPS y de muchos comandos AT). Simple y legible, pero ineficiente.
• Byte de inicio, longitud y datos: un byte marca el comienzo, otro indica cuántos bytes siguen. Es compacto, pero si se pierde un byte, el receptor queda desfasado hasta el próximo inicio.
• Escape de bytes (byte stuffing): cuando los datos pueden contener el mismo valor que el delimitador, se lo reemplaza por dos bytes (por ejemplo 0x7D 0x5E).
• Y siempre, un tiempo de espera (timeout): si un mensaje queda a medias, se descarta para resincronizar.

Detectar errores

• Paridad (1 bit por byte): detecta un bit alterado por byte.
• Suma de verificación (checksum): suma o XOR de los bytes. Es barata y detecta todos los errores de un bit, pero no ciertas combinaciones de dos bits.
• CRC (cyclic redundancy check): el resto de dividir el mensaje, visto como un polinomio, por un polinomio fijo. Un CRC-8 detecta todos los errores de 1 y 2 bits en mensajes cortos y casi todos los demás, con solo un byte de sobrecarga.

// CRC-8 con polinomio 0x07 (x^8 + x^2 + x + 1); crc8("123456789") = 0xF4
static uint8_t crc8(const uint8_t *datos, uint8_t n) {
    uint8_t crc = 0;
    while (n--) {
        crc ^= *datos++;
        for (uint8_t i = 0; i < 8; i++)
            crc = (crc & 0x80) ? (uint8_t)((crc << 1) ^ 0x07) : (uint8_t)(crc << 1);
    }
    return crc;
}

Una detección sin respuesta no sirve: el protocolo debe definir qué pasa al detectar el error (pedir la repetición, descartar o avisar). La elección depende del costo de un error: un termómetro que pierde una lectura no tiene problemas; un controlador de motor con un comando corrupto, sí.

09 · Lo que viene

Tres protocolos, tres respuestas

No hay un protocolo «mejor». La UART no necesita direcciones ni reloj y es ideal para dos extremos. I2C minimiza los cables en un bus con muchos sensores lentos. SPI maximiza la velocidad cuando hay pocos dispositivos y se pueden dedicar pines. La mayoría de los proyectos usan los tres.

10 · Analogía con programación

Tramas, relojes y errores en Python

Este programa construye tramas con distintos formatos, simula un receptor con un reloj desfasado para encontrar la tolerancia máxima, calcula el error de baudios que produce el divisor entero de la UART del ATmega328P (adelanto del próximo tema), mide qué fracción de errores detectan una suma, un XOR y un CRC-8, y compara el tiempo de transferencia de 16 bytes.

import random

random.seed(5)

# 1) tramas asincronas: inicio (0), datos del LSB al MSB, paridad opcional, parada (1)
def trama(byte, datos=8, paridad=None, paradas=1):
    bits = [0] + [(byte >> i) & 1 for i in range(datos)]
    if paridad:
        unos = sum(bits[1:])
        bits.append(unos % 2 if paridad == "par" else 1 - unos % 2)
    return bits + [1] * paradas

for texto, args in (("8N1", {}), ("8E1", {"paridad": "par"}), ("7O2", {"datos": 7, "paridad": "impar", "paradas": 2})):
    bits = trama(ord("A"), **args)
    print(f"'A' en {texto}: {''.join(map(str, bits))}  ({len(bits)} bits)")

# 2) el receptor muestrea en el centro de cada bit, con su propio reloj
def recibe(byte, razon, datos=8):
    # razon = duracion del bit del receptor / duracion del bit del emisor
    bits = trama(byte, datos)
    muestras = []
    for k in range(len(bits)):
        t = (k + 0.5) * razon                  # instante de muestreo (en bits del emisor)
        indice = int(t)
        muestras.append(bits[indice] if indice < len(bits) else 1)
    return muestras == bits

def tolera(razon):
    return all(recibe(b, razon) for b in range(256))

buenas = [r / 10000 for r in range(9000, 11001) if tolera(r / 10000)]
print()
print(f"relojes con 8N1 sin errores: de {min(buenas) - 1:+.2%} a {max(buenas) - 1:+.2%} (limite teorico simetrico: +-{0.5 / 9.5:.2%})")
buenas7 = [r / 10000 for r in range(9000, 11001) if all(recibe(b, r / 10000, 7) for b in range(128))]
print(f"con 7 bits de datos: de {min(buenas7) - 1:+.2%} a {max(buenas7) - 1:+.2%}")

# 3) el divisor entero del UART no siempre da la velocidad pedida (ver el tema 32)
print()
print("baudios pedidos  divisor  real      error")
for pedido, ubrr in ((9600, 103), (57600, 16), (115200, 8), (250000, 3)):
    real = 16e6 / (16 * (ubrr + 1))
    print(f"{pedido:14d}  {ubrr:7d}  {real:8.0f}  {real / pedido - 1:+.2%}")

# 4) detectar errores: suma, XOR y CRC-8 (polinomio 0x07)
def suma8(datos):
    return sum(datos) & 0xFF

def xor8(datos):
    r = 0
    for d in datos:
        r ^= d
    return r

def crc8(datos):
    crc = 0
    for d in datos:
        crc ^= d
        for _ in range(8):
            crc = ((crc << 1) ^ 0x07) & 0xFF if crc & 0x80 else (crc << 1) & 0xFF
    return crc

print()
print(f"CRC-8 de '123456789' = 0x{crc8(b'123456789'):02X} (valor de referencia 0xF4)")

def deteccion(funcion, errores, intentos=20000):
    detectados = 0
    for _ in range(intentos):
        msg = [random.randrange(256) for _ in range(8)]
        malo = msg[:]
        for pos in random.sample(range(64), errores):
            malo[pos // 8] ^= 1 << (pos % 8)
        if funcion(msg) != funcion(malo):
            detectados += 1
    return detectados / intentos

print("errores detectados en mensajes de 8 bytes (20 000 pruebas):")
for nombre, f in (("suma", suma8), ("XOR", xor8), ("CRC-8", crc8)):
    print(f"  {nombre:6s} 1 bit: {deteccion(f, 1):6.1%}   2 bits: {deteccion(f, 2):6.1%}   3 bits: {deteccion(f, 3):6.1%}")

# 5) tiempo para transferir 16 bytes
n = 16
print()
print("16 bytes:")
print(f"  UART 115200 8N1 : {10 * n / 115200 * 1e6:8.0f} us")
print(f"  SPI 1 MHz       : {8 * n / 1e6 * 1e6:8.0f} us")
print(f"  I2C 100 kHz     : {(9 * (n + 1) + 2) / 100e3 * 1e6:8.0f} us")
print(f"  I2C 400 kHz     : {(9 * (n + 1) + 2) / 400e3 * 1e6:8.0f} us")

Resultado: la letra «A» en 8N1 es 0 10000010 1. El receptor simulado acepta relojes entre −5,26 % y +5,88 % para 8N1: el límite por defecto coincide con la teoría (±5,26 %), y por el lado lento sobra un poco porque, después del bit de parada, la línea sigue en reposo y vale 1. Los divisores enteros de 16 MHz dan +0,16 % para 9600 baudios pero −3,55 % para 115 200. El CRC-8 detecta el 100 % de los errores de 1, 2 y 3 bits en mensajes de 8 bytes, la suma deja pasar el 6 % de los de 2 bits y el XOR el 11 %. Y 16 bytes tardan 1,39 ms por UART a 115 200, 128 µs por SPI a 1 MHz y 1,55 ms por I2C a 100 kHz.

La simulación del receptor es ideal (muestrea exactamente en el centro y detecta el flanco de inicio sin retardo); un receptor real tiene un margen menor.

11 · Exploración interactiva

Tramas, relojes y tiempos

El visualizador dibuja la forma de onda de un byte según la configuración de la trama. La segunda herramienta evalúa si dos velocidades son compatibles. La tercera compara el tiempo de enviar un mensaje con UART, SPI e I2C.

Recorrido guiado

1. Con el byte 65 («A») en 8N1: 0 10000010 1. Se envía primero el bit D0 = 1. Cambiá a 7 bits de datos y a paridad par: aparece un bit P más.
2. Con el byte 0xFF (255) la línea queda en alto todo el tiempo salvo el bit de inicio: una trama con todos unos casi no tiene flancos.
3. Pasá la velocidad a 115 200: cada bit dura 8,68 µs y el byte tarda 86,8 µs.
4. En la herramienta 2, 9600 y 9615,4 baudios dan una diferencia de −0,16 %: sin problema. Probá 9600 y 9000 (+6,7 %): el último bit se muestrea fuera de su ventana y la nota indica en qué bit empieza el error.
5. Con 115 200 en el emisor y 111 111 en el receptor (−3,55 % de diferencia), el sistema está dentro del límite teórico (±5,26 %), pero no del margen práctico.
6. En la herramienta 3, 16 bytes: SPI a 1 MHz tarda 128 µs, UART a 115 200 baudios 1,39 ms e I2C a 100 kHz 1,55 ms. Subí I2C a 400 kHz y baja a 388 µs.

12 · Comprensión

Confusiones frecuentes

13 · Práctica guiada

Predecí antes de comprobar

1. La trama de una letra

Dibujá, en 8N1, los bits en la línea para el carácter «K» (0x4B).

2. Un kilobyte

¿Cuánto tarda en enviarse 1 KB (1024 bytes) por una UART a 115 200 baudios en 8N1?

3. Eficiencia

Un formato 7E2 (7 bits de datos, paridad par, 2 bits de parada): ¿cuántos bits tiene la trama y qué fracción es útil?

4. Una velocidad aproximada

Con 16 MHz, 115 200 baudios se logran como 111 111 (−3,55 %). Si el otro extremo es exacto, ¿está dentro del límite teórico? ¿Y del práctico?

5. Cuántos cables

Se conectan 4 sensores a un microcontrolador. ¿Cuántas líneas de señal hacen falta con I2C y con SPI?

14 · Síntesis

Ideas para recordar

¿Listo para el tema 32?

Antes de avanzar, dibujá la trama de un byte en 8N1, calculá su duración a una velocidad dada y explicá por qué dos UART con velocidades ligeramente distintas pueden entenderse. Si podés justificar las tres respuestas, tenés la base para cualquier protocolo serie.

En el próximo tema estudiamos la UART y el monitor serie: los registros del ATmega328P, el cálculo de los baudios, los buffers y las interrupciones de recepción y transmisión.