Comunicación síncrona y asíncrona

01 · Punto de partida

¿Cuándo hay que mirar la línea?

En el tema anterior elegimos enviar los bits por una sola línea, uno detrás de otro. Pero una línea que lleva ceros y unos sucesivos no tiene separaciones visibles: si el emisor manda 1 1 1 0 0, lo que ve el receptor es un nivel alto durante tres bits y uno bajo durante dos. ¿Cuántos bits hubo? Solo se sabe si se conoce cuánto dura cada bit y en qué instante empieza.

Es un problema de muestreo que ya conocés desde la programación: leer un valor en el momento correcto. Si lo leés demasiado pronto o tarde, obtenés el dato anterior o el siguiente. En la comunicación, el receptor necesita un reloj propio que marque los instantes de lectura, alineado con el del emisor. Las formas de lograrlo definen dos familias de enlaces:

• En la comunicación síncrona, el emisor y el receptor comparten la misma referencia de tiempo: o un cable de reloj, o un reloj que el receptor recupera de los propios datos.
• En la comunicación asíncrona, no hay reloj compartido: cada extremo tiene el suyo, se acuerda la velocidad de antemano y se marca el comienzo de cada palabra para volver a alinear los relojes.

02 · Un reloj para los dos

Comunicación síncrona: un reloj compartido

En un enlace síncrono con línea de reloj, uno de los extremos (el maestro) genera una señal de reloj y la envía por un cable aparte. Cada flanco de esa señal es una orden de «mirá ahora». El receptor no necesita saber nada sobre la velocidad: simplemente lee la línea de datos en cada flanco. Si el maestro acelera, baja o se detiene un instante, el receptor acompaña sin problemas.

Los buses síncronos con reloj dedicado más comunes son SPI (la línea SCLK) e I²C (la línea SCL). Sus ventajas son claras: velocidad variable, ningún error por diferencias de reloj entre chips y receptores muy simples (en SPI, el receptor es literalmente un registro de desplazamiento). Su costo es una línea adicional.

Tiempos de establecimiento y retención

El receptor no mira la línea de datos «en un punto», sino que el dato debe estar estable alrededor del flanco. Dos tiempos de la hoja de datos lo especifican:

• El tiempo de establecimiento (setup time, t_su) es cuánto antes del flanco debe estar estable el dato.
• El tiempo de retención (hold time, t_h) es cuánto después del flanco debe seguir estable.

Por eso los enlaces síncronos hacen que el dato cambie en un flanco del reloj y se lea en el contrario: queda medio ciclo de margen a cada lado. Con ese esquema, el reloj máximo queda limitado por los tiempos del componente. Un ejemplo: si el emisor tarda 10 ns en colocar el dato en la línea y el receptor exige un establecimiento de 20 ns, el medio ciclo debe durar al menos 30 ns, así que el ciclo completo debe ser de 60 ns como mínimo y la frecuencia máxima es de unos 16,7 MHz.

03 · Cada uno con su reloj

Comunicación asíncrona: inicio y parada

Para ahorrar el cable del reloj, ambos extremos usan relojes propios que se programan a la misma velocidad nominal (por ejemplo, 9600 baudios). Pero dos cristales nunca son idénticos y, si se dejan correr, se desfasan. La solución es corta y elegante: no mantener la sincronía mucho tiempo. El emisor se «resincroniza» al comienzo de cada palabra y el receptor solo necesita mantenerse alineado durante unos pocos bits.

Para eso la palabra se encierra entre dos marcas:

• La línea, en reposo, permanece en nivel alto (1).
• El bit de inicio (start) baja la línea a 0 durante un bit. Ese flanco de bajada es la señal para que el receptor ponga en marcha su contador.
• Siguen los bits de datos, habitualmente 8, con el bit menos significativo primero.
• El bit de parada (stop) devuelve la línea a 1 y garantiza que el próximo bit de inicio producirá un flanco.

El receptor, al detectar el flanco de bajada, espera medio bit para colocarse en el centro del bit de inicio (y confirmar que sigue en 0, para descartar picos de ruido). A partir de ahí muestrea la línea cada un bit completo, siempre en el centro de cada intervalo: el punto más alejado de ambos flancos, donde es menos probable equivocarse. Después del bit de parada, vuelve a esperar un nuevo flanco.

Este es el modelo de la UART (tema 7), de RS-232 y de RS-485 sobre UART, y también de 1-Wire, que se basa en tiempos acordados sin reloj. El nombre «asíncrono» no significa que no haya tiempos: el receptor mide el tiempo con precisión, solo que con su propio reloj.

El precio: sobrecarga

En cada byte de 8 bits, la UART agrega 2 bits de control. La eficiencia es:

A 9600 baudios la velocidad bruta es de 9600 bits por segundo, pero los datos útiles son solo 960 bytes por segundo. Con paridad y dos bits de parada (formato 8E2) cada byte ocupa 12 bits y la eficiencia baja a 66,7 %. En un enlace síncrono con reloj, los 8 bits ocupan 8 ciclos: no hay desperdicio por cada byte, aunque cada transferencia tiene su propia cabecera.

04 · Cálculo

Cuánto puede desviarse el reloj

La resincronización en cada byte funciona porque el receptor solo necesita mantener el ritmo durante diez bits. ¿Cuánto error de reloj admite? Supongamos que el receptor corre más rápido o más lento que el emisor en una fracción e. El receptor muestrea el bit número k (contando el inicio como bit 0) en el instante (k + 0,5) × (1 + e), medido en bits del emisor. Mientras ese instante caiga dentro de su bit, es decir, entre k y k + 1, la lectura es correcta.

El peor caso es el último bit, el de parada, con k = 9. Allí se cumple la condición solo si la desviación acumulada es menor que medio bit:

Esa es la tolerancia teórica entre los dos relojes. En la práctica se pide mucho menos, alrededor de ±2 %, para dejar margen a los flancos lentos, al ruido y a la imprecisión al detectar el inicio. Y recordá que el error que cuenta es la diferencia entre ambos relojes: si el emisor tiene +2 % y el receptor −2 %, el error relativo es de casi 4 %.

Una sutileza adicional: la velocidad que se programa en el divisor del periférico también introduce un error. Un microcontrolador a 16 MHz no puede generar exactamente 115 200 baudios (con el divisor entero de un AVR obtiene 111 111 baudios en modo normal, un error de −3,5 %, o 117 647 con el modo de doble velocidad, un error de +2,1 %); por eso a veces se elige un cristal de 18,432 MHz u otras frecuencias «redondas» para las UART. Lo analizamos en los temas 4 y 8.

05 · Reloj sin cable

Relojes escondidos en los datos

Entre los dos extremos hay una tercera opción: enviar solo datos, pero codificarlos de tal manera que la señal contenga el reloj. El receptor lo recupera observando los cambios de nivel con un circuito llamado PLL (lazo de enganche de fase), que ajusta su propio reloj a la cadencia de las transiciones. Es la técnica de USB, Ethernet, SATA y PCIe, y se llama comunicación síncrona con reloj embebido (embedded clock) o autosincronizada.

Para que la recuperación funcione, la señal debe cambiar con frecuencia. Hay dos estrategias:

• Codificación con transición garantizada. La codificación Manchester (usada en el Ethernet de 10 Mbps) coloca una transición en el centro de cada bit, de manera que el valor del bit se lee según su sentido (de bajo a alto, o al revés, según la convención). Siempre hay cambios, a costa de duplicar el ancho de banda necesario.
• Relleno de bits (bit stuffing). Si hay una larga cadena de bits iguales, no habría transiciones y el reloj se perdería. El emisor inserta un bit de valor contrario cada cierto número de bits iguales, y el receptor lo descarta. CAN rellena un bit opuesto cada cinco bits iguales seguidos; USB inserta un 0 después de seis unos consecutivos. Otras codificaciones, como 8b/10b (SATA, PCIe antiguo, Gigabit Ethernet óptico), traducen cada byte a 10 bits elegidos para asegurar transiciones.

Una variante híbrida es la de CAN: no existe un cable de reloj y cada nodo tiene el suyo, como en un enlace asíncrono, pero los nodos se resincronizan con cada flanco que ven en el bus, no solo al inicio de la trama. Así, el relleno de bits garantiza que haya flancos con la frecuencia suficiente.

06 · Tres niveles

Sincronizar bits, palabras y tramas

La sincronización tiene más de un nivel. Conocer el instante de cada bit no es suficiente: además hay que saber dónde empieza cada byte y cada mensaje.

En un enlace asíncrono, por lo tanto, el primer bit de cada byte es obvio, pero el principio de cada mensaje no. Si arrancás a escuchar en medio de una transmisión, los bits de inicio te alinean enseguida y los bytes salen bien, pero no sabés en qué parte del mensaje estás. Por eso los protocolos de texto usan un fin de línea (\n) y los binarios, un byte delimitador, como veremos en el tema 41.

07 · Panorama

Comparación y ejemplos

Ninguna familia es mejor en general. La síncrona con reloj es la elección natural dentro de una placa; la asíncrona, para dos equipos con pocos cables; y la del reloj embebido, cuando la velocidad o la distancia exceden lo que permite un cable aparte.

08 · Con el microcontrolador

El mismo byte, de las dos maneras

La diferencia se aprecia con dos funciones que envían un byte «a mano» (bit-banging). En la síncrona, el programa genera él mismo el reloj; el receptor lee con cada pulso. No importa cuánto demoren las instrucciones, porque el tiempo lo marca el reloj:

const byte PIN_DATOS = 11;
const byte PIN_RELOJ = 12;

// Síncrona: el receptor muestrea en el flanco de subida del reloj
void enviarSincrono(byte dato) {
    for (int i = 7; i >= 0; i--) {                 // MSB primero
        digitalWrite(PIN_DATOS, (dato >> i) & 1);   // el dato cambia con el reloj en bajo
        digitalWrite(PIN_RELOJ, HIGH);                // flanco: el receptor lee ahora
        digitalWrite(PIN_RELOJ, LOW);
    }
}

En la asíncrona no hay reloj: el emisor es responsable de mantener cada nivel durante exactamente un tiempo de bit (104 µs a 9600 baudios). El código es casi el mismo, pero ahora el tiempo importa en cada instrucción:

const byte PIN_TX = 3;
const unsigned int US_POR_BIT = 104;               // 1 / 9600 baudios ≈ 104,2 µs

// Asíncrona: inicio, 8 bits de datos (LSB primero) y parada
void enviarAsincrono(byte dato) {
    noInterrupts();                                // una interrupción alargaría un bit
    digitalWrite(PIN_TX, LOW);                     // bit de inicio
    delayMicroseconds(US_POR_BIT);
    for (byte i = 0; i < 8; i++) {
        digitalWrite(PIN_TX, (dato >> i) & 1);   // bit i del byte
        delayMicroseconds(US_POR_BIT);
    }
    digitalWrite(PIN_TX, HIGH);                    // bit de parada (y reposo)
    delayMicroseconds(US_POR_BIT);
    interrupts();
}

Este segundo código tiene un defecto sutil: cada digitalWrite consume unos microsegundos que se suman al retardo, así que los bits duran algo más de 104 µs y la velocidad real queda unos puntos porcentuales por debajo de la nominal. Un diseño cuidadoso resta ese tiempo al retardo. En la práctica se usa el periférico UART de hardware, que cuenta los ciclos con precisión sin ocupar la CPU, o una biblioteca de UART por software que ya compensa estos retardos.

09 · Analogía con programación

Un receptor asíncrono con el reloj desviado

Con Python simulamos un receptor asíncrono. La trama de un byte (inicio, 8 bits de datos con el LSB primero y parada) se coloca en una línea ideal. El receptor detecta el inicio, y a partir de ahí muestrea cada bit en el instante (k + punto) × (1 + error): punto es la posición dentro del bit (0,5 = centro) y error es la desviación de su reloj respecto del del emisor. Después de la trama se asume otro byte enviado a continuación, así que la línea vuelve a bajar.

def trama_8n1(byte):
    """Inicio (0), 8 bits de datos con el LSB primero y parada (1)."""
    return [0] + [(byte >> i) & 1 for i in range(8)] + [1]


def muestrear(byte, error, punto=0.5):
    """Bits que lee un receptor cuyo reloj tiene un error relativo (0,02 = 2 % más lento)."""
    linea = trama_8n1(byte)
    leidos = []
    for k in range(10):
        t = (k + punto) * (1 + error)            # instante, en bits del emisor
        n = int(t)                               # bit que está en la línea en ese instante
        leidos.append(linea[n] if n < 10 else 0)   # tras la trama llega otro inicio (0)
    return leidos


def decodificar(leidos):
    if leidos[0] != 0:
        return "falso inicio"
    if leidos[9] != 1:
        return "error de trama (el bit de parada no es 1)"
    valor = sum(leidos[1 + i] << i for i in range(8))
    return f"byte recibido: 0x{valor:02X}"


for error in (-0.06, -0.05, 0.0, 0.05, 0.06):
    print(f"reloj {error * 100:+.0f} % -> {decodificar(muestrear(0xA5, error))}")

print()
for punto in (0.5, 0.9):
    print(f"muestreo al {punto * 100:.0f} % del bit, reloj +3 % -> {decodificar(muestrear(0x55, 0.03, punto))}")

Resultado: con el byte 0xA5, hasta ±5 % de error el receptor lee bien. Con +6 % ve un error de trama, porque el muestreo del bit de parada cae ya en el inicio del byte siguiente. Con −6 % ocurre lo peor: lee 0x25 sin ningún aviso, porque las últimas muestras caen en el bit anterior y, como el bit 7 del byte vale 1, el bit de parada parece correcto por casualidad. En la segunda prueba, muestrear al 50 % del bit tolera un +3 %, pero hacerlo al 90 % ya produce un error de trama. Probá con otros bytes y errores y buscá el límite exacto con 0,5 y con 0,9.

El modelo ignora el ruido y los flancos lentos, así que el límite real es menor. Aun así muestra por qué la UART debe muestrear en el centro del bit: es el punto con mayor margen para ambos lados.

10 · Exploración interactiva

Un receptor con el reloj desviado

Este laboratorio aplica el modelo del apartado anterior. Elegí un byte, la velocidad del enlace, el error de reloj del receptor y el punto del bit en que muestrea. Vas a ver la trama que se transmite, los bits que lee el receptor (los que difieren aparecen resaltados) y el veredicto: correcto, error de trama detectado o un valor equivocado que pasa sin que el receptor se entere.

El resultado se calcula para un byte seguido inmediatamente por otro (sin pausa entre caracteres). El «desvío al muestrear la parada» indica cuánto se aparta el instante de lectura del último bit respecto de su centro nominal; mientras no cruce el borde del bit, la lectura es correcta.

Recorrido guiado

1. Con los valores iniciales (0xA5 = 165, error 0 %, muestreo al centro), todo se lee bien. Mirá la fila «Bit»: I es el inicio, 0 a 7 los datos y P la parada. A 9600 baudios, cada bit dura 104,2 µs y salen 960 bytes útiles por segundo.
2. Subí el error de a poco. Hasta ±5 % el receptor lee todo bien, y el límite exacto que indica el panel es ±5,3 % con muestreo central.
3. A +6 %, aparece el error de trama: el bit de parada se lee como 0 porque el muestreo ya cae en el inicio del byte siguiente.
4. A −6 %, con el byte 165, el veredicto es «valor erróneo sin aviso»: el receptor entrega 37 (0x25) y ni siquiera detecta que algo falló. Probá con 85 (0x55) a −6 %: este sí produce error de trama. Que el fallo se vea o no depende de los datos; por eso conviene tener paridad o CRC.
5. Volvé a 0 % y cambiá el punto de muestreo a 90 %. La tolerancia positiva se reduce a poco más de 1 %. Poné +3 % y fallará, aunque con el muestreo al centro funcionaba bien.
6. Con muestreo al 10 %, el límite positivo mejora (9,9 %) pero el negativo cae a 1,1 %. Solo el centro equilibra ambos lados.
7. Cambiá la velocidad a 115 200 baudios: la duración del bit baja a 8,7 µs, pero la tolerancia en porcentaje es la misma. Subir la velocidad no hace más exigente al reloj; lo que cambia es el error absoluto en nanosegundos.

11 · Método de trabajo

Cómo elegir y configurar

1. Mirá qué ofrece el componente. Casi siempre la hoja de datos decide: un sensor I²C o SPI es síncrono, un módulo GPS o Bluetooth serie, asíncrono.
2. Si es síncrono, identificá quién genera el reloj (el maestro) y con qué flanco se muestrea. SPI lo define con los modos CPOL y CPHA (tema 13); en I²C está fijado por el protocolo.
3. Respetá setup y hold. Compará la frecuencia de reloj con el límite que impone la hoja de datos; si se supera, los datos se leen mal de forma intermitente.
4. Si es asíncrono, acordá la configuración completa: velocidad, bits de datos, paridad y bits de parada. Una diferencia en cualquiera produce basura o errores de trama.
5. Verificá el error de reloj. Calculá la velocidad real que produce tu divisor y sumá los errores de ambos extremos. Si hay un oscilador RC, calibralo o usá un cristal.
6. Definí cómo se delimitan los mensajes. En un enlace asíncrono, el protocolo de aplicación debe marcar el comienzo y el fin de cada mensaje.
7. Medí con un analizador lógico. Para un enlace asíncrono, medí la duración de un bit y comprobá que coincide con la teórica; para uno síncrono, verificá que el dato esté estable en cada flanco de muestreo.

La falla más común es una velocidad distinta en los dos lados: al medir un bit en el analizador se ve enseguida. La segunda, una línea que queda sin definir (sin pull-up o sin pull-down) y produce flancos falsos que el receptor interpreta como bits de inicio.

12 · Comprensión

Confusiones frecuentes

13 · Práctica guiada

Predecí antes de comprobar

1. Eficiencia de una UART

Calculá cuántos bytes de datos útiles por segundo transporta un enlace a 9600 baudios con formato 8N1 y con formato 8E2 (8 datos, paridad par y 2 bits de parada).

2. Tiempo de bit

¿Cuánto dura un bit a 9600 y a 115 200 baudios? ¿A qué distancia del flanco de inicio debe leerse el primer bit de datos?

3. ¿Se entienden?

Un transmisor tiene un error de reloj de +3 % y el receptor de −3 %. ¿Cuál es el error relativo y comunican bien en 8N1 con muestreo central? ¿Y si cada uno tiene ±1 %?

4. Velocidad máxima de un bus síncrono

Un esclavo SPI requiere 25 ns de establecimiento, y el dato tarda 5 ns en estar disponible tras el flanco que lo cambia. El dato cambia en un flanco y se lee en el siguiente (medio ciclo después). ¿Cuál es la frecuencia máxima de reloj?

5. Decodificar una línea

Una línea en reposo (1) cae a 0 y presenta, en intervalos de un bit, la secuencia 0 1 0 1 0 1 0 1 0 1 antes de volver al reposo. ¿Qué byte se transmitió en 8N1?

6. Clasificar

Clasificá estos enlaces según cómo se sincronizan: (a) con línea de reloj dedicada, (b) asíncrono con inicio y parada, (c) con reloj embebido en los datos: SPI, UART, USB, I²C, Ethernet, RS-232.

14 · Síntesis

Ideas para recordar

¿Listo para el tema 4?

Antes de avanzar, dibujá de memoria la trama 8N1 del carácter «A» (0x41) marcando los instantes de muestreo, calculá el error de reloj máximo que tolera y explicá por qué un enlace síncrono con reloj no tiene este problema. Si podés justificar las tres respuestas, tenés clara la base de UART, SPI e I²C.

En el próximo tema estudiamos la velocidad, los baudios y el sentido de la comunicación: la diferencia entre bits por segundo y baudios, el ancho de banda y los modos símplex, half duplex y full duplex.