Configuración de una UART

01 · Punto de partida

La velocidad que pedís y la que obtenés

En el tema anterior estudiamos la trama. Ahora nos ocupamos de lo que la hace posible: el ritmo. Dos UART se entienden si ambas dividen el tiempo en bits casi iguales, y «casi» tiene un límite preciso que ya calculamos en el tema 3: la desviación acumulada hasta el último bit de la trama no debe superar medio bit. Lo que falta saber es de dónde viene esa desviación en un chip real.

Viene de dos lugares. Uno es el oscilador: un cristal es muy exacto, pero un oscilador RC interno puede desviarse varios puntos porcentuales. El otro es el divisor de baudios: la UART obtiene su ritmo dividiendo el reloj del microcontrolador por un número entero, y si la velocidad pedida no resulta de una división exacta, el chip usa la más cercana que puede lograr. Esa diferencia es un error de diseño que nadie ve en el código, porque Serial.begin no avisa.

02 · De dónde sale el ritmo

El generador de baudios

La UART tiene un contador que cuenta pulsos del reloj del sistema y genera un pulso de salida cada vez que llega a un valor programado: el divisor. Como el receptor sobremuestrea (16 muestras por bit en los AVR), el reloj base de la UART debe ser 16 veces la velocidad de bits:

En un ATmega328P, UBRR es un registro de 12 bits (0 a 4095). El resultado se redondea al entero más cercano, y como la velocidad real depende de ese entero, solo hay ciertas velocidades alcanzables. El AVR ofrece además un modo de doble velocidad (bit U2X0) que reduce la división a 8, con el que algunas velocidades se acercan más a la pedida:

Un ejemplo con el reloj típico de un Arduino (16 MHz) y 9600 baudios: UBRR = 16 000 000 / (16 × 9600) − 1 = 103,17, que se redondea a 103. La velocidad real es 16 000 000 / (16 × 104) ≈ 9615 baudios, una diferencia de +0,16 %. Perfectamente aceptable.

Otras familias resuelven esto de otro modo. Los STM32, el ESP32 y la Raspberry Pi Pico usan un divisor fraccionario (con 4 o más bits decimales), lo que reduce el error de velocidad a una fracción de punto porcentual para casi cualquier combinación de reloj y baudios. El problema del error entero es característico de los microcontroladores sencillos, como los AVR y los PIC.

03 · Cálculo

El error del divisor

El error de velocidad es la diferencia relativa entre la velocidad real y la pedida:

Dos hechos saltan a la vista. Primero, las velocidades «bajas» (9600, 19 200) tienen un error mínimo, pero las altas pueden ser un problema: 115 200 baudios a 16 MHz tiene −3,55 % en modo normal y +2,12 % en doble velocidad; y 230 400 baudios en modo normal llega a +8,5 %, que ya supera el límite teórico del 5,26 % y no puede funcionar contra un compañero exacto. Segundo, el modo de doble velocidad no es siempre mejor: mejora 57 600 baudios pero deja 115 200 casi igual. Hay que mirar el error caso por caso.

La solución: un cristal «de baudios»

Cuando el error importa, se elige el reloj para que el divisor sea exacto. Los cristales de 7,3728 MHz, 11,0592 MHz y 18,432 MHz son múltiplos enteros de 16 × 115 200 (por ejemplo, 18 432 000 / (16 × 115 200) = 10 exacto), y por eso aparecen en tantos diseños de comunicación. Con ellos, todas las velocidades estándar tienen un error de cero. Una frecuencia de 8 MHz, en cambio, es mala para velocidades altas: 115 200 baudios da +8,5 % en modo normal y −3,55 % en doble velocidad.

Por último, un recordatorio sobre el oscilador: un cristal de cuarzo desvía unas decenas de ppm (0,002 %), un resonador cerámico del orden de 0,5 % y un oscilador RC interno entre 1 % y 10 %, según esté calibrado. Todos estos errores se suman al del divisor.

04 · Sumar errores

Presupuesto de error entre dos extremos

Lo que importa al receptor es el desvío relativo entre su ritmo y el del transmisor. En el peor caso, se suman los errores de ambos: el del oscilador del emisor, el de su divisor, y los mismos dos del receptor.

El límite teórico es el que vimos en el tema 3, ±5,26 % con muestreo central en 8N1, pero el margen práctico es menor, porque los flancos reales no son perfectos, hay ruido y el receptor decide con tres muestras. Una regla de diseño razonable es la siguiente:

Veamos un caso. Un Arduino a 16 MHz, 115 200 baudios en modo normal (−3,55 %) habla con un adaptador USB–serie moderno, que tiene un error de prácticamente cero: la diferencia es de 3,55 %. Está en la zona «al límite»: en muchas mesas de trabajo funciona, pero con otra computadora o un cable largo puede empezar a fallar. Y si el otro extremo fuera otro AVR en doble velocidad (+2,12 %), la diferencia sube a casi 5,9 % y la comunicación falla en cuanto aparecen los bytes con muchos bits distintos.

El diagrama muestra qué pasa con el muestreo de una trama 8N1 de diez bits cuando el reloj del receptor se desvía. Cada fila coloca los puntos de muestreo (uno por bit, calculados en el instante (k + 0,5) × (1 + e)) sobre las celdas de bit del emisor:

La lección es que el error no se reparte parejo: crece a lo largo de la trama y es máximo en el último bit. Por eso las tramas largas (9 bits de datos, paridad, dos paradas) toleran menos error que las cortas.

05 · Diagnóstico

Síntomas de una mala configuración

La mayoría de las fallas de un enlace serie nuevo son de configuración. Los síntomas orientan hacia la causa:

Un caso instructivo de diferencia de formato: si el emisor usa 2 bits de parada y el receptor espera 1, normalmente funciona, porque el segundo bit de parada se interpreta como reposo; pero si el emisor usa 1 y el receptor espera 2, el segundo bit de parada del receptor coincide con el inicio del siguiente carácter, y aparecen errores de trama cuando los caracteres son seguidos. La regla: el receptor puede ser más exigente que el emisor en las paradas solo si hay pausas entre caracteres.

06 · Lo que la UART informa

Banderas de error de la UART

La UART verifica cada carácter y deja constancia de los problemas en bits de estado. Los tres más importantes son:

• Error de trama (framing error, FE): el bit de parada no llegó en 1. Causas: velocidad o formato distintos, ruido, BREAK o línea desconectada.
• Error de paridad (parity error, PE): la paridad del carácter recibido no coincide con la esperada. Causas: paridad configurada distinta, o un bit alterado por ruido.
• Desbordamiento (data overrun, DOR): llegó un carácter nuevo y el anterior seguía sin ser leído, por lo que se pierde uno de los dos. Es un problema del programa (o de la CPU saturada), no de la línea.

Dos particularidades a tener en cuenta. Primero, en los AVR, las banderas corresponden al carácter que está en el registro de datos y se actualizan al leerlo: hay que consultarlas antes de leer el dato. Segundo, la biblioteca Serial de Arduino descarta en silencio los caracteres con error y no los reporta, así que para ver los errores hay que mirar los registros o usar otra interfaz (en ESP-IDF, el controlador publica eventos como UART_FRAME_ERR, UART_PARITY_ERR y UART_FIFO_OVF).

El desbordamiento merece una cuenta. A 115 200 baudios en 8N1 llega un carácter cada 86,8 µs. Un AVR guarda como mucho dos caracteres en su búfer de recepción: no hay margen para esperar. Si el programa lee por consulta (polling) cada 2 ms, en ese lapso llegan 23 caracteres y se pierden todos menos los dos primeros. La solución son las interrupciones con un buffer, que estudiamos en el tema 9.

07 · Velocidad desconocida

Detección automática de velocidad

¿Qué hacer cuando se desconoce la velocidad de una línea, por ejemplo la de un módulo sin documentación? Se puede medir. Cuando comienza un carácter, el bit de inicio dura exactamente un tiempo de bit; la inversa de ese tiempo es la velocidad. Si el primer carácter es la «U» (0x55), cuya trama alterna 0 y 1, el primer pulso en nivel bajo es el bit de inicio, y su duración es un bit.

Muchos bootloaders y módulos usan este método (autobaud): el equipo que arranca espera un carácter conocido, mide el pulso y configura su divisor. Después se redondea a la velocidad estándar más próxima:

El mismo método sirve con un analizador lógico o un osciloscopio: se mide el pulso más corto de la captura. Una advertencia: para que el redondeo sea confiable, la medición debe ser precisa al 1 o 2 %; con un temporizador del microcontrolador funciona muy bien, pero con pulseIn de Arduino, a velocidades altas, la resolución en microsegundos ya es insuficiente.

08 · Decisión de diseño

Elegir la velocidad

No hay una velocidad correcta en general; hay compromisos. Estos son los criterios habituales:

• Ancho de banda necesario. Calculá los bytes por segundo con la fórmula del tema 4, y elegí la velocidad estándar más baja que deje una utilización cómoda.
• Error de baudios. Preferí velocidades con error mínimo para tu reloj; si la velocidad exacta importa, elegí el cristal en función de ella.
• Distancia y ruido. A mayor velocidad, menores distancias y cables más limpios. Orientativamente, una UART TTL sin buffers funciona a 115 200 baudios en cables de uno o dos metros, y a 9600 en distancias de varios metros; con RS-232 se llega a unos 15 m y con RS-485 a más de 1 km a velocidades bajas (temas 22 y 24).
• Capacidad del receptor. Un microcontrolador sencillo que procesa cada byte puede no sostener velocidades altas con ráfagas.
• Compatibilidad. Muchos módulos arrancan a 9600 y permiten subir la velocidad por comando; el 9600 es el punto de partida más seguro.

Una práctica útil: arrancar con 9600 baudios y 8N1 para verificar el enlace, y recién después subir la velocidad si hace falta, midiendo el error en cada paso.

09 · Con el microcontrolador

Calcular el divisor y leer los errores

El primer programa calcula, para una velocidad pedida, el valor de UBRR con redondeo y el error resultante, e imprime el resultado. Es la misma cuenta del apartado 03 y sirve para comprobar, antes de conectar nada, si una combinación de reloj y velocidad es razonable:

void mostrarError(unsigned long baud) {
    // Redondeo al entero más cercano (el mismo cálculo que usa avr-libc en util/setbaud.h)
    unsigned long ubrr = (F_CPU + 8UL * baud) / (16UL * baud) - 1;
    float real = F_CPU / (16.0 * (ubrr + 1));
    float error = (real - baud) / baud * 100.0;

    Serial.print(baud);
    Serial.print(" -> UBRR ");
    Serial.print(ubrr);
    Serial.print(", real ");
    Serial.print(real, 0);
    Serial.print(", error ");
    Serial.print(error, 2);
    Serial.println(" %");
}

void setup() {
    Serial.begin(9600);
    mostrarError(9600);       // 9600 -> UBRR 103, real 9615, error 0.16 %
    mostrarError(115200);     // 115200 -> UBRR 8, real 111111, error -3.55 %
}

void loop() {}

El segundo programa configura la UART del ATmega328P directamente por registros y lee el carácter junto con sus banderas de error. Es código específico de los AVR y reemplaza al objeto Serial (no conviene mezclar ambos). Fijate en el orden: se lee el estado antes que el dato.

void uartInicio() {
    UBRR0 = 103;                                   // 9600 baudios con 16 MHz (modo normal)
    UCSR0B = (1 << RXEN0) | (1 << TXEN0);        // habilitar receptor y transmisor
    UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);     // 8 bits de datos, sin paridad, 1 parada
}

// Devuelve true si hay un carácter. 'errores' trae los bits FE0, DOR0 y UPE0 de ese carácter.
bool uartLeer(uint8_t &dato, uint8_t &errores) {
    if (!(UCSR0A & (1 << RXC0))) return false;                       // no llegó nada
    errores = UCSR0A & ((1 << FE0) | (1 << DOR0) | (1 << UPE0));     // 1.º: leer el estado…
    dato = UDR0;                                                       // 2.º: …recién ahora el dato
    return true;
}

void setup() {
    uartInicio();
    pinMode(13, OUTPUT);
}

void loop() {
    uint8_t c, e;
    if (uartLeer(c, e)) {
        if (e & (1 << FE0))  digitalWrite(13, HIGH);   // error de trama: encender el LED
        // else: procesar el carácter 'c'
    }
}

Para medir una velocidad desconocida con el método del apartado 07, pulseIn(pinRX, LOW) devuelve la duración en microsegundos del pulso en nivel bajo: si el primer carácter es la «U», es el bit de inicio, y 1000000UL / duracion da la velocidad aproximada. Funciona bien hasta 38 400 baudios; a velocidades mayores, un temporizador en modo captura da mejor resolución.

10 · Analogía con programación

Tabla de errores y velocidad de una línea desconocida

La cuenta del divisor se escribe en Python con una función que devuelve el valor de UBRR, la velocidad real y el error. Con ella armamos la tabla de un reloj dado y comparamos los modos. También incluimos la estimación del autobaud (redondeo a la velocidad estándar más cercana) y el error relativo entre dos extremos.

ESTANDAR = (1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200)


def divisor(f, baud, doble=False):
    k = 8 if doble else 16
    ubrr = (f + k * baud // 2) // (k * baud) - 1          # redondeo al entero más cercano
    real = f / (k * (ubrr + 1))
    return ubrr, real, (real - baud) / baud * 100


def valoracion(error):
    e = abs(error)
    if e <= 1: return "excelente"
    if e <= 2: return "aceptable"
    if e <= 3: return "marginal"
    if e <= 5.26: return "al límite"
    return "FALLA"


def error_relativo(baud_tx, baud_rx):
    """Error del período de bit del receptor respecto del emisor, en %."""
    return ((1 + baud_tx / 100) / (1 + baud_rx / 100) - 1) * 100


for f in (16_000_000, 18_432_000):
    print(f"--- Reloj de {f / 1e6:g} MHz ---")
    for baud in (9600, 57600, 115200, 230400):
        for doble in (False, True):
            ubrr, real, err = divisor(f, baud, doble)
            modo = "doble" if doble else "normal"
            print(f"{baud:7d} {modo:6s} UBRR {ubrr:3d}  real {real:9.0f}  error {err:+6.2f} %  {valoracion(err)}")

print()
_, _, err_a = divisor(16_000_000, 115200, False)    # -3,55 %
_, _, err_b = divisor(16_000_000, 115200, True)     # +2,12 %
print(f"AVR normal (receptor) con AVR doble (emisor): {error_relativo(err_b, err_a):+.2f} %")
print(f"AVR normal (receptor) con una PC exacta:       {error_relativo(0, err_a):+.2f} %")

print()
for ancho_us in (104, 52, 8.7):
    medida = 1e6 / ancho_us
    cercana = min(ESTANDAR, key=lambda b: abs(b - medida))
    print(f"pulso de {ancho_us:5g} µs -> {medida:7.0f} baudios -> {cercana}")

Resultado: con 16 MHz, 9600 baudios da error de +0,16 % en los dos modos y 115 200 da −3,55 % (normal) o +2,12 % (doble), «al límite» y «marginal»; 230 400 en modo normal da +8,51 % y FALLA. Con 18,432 MHz todos los errores son 0,00 %, en ambos modos, porque 18 432 000 es múltiplo exacto de 16 × 115 200 (y de 8 × 230 400). Dos AVR a 115 200 baudios, uno en cada modo, tienen un error relativo de +5,88 %, por encima del límite; contra una PC exacta queda en +3,68 %. El autobaud acierta 9600, 19 200 y 115 200 a partir del ancho del pulso.

El modelo del divisor supone el método de redondeo del AVR. Otras familias usan divisores fraccionarios, y algunas prefieren redondear hacia abajo; los valores exactos cambian, pero el método de análisis (calcular la velocidad real, comparar y sumar errores) es el mismo.

11 · Exploración interactiva

Calculadora de baudios y tolerancia

Este laboratorio reúne todo el tema. Elegí el reloj del microcontrolador, la velocidad pedida y el modo del divisor; indicá la tolerancia de tu oscilador y el error de velocidad del otro extremo. Calcula el divisor, la velocidad real, el error en el peor caso, el margen contra el límite de 5,26 % y, con el modelo de muestreo del tema 3, cuántos de los 256 valores posibles de byte se leerían mal, distinguiendo los que producen un error de trama de los que se corrompen en silencio.

El «error relativo en el peor caso» combina el error del divisor, la tolerancia del oscilador (en el sentido que más perjudica) y el error del otro extremo. El conteo de bytes aplica el modelo del tema 3 (muestreo en el centro del bit, caracteres seguidos) a los 256 valores posibles. Los AVR de este laboratorio usan el redondeo al entero más cercano.

Recorrido guiado

1. Con los valores iniciales (16 MHz, 9600 baudios, divisor normal, cristal y otro extremo exacto) el divisor es 103, la velocidad real 9615 baudios y el error +0,16 %. La valoración es excelente y ningún byte se lee mal.
2. Pasá a 115 200 baudios: UBRR = 8, velocidad real 111 111 y error −3,55 %. Queda «al límite». Fijate que el modelo ideal todavía lee bien los 256 bytes: el margen se terminó, pero el error aún no basta para fallar. Un poco de ruido o un otro extremo desviado ya alcanzaría.
3. Cambiá a doble velocidad: UBRR = 16, velocidad 117 647 y error +2,12 %: «marginal». Es mejor que el modo normal, pero no mucho.
4. Subí el reloj a 18,432 MHz con el divisor normal: UBRR = 9 y error 0,00 %. Es la razón de existir de los cristales «de baudios». Probá también 7,3728 y 11,0592 MHz.
5. Volvé a 16 MHz y 115 200 baudios en modo normal y mové el deslizador del otro extremo a +2 %: el error relativo llega a +5,76 %, supera el 5,26 % y los 256 bytes dan error de trama, porque el bit de parada ya se muestrea en el inicio del carácter siguiente. Con el signo contrario (−2 %) el error relativo baja a +1,6 % y todo se lee bien: que dos errores se sumen o se compensen depende de sus signos.
6. Con 9600 baudios y cristal, cambiá el oscilador a RC interno sin calibrar (±10 %): el error relativo en el peor caso pasa del 10 %, la valoración es «falla» y los 256 bytes se leen mal. Un RC sin calibrar no sirve para una UART.
7. Probá 230 400 baudios con 16 MHz: en modo normal sale a +8,51 %, imposible; en doble velocidad, −3,55 %. Con divisor fraccionario, el error es prácticamente cero.
8. Elegí 1 000 000 con 16 MHz: UBRR = 0 y el error es exacto. Con 8 MHz, en cambio, el divisor da UBRR = 0 y la velocidad real queda en 500 000: el divisor no puede alcanzar lo pedido.

12 · Método de trabajo

Cómo configurar y verificar

1. Definí el formato. Salvo que el otro dispositivo pida otra cosa, usá 8N1.
2. Calculá el divisor y el error para tu reloj y la velocidad deseada. Si el error supera el 2 %, probá el doble de velocidad, otra velocidad o un cristal adecuado.
3. Sumá los errores de ambos extremos. Las hojas de datos de los módulos suelen indicar su tolerancia; los adaptadores USB–serie modernos son prácticamente exactos.
4. Evitá los osciladores RC sin calibrar para la UART, o calibralos con una referencia.
5. Empezá con una velocidad baja (9600) y subí gradualmente, verificando que no aparezcan errores.
6. Mirá la línea con un analizador lógico: medí el ancho del bit más corto y compará con el valor teórico; la diferencia es la prueba definitiva del error de velocidad.
7. Leé las banderas de error si el hardware las ofrece: los errores de trama señalan velocidad o formato; los de paridad, formato o ruido; los de desbordamiento, un programa que no lee a tiempo.
8. Prevé la recuperación. Un protocolo robusto debe poder resincronizarse tras un error (delimitadores, tiempos de silencio) y descartar lo corrupto, como veremos en los temas 41 y 45.

Si dos equipos que «deberían entenderse» muestran basura, el primer paso es siempre el mismo: medir un bit con el analizador, convertir a baudios y comparar con lo que cada lado cree que está usando. En cuestión de minutos se descubre un 9600 contra un 115 200, o un 8N1 contra un 7E1.

13 · Comprensión

Confusiones frecuentes

14 · Práctica guiada

Predecí antes de comprobar

1. Calcular un divisor

Calculá UBRR, la velocidad real y el error para 19 200 baudios con un reloj de 16 MHz en modo normal.

2. El reloj de 8 MHz

Un ATmega a 8 MHz debe trabajar a 115 200 baudios. ¿Qué error da en modo normal y en doble velocidad? ¿Qué cristal lo resolvería?

3. Dos extremos con errores

Un AVR a 16 MHz y 115 200 baudios en modo normal habla con otro AVR igual en modo de doble velocidad. ¿Cuál es el error relativo? ¿Y contra una PC con un adaptador exacto?

4. Autobaud

Un analizador lógico mide que el pulso más corto de una línea dura 52 µs. ¿A qué velocidad estándar trabaja? ¿Y si el pulso dura 26 µs?

5. Interpretar síntomas

Un receptor muestra: (a) basura constante; (b) texto perfecto salvo las letras con acento; (c) errores de paridad esporádicos, uno por cada cien caracteres. ¿Qué sospechás en cada caso?

6. Un desbordamiento

Un PC envía datos continuos a 115 200 baudios en 8N1 a un microcontrolador que consulta el puerto cada 2 ms. ¿Cuántos caracteres llegan entre dos consultas y qué ocurre?

15 · Síntesis

Ideas para recordar

¿Listo para el tema 9?

Antes de avanzar, calculá el divisor y el error de 57 600 baudios con un reloj de 16 MHz en ambos modos, decidí si una UART con error de +2,12 % puede hablar con otra con −3,55 % y explicá qué indicaría un error de trama continuo en el receptor. Si podés justificar las tres respuestas, sabés configurar una UART con criterio.

En el próximo tema estudiamos la UART en el microcontrolador: buffers de recepción y transmisión, interrupciones, lectura sin bloqueo, y cómo evitar los desbordamientos.