Comunicación serie y paralela

01 · Punto de partida

Ocho bits, dos caminos

En el tema anterior vimos que todo mensaje se descompone en bytes y que estos viajan como bits sobre un canal. Falta una decisión de diseño que afecta el costo, la velocidad y la distancia de cualquier enlace: ¿cuántos cables se usan para los bits de datos?

Pensalo como una función que recibe un arreglo. Podés pasarle los ocho elementos como ocho argumentos en la misma llamada, o pasarlos de a uno en ocho llamadas sucesivas. La primera manera es la comunicación paralela; la segunda, la comunicación serie. En software la elección parece trivial. En electrónica cada «argumento» es un cable, un pin del chip y una pista de la placa, y cada «llamada» consume tiempo.

02 · Todos a la vez

Comunicación paralela

En un enlace paralelo, cada bit de la palabra tiene su propia línea y los N bits se transmiten simultáneamente. Una línea adicional, el reloj o strobe, le avisa al receptor cuándo mirar: mientras el reloj está inactivo los datos pueden estar cambiando; cuando marca el momento, todos son válidos y se capturan juntos.

Ejemplos que ya conocés o vas a encontrar:

• Un puerto de entrada/salida del microcontrolador (los 8 pines de un registro PORT) es un bus paralelo en miniatura: una sola escritura cambia ocho pines a la vez.
• El bus de datos y de direcciones de una memoria externa, donde cada dirección y cada palabra ocupan decenas de líneas.
• Una pantalla LCD de caracteres (controlador HD44780) en modo de 8 bits o de 4 bits, con las líneas de datos DB0 a DB7, más RS y E.
• El viejo puerto paralelo de impresora (Centronics, LPT) y los discos IDE.

La gran virtud del paralelo es la simplicidad: no hay que construir ni descomponer nada, el dato está presente en los cables y el hardware receptor lo captura de una vez. Su costo, en cambio, aparece en la cantidad de pines, de pistas y de conductores.

03 · Uno detrás de otro

Comunicación serie

En un enlace serie, los bits viajan uno detrás de otro por una única línea de datos. El emisor toma el byte, lo descompone y coloca en la línea un bit por cada intervalo de tiempo; el receptor muestrea la línea con el mismo ritmo y vuelve a armar el byte. Para eso ambos extremos deben coincidir en cuánto dura cada bit, en qué bit va primero y en dónde empieza la palabra.

Son ejemplos de enlaces serie: UART, SPI, I²C, 1-Wire, RS-232, RS-485, CAN, USB, Ethernet y casi todos los que veremos en este curso. Que el nombre no engañe: serie describe cómo se envían los bits de datos, y no impide que un enlace use además cables de reloj, de selección o de alimentación.

04 · Cálculo

Cuánto tarda cada una

Si ambos enlaces usaran el mismo reloj, el paralelo sería N veces más veloz: mientras uno envía una palabra de N bits por cada ciclo, el otro necesita N ciclos. Con una palabra de ancho N bits y una frecuencia de reloj f:

La velocidad se mide en bits por segundo (bps). Un bus paralelo de 8 bits con reloj de 10 MHz mueve 80 Mbps; una línea serie con el mismo reloj, solo 10 Mbps. Pero la comparación justa no usa el mismo reloj, como veremos en la sección siguiente. Antes, fijate en lo que cuesta cada alternativa:

Un caso cotidiano: el UART de un Arduino a 115 200 baudios mueve unos 11 520 bytes por segundo (cada byte ocupa 10 bits en la línea, por el bit de inicio y el de parada). Un bus de 8 bits manejado con digitalWrite es lento por el código que lo gobierna; manejado en bloque por registros es mucho más rápido, pero consume nueve o diez pines.

05 · El límite del paralelo

El problema del desfase (skew)

Si las ocho líneas fueran idénticas, aumentar la frecuencia sería gratis. No lo son. Cada una tiene una longitud, una capacidad y un recorrido ligeramente distintos, por lo que los bits que salen juntos llegan en instantes diferentes. Esa diferencia se llama desfase o skew.

Una señal en una placa de circuito impreso FR-4 se propaga a unos 15 cm por nanosegundo, es decir, unos 6 a 7 ns por metro. Una diferencia de longitud de 10 cm entre dos pistas genera cerca de 0,6 ns de desfase.

El receptor captura todas las líneas en un único instante. Si una de ellas todavía no cambió, lee su valor anterior y el byte llega corrupto, sin ninguna señal de alarma. La regla práctica es que el desfase debe ser una pequeña fracción del período del reloj, y como el desfase depende de la geometría y no de la electrónica, la única forma de ir más rápido es acortar y igualar los cables, algo que se vuelve imposible fuera de la placa.

Hay además otros dos efectos en contra. El acoplamiento entre líneas vecinas (diafonía o crosstalk) crece cuando muchas señales conmutan a la vez y se induce ruido unas en otras. Y la cantidad de bits que cambian simultáneamente demanda un pico de corriente que perturba la alimentación.

En un enlace serie no hay nada que alinear: con una sola línea, no existe desfase entre bits. Para ir más rápido basta con acortar la duración de cada bit, y eso solo exige que el cable y la electrónica soporten esa frecuencia. Por eso el enlace serie puede trabajar a relojes de varios gigahertz.

06 · Tendencia

Por qué ganó la comunicación serie

Durante décadas, los buses paralelos eran la manera lógica de ir rápido. Cada generación subía el ancho o el reloj, hasta que chocó con el desfase. Los reemplazos fueron todos enlaces serie, muy rápidos, y la historia se repite en distintas áreas:

El paralelo sobrevive donde las distancias son mínimas y el ancho de banda es enorme: la memoria RAM de una computadora, por ejemplo, usa 64 líneas de datos entre el procesador y los módulos. Y en el microcontrolador, todos los puertos de E/S son paralelos por dentro. Pero entre chips y entre equipos, serie es la regla.

Varios carriles en serie

Una solución intermedia es usar varias líneas serie independientes, llamadas carriles (lanes). PCI Express x1, x4 o x16 y las memorias flash con SPI dual o quad (2 o 4 líneas de datos) lo hacen. En PCIe cada carril recupera su propio reloj a partir de los datos, de modo que el desfase entre carriles se corrige en el receptor; en SPI dual o quad las líneas comparten el reloj, algo viable porque la distancia es de centímetros. Es un paralelismo con muchas menos desventajas que el paralelo clásico.

07 · Conversión

Pasar de una forma a otra

Dentro de un chip, los datos viven en paralelo: un registro de 8 bits. Para sacarlos por un cable serie hay que convertirlos, y del otro lado, volver a armarlos. Ese trabajo lo hace un registro de desplazamiento (shift register): una cadena de biestables en la que cada pulso de reloj mueve todo el contenido una posición.

El 74HC595 es un componente de uso muy extendido. Con tres pines (datos, reloj de desplazamiento y reloj de salida o latch) maneja 8 LED, y encadenando n integrados se controlan 8 × n salidas sin usar un solo pin más. El 74HC165 hace lo inverso para leer botones o interruptores. Ambos son una herramienta clásica para ahorrar pines a costa de tiempo: para llenar ocho bits hacen falta ocho pulsos de reloj.

08 · Convención

Orden de los bits: MSB y LSB

En un enlace serie, además de la velocidad, hay que acordar cuál de los ocho bits va primero. Hay dos convenciones:

• MSB primero (most significant bit first): sale primero el bit 7, el de mayor peso. Es el orden de la notación habitual (0x41 = 01000001) y el más común en SPI e I²C.
• LSB primero (least significant bit first): sale primero el bit 0. Es el orden de la UART clásica. I²C envía el MSB primero, y en SPI depende del dispositivo, así que no hay una regla universal.

Si el emisor y el receptor no coinciden, el receptor arma el byte al revés: el mismo valor se lee con los bits invertidos de posición. El byte 0x41 (01000001) enviado MSB primero y leído como LSB primero se convierte en 0x82 (10000010). No hay error de comunicación ni de nivel: todos los bits llegaron bien, pero se interpretan en orden inverso, y por eso es uno de los errores más desconcertantes con un analizador lógico que muestra las señales correctas.

09 · Con el microcontrolador

El mismo dato, de las dos formas

Veamos el contraste en código. Primero, enviar un byte a un dispositivo de 8 bits con interfaz paralela. Hacen falta ocho pines de datos y uno de reloj (strobe), y el dato se coloca y se valida con un pulso:

const byte PIN_DATOS[8] = {2, 3, 4, 5, 6, 7, 8, 9};   // D0..D7
const byte PIN_STROBE = 10;

void enviarParalelo(byte dato) {
    for (byte i = 0; i < 8; i++) {
        digitalWrite(PIN_DATOS[i], (dato >> i) & 1);   // un bit por pin
    }
    digitalWrite(PIN_STROBE, HIGH);                      // el receptor captura aquí
    delayMicroseconds(1);
    digitalWrite(PIN_STROBE, LOW);
}

Ahora el mismo trabajo, con un 74HC595 que convierte los bits a paralelo en el otro extremo. El microcontrolador solo usa tres pines, sin importar cuántos integrados haya encadenados:

const byte PIN_DS = 11;      // datos en serie
const byte PIN_SHCP = 12;    // reloj de desplazamiento
const byte PIN_STCP = 13;    // reloj de salida (latch)

void enviarSerie(byte dato) {
    digitalWrite(PIN_STCP, LOW);
    shiftOut(PIN_DS, PIN_SHCP, MSBFIRST, dato);   // 8 pulsos de reloj, MSB primero
    digitalWrite(PIN_STCP, HIGH);                 // las salidas cambian todas a la vez
}

El primer método usa 9 pines por byte; el segundo, 3. Con dos 74HC595 en cadena el control sería de 16 salidas con los mismos 3 pines (dos llamadas a shiftOut antes del latch). El precio es el tiempo: cada digitalWrite necesita unos microsegundos, así que sacar un byte serie con esta técnica toma varias decenas de microsegundos. Para velocidades mayores se usa el periférico SPI de hardware (tema 12), que hace lo mismo sin intervención del programa.

10 · Analogía con programación

Serializar, deserializar y perder bits por el desfase

Con Python exploramos las dos ideas centrales del tema sin necesidad de hardware. Primero, la conversión de un byte a su secuencia de bits y de vuelta, con el orden de bits como parámetro. Luego, un modelo de bus paralelo: cada línea tiene un retardo propio (una fracción del desfase máximo) y el receptor captura en la mitad del ciclo. Si una línea todavía no cambió, el receptor lee el valor anterior.

def a_bits(valor, ancho=8, msb_primero=True):
    bits = [(valor >> i) & 1 for i in range(ancho)]       # bit 0 primero
    return bits[::-1] if msb_primero else bits


def a_valor(bits, msb_primero=True):
    if msb_primero:
        bits = bits[::-1]
    return sum(b << i for i, b in enumerate(bits))


# 1) Serie: el emisor y el receptor deben acordar el orden
enviado = a_bits(0x41, msb_primero=True)
print("línea serie:", enviado)
print("receptor MSB primero: 0x%02X" % a_valor(enviado, msb_primero=True))
print("receptor LSB primero: 0x%02X  (¡mismo cable, otro valor!)" % a_valor(enviado, msb_primero=False))

# 2) Paralelo: cada línea llega con un retardo distinto
RETARDOS = [0.0, 0.9, 0.3, 1.0, 0.55, 0.15, 0.75, 0.4]       # fracción del desfase máximo


def paralelo(valor, f_mhz, skew_ns, anterior=0x00):
    periodo = 1000 / f_mhz                                    # ns
    leido = 0
    for i in range(8):
        nuevo = (valor >> i) & 1
        viejo = (anterior >> i) & 1
        llega_a_tiempo = skew_ns * RETARDOS[i] < periodo / 2   # se captura a mitad de ciclo
        leido |= (nuevo if llega_a_tiempo else viejo) << i
    return leido


print()
for f in (10, 100, 500, 1000):
    leido = paralelo(0xFF, f, skew_ns=1.0)
    print(f"{f:5d} MHz, desfase 1 ns: se envía 0xFF, se lee 0x{leido:02X}")

Resultado: el byte 0x41 enviado MSB primero se lee como 0x41 o como 0x82 según el orden que espere el receptor. En el bus paralelo con 1 ns de desfase, a 10 y 100 MHz llega 0xFF completo; a 500 MHz falla la línea 3 (su retardo de 1,0 ns no es menor que la mitad del ciclo, 1 ns) y se lee 0xF7; a 1 GHz fallan cuatro líneas y se lee 0xA5. Probá otros desfases y relojes, y buscá la frecuencia máxima con 0,3 ns de desfase.

El modelo es una simplificación (los retardos reales son menos regulares y el muestreo no es perfecto), pero captura lo esencial: el paralelo falla en silencio. No hay ningún mecanismo que avise de que una línea llegó tarde, y por eso los diseñadores le dan tanta importancia a la longitud de las pistas.

11 · Exploración interactiva

Un byte, dos caminos

Este laboratorio manda el mismo valor por un bus paralelo y por un enlace serie, y compara lo que cuesta cada uno y lo que llega. Elegí el ancho de la palabra, el reloj de cada enlace, el desfase máximo entre las líneas del bus paralelo y el orden de bits que usan el emisor y el receptor del enlace serie. Los resultados se actualizan al cambiar cualquier control.

Las reglas son las del código anterior: el bus paralelo captura a mitad de ciclo y las líneas tienen retardos distintos (de 0 al 100 % del desfase máximo); las líneas que llegan tarde mantienen su valor anterior, que en este laboratorio es 0. El enlace serie no sufre desfase, pero puede fallar por el orden de bits.

El tiempo total de la transferencia no incluye los bits de control (inicio, parada, direcciones) que añaden los protocolos reales; es un cálculo ideal para entender la relación entre ancho y reloj. Los bits que difieren del valor enviado aparecen resaltados.

Recorrido guiado

1. Con los valores iniciales (65 = 0x41, 8 bits, paralelo a 10 MHz, serie a 100 MHz, desfase 1 ns), el bus paralelo trabaja bien y el valor llega intacto. Mirá los tiempos para una palabra: el paralelo tarda 100 ns y el serie solo 80 ns. Con una única línea, el enlace serie ya es más rápido porque su reloj es diez veces mayor.
2. Subí el reloj paralelo a 100 MHz: el tiempo baja a 10 ns y la palabra sigue llegando bien. El paralelo gana la comparación con un desfase pequeño.
3. Subí a 500 MHz. Con 1 ns de desfase, cada ciclo dura 2 ns y la captura ocurre en 1 ns, de modo que la línea 3 (retardo de 1 ns) ya no llega. Con 65 (0x41) no se nota, porque sus bits en 1 son el 0 y el 6, y ninguno está en la línea 3; probá con 255 y verás que aparece 0xF7, lo que vimos en el código.
4. Con 255 a 1 GHz y 1 ns de desfase, fallan cuatro líneas. El byte paralelo llega muy dañado, mientras el serie, que no se ve afectado por el desfase, sigue intacto.
5. Con 3 ns de desfase y 500 MHz, el bus paralelo falla con casi cualquier valor; solo es seguro a 100 MHz o menos (la captura ocurre a los 5 ns). Es el caso del cable largo: la única salida es bajar el reloj, con lo cual pierde su ventaja frente al serie.
6. Poné el emisor en «MSB primero» y el receptor en «LSB primero» con el valor 65: el enlace serie entrega 130 (0x82). Ningún bit se perdió; el receptor los armó en otro orden.
7. Pasá a 16 bits y 1 MiB. Compará los tiempos y la cantidad de líneas: el paralelo necesita 16 líneas de datos frente a una y, a su reloj máximo viable, ya no gana en velocidad.

12 · Método de trabajo

Cómo elegir entre serie y paralela

1. Calculá la velocidad necesaria. Bytes por segundo × 8 = bits por segundo. Un sensor que entrega 10 muestras de 2 bytes por segundo necesita 160 bps, una cifra ridícula para un enlace serie.
2. Contá los pines disponibles. Si tu microcontrolador tiene pocos, la serie es casi obligatoria; si sobran y la velocidad es crítica, el paralelo es una opción.
3. Medí la distancia. Dentro de la placa casi todo sirve; fuera de ella, el paralelo se complica con los metros.
4. Considerá el ruido. Cuantos más cables, más antenas captando interferencias y más diafonía.
5. Revisá qué ofrece el componente. En la práctica, la elección casi siempre la impone la interfaz del chip: un sensor I²C se conecta en serie, una memoria de datos rápida puede ser paralela.
6. Expandí con registros de desplazamiento si faltan pines. Un 74HC595 o 74HC165 cuesta centavos y agrega 8 salidas o entradas por 3 pines.
7. Documentá el orden de bits y de bytes. Escribí en el código de qué lado se interpreta MSB o LSB primero; esa información se pierde con facilidad.

Cuando algo falla en un bus serie, un analizador lógico muestra la línea y su decodificación; cuando falla en un bus paralelo, hay que mirar todas las líneas a la vez y verificar sus tiempos relativos, algo que exige más canales de medida y más paciencia.

13 · Comprensión

Confusiones frecuentes

14 · Práctica guiada

Predecí antes de comprobar

1. Tiempo de una transferencia

Se debe mover 1 MiB (1 048 576 bytes). Un bus paralelo de 8 bits trabaja a 10 MHz; un enlace serie, a 100 MHz. ¿Cuánto tarda cada uno, sin contar los bits de control?

2. Pines de una pantalla

Una pantalla LCD HD44780 se maneja en modo de 8 bits (DB0 a DB7, RS y E, con RW a masa). ¿Cuántos pines usa del microcontrolador? ¿Y en modo de 4 bits? ¿Y con una placa adaptadora I²C?

3. Una barra de LED

Querés controlar 24 LED con 74HC595. ¿Cuántos integrados y cuántos pines del microcontrolador necesitás? Si el reloj de desplazamiento es de 1 MHz, ¿cuánto tarda en actualizarse la barra?

4. Límite por desfase

Dos pistas de un bus difieren en 2 cm. Con una velocidad de propagación de unos 6,7 ns por metro, ¿cuánto desfase generan? Si el desfase no debe superar el 10 % del ciclo, ¿cuál es la frecuencia máxima del reloj?

5. Orden de bits

El emisor envía 0xB4 (10110100) con el MSB primero, y el receptor lo interpreta como LSB primero. ¿Qué valor obtiene?

6. Clasificar interfaces

Clasificá como serie o paralela: USB, memoria RAM DDR, SATA, I²C, HDMI, el bus de un LCD de 8 bits, PCI Express, SPI.

15 · Síntesis

Ideas para recordar

¿Listo para el tema 3?

Antes de avanzar, calculá cuánto tarda en enviarse 1 KiB por un bus paralelo de 16 bits a 20 MHz y por un enlace serie a 50 MHz, explicá con tus palabras por qué el desfase impide subir el reloj de un bus paralelo y mostrá con un ejemplo qué pasa si emisor y receptor no acuerdan el orden de los bits. Si podés justificar las tres respuestas, ya manejás la diferencia entre ambos enfoques.

En el próximo tema estudiamos la comunicación síncrona y asíncrona: cómo sabe el receptor cuándo mirar la línea, ya sea porque el emisor se lo indica con un reloj o porque ambos acordaron un ritmo y marcan el inicio de cada palabra.