Depurar comunicaciones

01 · Objetivo

Ver antes de suponer

La regla de oro de la depuración de comunicaciones es esta: nadie puede razonar con certeza sobre un enlace que no está viendo. El código dice qué se quiso enviar; el cable, qué se envió. Y el código del otro extremo dice qué se espera recibir, no qué llegó. Suponer («el cable debe estar bien», «la velocidad es la misma», «el sensor tiene la dirección 0x76») es la manera más cara de perder una tarde. Medir cuesta unos minutos, y cada medición descarta una familia entera de causas.

Las fallas de comunicación tienen una propiedad desagradable: los síntomas se parecen mucho entre sí. «No recibo nada» puede ser un cable cortado, la masa sin unir, una velocidad distinta, un pin mal configurado, un nivel de tensión incompatible, un receptor que no escucha o un emisor que no transmite. La depuración consiste en distinguirlas con el mínimo de mediciones, y para eso hay un método y un puñado de instrumentos.

02 · Pensar antes de medir

Un método: de abajo hacia arriba

El enlace es una pila de capas, y una falla en una capa baja se manifiesta como un síntoma en una alta: una masa sin unir produce bytes errados, que producen tramas con CRC incorrecto, que producen reintentos, que producen una lectura «que no llega». Si se empieza a revisar el protocolo y la falla está en la masa, se pierde el tiempo. Por eso el recorrido es de abajo hacia arriba, y cada capa se da por buena solo después de comprobarla:

1. Alimentación y masa. ¿Los dos dispositivos tienen la tensión correcta? ¿Están unidas las masas? Con el multímetro: tensión de cada placa y continuidad entre las masas. Sin referencia común, las tensiones de las señales no significan nada.
2. Nivel eléctrico. ¿La línea está en el nivel de reposo que corresponde (alto en una UART de 3,3 V, alto con resistencias en I²C, una diferencia mínima en RS-485)? ¿Cambia al transmitir? ¿Llega a los niveles lógicos (más de 2 V para un alto de 3,3 V, menos de 0,8 V para un bajo)?
3. Bits y tiempos. ¿Hay actividad en la línea cuando el emisor transmite? ¿Cuánto dura el bit más corto? De ahí se deduce la velocidad real y se compara con la configurada.
4. Bytes. ¿El decodificador, configurado con la velocidad y el formato esperados, muestra los bytes que se enviaron? Si no, el problema es de velocidad, formato, polaridad o ruido.
5. Trama. ¿Los bytes forman tramas válidas (inicio, largo, CRC)? ¿En qué lugar se rompen?
6. Protocolo. ¿Se confirma lo que se recibe? ¿Los tiempos de espera son adecuados? ¿Los contadores de los dos extremos cuadran (tema 47)?
7. Aplicación. Recién acá se examina el significado de los datos: orden de bytes, escala, rangos (tema 46).

Cuatro hábitos acompañan al método y valen tanto como los instrumentos:

• Una sola cosa a la vez. Si se cambian la velocidad, el cable y el programa a la vez y el enlace anda, no se sabe cuál de los tres era. Se cambia una variable, se prueba, se anota.
• Partir por la mitad. Un sistema con A → cable → B se divide: ¿A transmite bien? (se mira la salida de A con un instrumento, sin B). ¿B recibe bien? (se le entrega una señal conocida desde una computadora). Un bucle de prueba (loopback: unir TX con RX del mismo dispositivo) verifica el pin, la configuración y el programa sin cable ni segundo dispositivo.
• Reemplazar por algo que funcione. Una computadora con un adaptador USB–serie y un programa de terminal es un interlocutor de referencia: si el dispositivo conversa con ella y no con su par, la falla está en el par o en el cable.
• Escribir lo que se ve. La captura, la medición, la hipótesis descartada. Las fallas intermitentes se resuelven con datos acumulados, no con la memoria.

03 · La caja de herramientas

Los instrumentos y para qué sirve cada uno

Los instrumentos se complementan: el osciloscopio responde si la señal es eléctricamente sana; el analizador lógico, qué dicen los bits a lo largo de muchos mensajes; el sniffer, qué conversación hay; y los contadores del programa, qué piensa cada extremo. Un orden de uso muy práctico: el multímetro primero (dos minutos y descarta lo más tonto), después el analizador lógico (barato, versátil, decodifica), y el osciloscopio cuando el analizador dice «los bits llegan» pero el comportamiento sugiere un problema eléctrico (ruido, flancos lentos, reflexiones).

Con el multímetro, las comprobaciones mínimas que siempre conviene hacer antes de lo demás son: (1) la tensión de alimentación de cada placa, bajo carga (un cable USB fino o una fuente débil pueden caer a 4 V cuando transmite la radio); (2) la continuidad de la masa entre los dos extremos (con el cable puesto, resistencia casi nula); (3) la continuidad de cada señal de punta a punta, y que no haya continuidad entre dos señales distintas ni con la masa; (4) el reposo de la línea con el sistema en marcha pero sin transmitir: una UART de 3,3 V debe medir cerca de 3,3 V, no 0 ni 1,6 V (una línea a medias indica un pin flotante o dos transmisores peleando).

04 · La forma de la señal

El osciloscopio

El osciloscopio dibuja la tensión de una línea en función del tiempo, y de ese dibujo se leen cosas que ningún programa ve. Para una comunicación digital, las preguntas típicas son:

Para medir bien hay que respetar algunas reglas de uso que, ignoradas, producen imágenes que mienten:

• Ancho de banda. Un osciloscopio recorta lo que supera su ancho de banda. Un flanco con un tiempo de subida tr tiene un contenido de frecuencias hasta aproximadamente 0,35 / tr; para verlo bien, el instrumento necesita al menos esa banda y, mejor, el doble. Un flanco de 5 ns pide 70 MHz como mínimo, y 140 MHz para medirlo con comodidad. Para una UART de 9600 baudios, con flancos de unas decenas de nanosegundos, sobra con un instrumento básico de 20 MHz; para un SPI de 20 MHz, hacen falta 100 MHz o más (herramienta 3).
• La sonda. Se usa en la posición ×10 (reduce la carga: unos 10 MΩ y 10 a 15 pF frente a la línea) y se compensa con la señal de prueba del propio instrumento hasta que el pulso cuadrado salga cuadrado. El cable de tierra largo de la sonda forma una antena y una inductancia que dibuja oscilaciones que no existen: para señales rápidas se usa el resorte de tierra corto que trae la sonda, en vez del cable con pinza.
• La base de tiempos y el disparo. Para ver un byte de 9600 baudios (1,04 ms) se usa una base de unos 200 µs por división; para una trama de 16 bytes (16,7 ms), unos 2 ms por división. El disparo se pone en el flanco de bajada del bit de inicio, en modo normal (espera el evento) o único (captura una vez), con el nivel en la mitad de la excursión. Un disparo mal puesto hace que la imagen salte y parezca ruido.
• Masa. La masa de la sonda es la del osciloscopio, que normalmente está unida a la tierra de la red. Conectarla a un punto que no esté a masa del circuito produce un cortocircuito. Al medir equipos conectados a la red sin aislar, se usa una sonda diferencial o un transformador de aislación.

Un osciloscopio con función de decodificación serie (muchos modelos actuales la traen para UART, I²C y SPI) tiene lo mejor de los dos mundos para una captura corta: se ve la señal analógica y, encima, los bytes decodificados. Para capturas largas, en cambio, el analizador lógico es mejor: tiene más canales y más memoria.

05 · Ceros y unos, en abundancia

El analizador lógico

Un analizador lógico mira cada línea cada 1/fs segundos (su frecuencia de muestreo), compara la tensión con un umbral y guarda un 0 o un 1 en su memoria. El resultado es un diagrama de tiempos digital de varias líneas a la vez, que un programa decodifica según el protocolo que se le indique. Los modelos económicos (de 8 canales, con USB, de pocas decenas de euros) son suficientes para casi todo lo de este curso. Hay cinco parámetros que se eligen en cada captura:

• Frecuencia de muestreo. Para decodificar una UART hacen falta al menos 4 muestras por bit; para medir bien los anchos, 10 o más. Con menos, un pulso corto puede perderse y el decodificador muestra errores que no existen (herramienta 3). El modelo en Python de la sección 11 lo muestra: una captura de 9600 baudios muestreada a 20 kHz (2,1 muestras por bit) todavía se decodifica en un caso ideal, pero a 15 kHz (1,6) ya da bytes incorrectos sin ningún aviso. Se prefiere 10 veces la velocidad, o más.
• Memoria. Define cuánto tiempo se mira: muestras / fs. Con un millón de muestras a 1 MHz hay un segundo, 960 bytes de una UART a 9600. Subir la frecuencia de muestreo acorta la ventana; por eso se empieza con una frecuencia moderada, y se aumenta solo si hace falta.
• Umbral. La tensión que separa un 0 de un 1. Para una lógica de 3,3 V suele ser 1,65 V; para 1,8 V, alrededor de 0,9 V. Muchos analizadores lo permiten ajustar; si está mal puesto, una señal de 1,8 V puede leerse como siempre 0. Un flanco lento o ruidoso cerca del umbral produce pulsos falsos (otra razón para mirarlo con el osciloscopio).
• Disparo (trigger). Cuándo empieza a registrar. Se dispara por un flanco (la caída de CS en un SPI, el bit de inicio de una UART), por un patrón (el byte 0xA5) o por una secuencia. Sin disparo, se registra una ventana cualquiera y quizá se pierda lo interesante. Un truco muy usado: el programa baja un pin de depuración justo cuando detecta la falla, y el analizador dispara con ese pin; así queda registrado lo que pasó antes del error (el espía de la sección 10 tiene un pin así).
• Los decodificadores. Se agregan sobre los canales: UART (velocidad, bits de datos, paridad, parada, polaridad), I²C (SDA y SCL), SPI (CS, SCLK, MOSI y MISO con el modo), CAN, 1-Wire, y otros. El resultado aparece como una capa de texto sobre las formas de onda: bytes, direcciones, ACK y NACK, errores marcados en rojo.

El analizador lógico tiene sus propias limitaciones, que hay que conocer para no ser engañado:

• No ve la forma analógica. Un flanco que apenas llega al umbral aparece como un pulso perfecto, o no aparece. Si el decodificador muestra errores de manera intermitente y la señal «se ve limpia», el osciloscopio es el siguiente paso.
• No ve lo que pasa entre muestras: un glitch de 20 ns pasa inadvertido a 1 MHz de muestreo, aunque sea suficiente para confundir al receptor real.
• Carga la línea con una capacidad pequeña (varios picofaradios), que casi nunca importa pero sí en un bus I²C ya al límite.
• Necesita la masa unida a la del circuito, como cualquier instrumento: sin ella, las mediciones no tienen referencia.
• Registra durante un tiempo corto: para fallas que ocurren una vez por hora, se deja el sniffer de bytes (sección 8) y se usa el analizador lógico solo cuando se sabe cuándo falla.

06 · El caso más común

Decodificar una UART a mano

Dado un osciloscopio o un analizador sin decodificador, un byte de una UART se lee a mano en cuatro pasos:

1. Medir el bit más corto. En una captura de bytes variados hay pulsos de un solo bit; el más angosto es un tiempo de bit. Si mide 104 µs, la velocidad es 1/104 µs ≈ 9615, o sea 9600 baudios. Se redondea a la velocidad estándar más cercana (1200, 2400, 4800, 9600, 19 200, 38 400, 57 600 o 115 200). Una medida que da 52 µs corresponde a 19 200 baudios, y una que da 208 µs, a 4800.
2. Encontrar el inicio. La línea en reposo está en alto; el primer flanco de bajada es el comienzo del bit de inicio. Desde ahí, cada tiempo de bit trae un bit nuevo.
3. Leer los datos. Se mira la línea en la mitad de cada bit. El primer bit es el menos significativo. En la figura, los ocho bits de datos son 1, 0, 1, 0, 0, 1, 0, 1: invertidos de orden (el primero es el bit 0) dan 10100101 = 0xA5.
4. Comprobar la parada. Después de los bits de datos (y de la paridad, si la hay) la línea tiene que estar en alto. Si está en bajo, es un error de encuadre: el receptor está desfasado, la velocidad es otra o hay un corte.

El carril inferior de la figura muestra por qué una velocidad mal configurada produce basura: el receptor mira la línea en instantes cada vez más corridos respecto de los bits reales. Hacia el final del byte, el error acumulado supera medio bit, y el receptor lee un bit que no es el que corresponde. Con 10 bits por byte, el límite teórico es de ±5 %; con los errores de los osciladores de ambos lados, se considera seguro menos de ±2 a 3 %. Muchos microcontroladores generan los baudios dividiendo un reloj, y algunas velocidades (115 200 desde ciertos relojes) salen con un error de 2 a 3 %; por eso, cuando se combinan dos chips distintos, a veces conviene elegir una velocidad cuyo error sea menor (herramienta 2).

07 · Con reloj

I²C y SPI: qué se ve y qué falla

Los buses con reloj (temas 12 a 20) son más fáciles de leer que una UART, porque el reloj dice cuándo mirar cada bit, y por eso los decodificadores del analizador rara vez se equivocan. Lo que sí hacen es mostrar claramente qué falta. Para cada uno, lo que conviene mirar:

I²C

Una transacción es: condición de inicio (SDA baja con SCL alta), un byte con los siete bits de dirección y el bit de lectura o escritura, un noveno bit de confirmación a cargo del esclavo (ACK si baja SDA, NACK si la deja en alto), los bytes de datos con su ACK, y la condición de parada. Para leer un registro de un BME280 en la dirección 0x76 es: S · EC A · D0 A · Sr · ED A · 60 N · P (la dirección de escritura es 0x76 << 1 = 0xEC, la de lectura 0xED). La herramienta 4 genera la secuencia para cualquier dirección y calcula el tiempo.

SPI

En SPI no hay confirmaciones: un esclavo sordo no avisa. Lo que se ve son cuatro líneas: CS (que baja al inicio y sube al final de cada transacción), SCLK, MOSI y MISO. Los errores típicos son de configuración, y se reconocen por el aspecto de los datos:

Para ambos buses, una técnica útil es la captura de referencia: grabar una transacción que sí funciona (con una biblioteca probada, o con la computadora) y compararla con la que falla. Las diferencias de longitud, de orden, de tiempos o de datos señalan el problema mucho más rápido que mirar el código.

08 · Oír sin hablar

Sniffers: escuchar sin intervenir

Un sniffer es un dispositivo que escucha un enlace sin participar en él y muestra lo que circula. La clave es que sea pasivo: no transmite, no confirma, no carga la línea más de lo imprescindible. Si el sniffer altera el enlace (por ejemplo, contestando un ACK que nadie le pidió), la falla que se persigue puede desaparecer o convertirse en otra. Según el medio:

Un buen sniffer registra, para cada trama: el instante (con la mejor resolución posible), quién habló (la línea o la dirección de origen), los bytes crudos en hexadecimal y el resultado de aplicar las reglas del protocolo: ¿el inicio es el esperado?, ¿el largo es posible?, ¿el CRC verifica?, ¿qué tipo es y qué secuencia lleva? Esto último es lo que distingue una «lista de bytes» de una herramienta de diagnóstico: una línea como [receptor] +26.0 ms 8 bytes MALA: CRC incorrecto | A5 04 01 02 41 00 45 AD dice más que el mismo volcado sin interpretar.

Los sniffers tienen límites que conviene tener claros. La precisión del tiempo es la de la captura: un adaptador USB entrega los bytes con una demora de uno o varios milisegundos que no es constante, así que los instantes de las tramas sirven para ver el orden y los tiempos gruesos (el período, los reintentos a 60 o 120 ms) pero no para medir un viaje de 26 ms con precisión; eso es del analizador lógico, que muestrea con su propio reloj. El sniffer no ve lo eléctrico: una trama que llegó dañada por un flanco lento aparece como una trama con CRC incorrecto, sin decir por qué. Y no puede escuchar lo que no está en su medio: no sirve para ver qué hace el programa dentro del dispositivo. Para eso, los contadores y el registro del propio programa, que a su vez no ven lo que hace el cable. Los tres enfoques se combinan.

09 · Experiencia acumulada

Síntomas y causas típicas

La tabla siguiente reúne las fallas de comunicación más frecuentes en los proyectos de este curso, ordenadas del síntoma a la medición que las confirma. Es la lista de hipótesis que conviene recorrer antes de sospechar del protocolo o del programa.

10 · Con el microcontrolador

Un espía de tramas para el enlace del taller

El programa siguiente es un sniffer pasivo para ESP32 que escucha el enlace del tema 47. Usa dos UART de recepción, una por cada línea (TX del emisor y TX de la receptora), en paralelo con los cables que ya existen, y nunca transmite. Separa las tramas por silencio (5 ms sin bytes), les aplica las reglas del protocolo (inicio, largo, CRC) y muestra una línea por trama con el instante, el tiempo desde la trama anterior y el diagnóstico; las tramas malas aparecen con todos sus bytes. Además, sube un pin de depuración durante 50 µs cada vez que ve una trama mala: conectado a un analizador lógico como canal de disparo, deja capturada la señal real justo en el instante de la falla.

// ---------- Espía pasivo del enlace del tema 47: escucha dos líneas y no transmite nada ----------
const uint8_t  PIN_RX_EMISOR = 25;                             // en paralelo con el TX del emisor
const uint8_t  PIN_RX_RECEPTOR = 26;                           // en paralelo con el TX de la receptora
const uint8_t  PIN_TX_LIBRE_1 = 27, PIN_TX_LIBRE_2 = 14;       // pines de TX de las UART: se dejan sin conectar
const uint8_t  PIN_DEPURAR = 4;                                // un pulso por cada trama mala, para disparar un analizador
const uint32_t BAUDIOS = 9600;
const uint32_t SILENCIO_US = 5000;                             // unos 5 caracteres sin bytes: la trama terminó
const uint32_t INFORME_MS = 10000;

const uint8_t  SOF = 0xA5;
const uint8_t  MAX_LEN = 35;
const size_t   MAX_TRAMA = 64;

uint16_t crc16(const uint8_t *d, size_t n) {
    uint16_t crc = 0xFFFF;
    while (n--) {
        crc ^= *d++;
        for (uint8_t i = 0; i < 8; i++) crc = (crc & 1) ? (crc >> 1) ^ 0xA001 : crc >> 1;
    }
    return crc;
}

// Un canal es una línea que se escucha: acumula bytes hasta que hay un silencio.
struct Canal {
    const char *nombre;
    HardwareSerial *puerto;
    uint8_t  buf[MAX_TRAMA];
    size_t   n = 0;
    bool     desbordado = false;
    uint32_t inicioUs = 0, ultimoByteUs = 0;
    uint32_t validas = 0, malas = 0, bytes = 0;
};

Canal emisor = { "emisor", &Serial1 };
Canal receptor = { "receptor", &Serial2 };
uint32_t ultimoInicioUs = 0;

// Devuelve nullptr si la trama es buena, o el motivo por el que no lo es.
const char *diagnostico(const uint8_t *b, size_t n) {
    if (b[0] != SOF) return "no empieza con A5";
    if (n < 7) return "demasiado corta";
    if (b[1] < 3 || b[1] > MAX_LEN) return "LEN imposible";
    if (n < (size_t)b[1] + 4) return "cortada (faltan bytes)";
    if (n > (size_t)b[1] + 4) return "con bytes de más (dos tramas pegadas?)";
    if (crc16(b + 1, n - 1) != 0) return "CRC incorrecto";
    return nullptr;
}

void cerrar(Canal &c) {
    const char *motivo = c.desbordado ? "más larga que el búfer" : diagnostico(c.buf, c.n);
    c.bytes += c.n;
    uint32_t delta = c.inicioUs - ultimoInicioUs;               // desde el comienzo de la trama anterior, en cualquiera de las dos líneas
    ultimoInicioUs = c.inicioUs;
    Serial.printf("[%-8s] t=%lu.%06lu s  +%7.3f ms  %2u bytes  ", c.nombre, c.inicioUs / 1000000, c.inicioUs % 1000000, delta / 1000.0, (unsigned)c.n);
    if (motivo == nullptr) {
        c.validas++;
        if (c.buf[4] == 0x01) Serial.printf("LECTURA #%u\n", c.buf[5]);
        else if (c.buf[4] == 0x41) Serial.printf("ACK #%u\n", c.buf[5]);
        else Serial.printf("tipo 0x%02X\n", c.buf[4]);
    } else {
        c.malas++;
        Serial.printf("MALA: %s |", motivo);
        for (size_t i = 0; i < c.n; i++) Serial.printf(" %02X", c.buf[i]);
        Serial.println();
        digitalWrite(PIN_DEPURAR, HIGH);                        // el flanco sirve de disparo para el analizador lógico
        delayMicroseconds(50);
        digitalWrite(PIN_DEPURAR, LOW);
    }
    c.n = 0;
    c.desbordado = false;
}

void atender(Canal &c) {
    while (c.puerto->available()) {
        uint8_t b = c.puerto->read();
        uint32_t ahora = micros();
        if (c.n == 0) c.inicioUs = ahora;
        if (c.n < MAX_TRAMA) c.buf[c.n++] = b; else c.desbordado = true;
        c.ultimoByteUs = ahora;
    }
    if (c.n > 0 && micros() - c.ultimoByteUs > SILENCIO_US) cerrar(c);
}

void setup() {
    Serial.begin(115200);
    pinMode(PIN_DEPURAR, OUTPUT);
    Serial1.begin(BAUDIOS, SERIAL_8N1, PIN_RX_EMISOR, PIN_TX_LIBRE_1);
    Serial2.begin(BAUDIOS, SERIAL_8N1, PIN_RX_RECEPTOR, PIN_TX_LIBRE_2);
    Serial.println("Espía listo: escucho el emisor (GPIO 25) y la receptora (GPIO 26) a 9600 baudios");
}

void loop() {
    atender(emisor);
    atender(receptor);
    static uint32_t ultimoInforme = 0;
    if (millis() - ultimoInforme >= INFORME_MS) {
        ultimoInforme = millis();
        Serial.printf("--- emisor: %lu buenas, %lu malas, %lu bytes | receptor: %lu buenas, %lu malas, %lu bytes\n",
                      emisor.validas, emisor.malas, emisor.bytes, receptor.validas, receptor.malas, receptor.bytes);
    }
}

Qué hay que notar:

• Pasivo de verdad. Las UART se abren con los pines de TX en dos pines sin conectar; el programa jamás llama a write. Las entradas del ESP32 son de alta impedancia, por lo que dos de ellas en paralelo con una línea no la alteran de forma apreciable.
• El fin de una trama es el silencio, no el largo: así se detectan también las tramas cortadas o pegadas. Con 9600 baudios un byte dura 1,04 ms, y 5 ms equivalen a casi cinco caracteres; entre dos bytes de la misma trama nunca hay una pausa así. (Para la velocidad de otra aplicación se ajusta SILENCIO_US: Modbus RTU usa 3,5 caracteres.)
• El diagnóstico está ordenado como el decodificador del tema 41: inicio, largo mínimo, largo posible, largo coincidente con lo recibido y, por último, CRC. El primer fallo es el motivo que se informa, que apunta a la capa donde buscar.
• El tiempo es de la lectura de la UART, no del bit en el cable: tiene una incertidumbre de menos de un milisegundo por el ciclo del programa. Sirve para ver la cadencia, los reintentos a 60 y 120 ms y los silencios; no para medir un viaje de 26 ms con precisión. Para eso, el analizador lógico.
• El pin de depuración da un flanco por cada trama mala. Conectado al canal de disparo del analizador (con el disparo en flanco ascendente y una captura previa a él), se obtiene la forma real de la señal justo antes del fallo, que es lo que se necesita para distinguir un ruido de una colisión.
• Los informes de cada 10 s cuentan las tramas buenas y malas por línea. Si el emisor tiene 100 tramas buenas y 12 malas, se sabe que el problema está en un sentido y no en el otro, sin mirar el código de ningún extremo.

11 · Analogía con programación

Un analizador lógico en Python

El modelo siguiente hace en Python lo que hace un analizador: fabrica la captura de muestras de una UART (ceros y unos tomados a una frecuencia fija) a partir de los bytes del taller anterior, mide el bit más corto para estimar la velocidad, decodifica la UART muestreando en la mitad de cada bit y, sobre los bytes obtenidos, hace de sniffer de tramas: busca el inicio, comprueba el largo y verifica el CRC-16. Con él se reproducen tres fallas clásicas: una velocidad equivocada, un muestreo insuficiente y un bit dañado en la trama.

import struct

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


def crc16(datos):
    crc = 0xFFFF
    for b in datos:
        crc ^= b
        for _ in range(8):
            crc = (crc >> 1) ^ 0xA001 if crc & 1 else crc >> 1
    return crc


def armar(dst, src, tipo, datos):
    cuerpo = bytes([len(datos) + 3, dst, src, tipo]) + datos
    return bytes([0xA5]) + cuerpo + crc16(cuerpo).to_bytes(2, "little")


# ---------- Lo que ve un analizador lógico: muestras de 0 y 1 ----------
def bits_de(byte):
    return [0] + [(byte >> i) & 1 for i in range(8)] + [1]        # inicio, 8 datos (LSB primero), parada


def muestrear(datos, baud, fs, reposo=3):
    bits = [1] * reposo + [b for x in datos for b in bits_de(x)] + [1] * 3
    total = int(len(bits) * fs / baud)
    return [bits[min(int((k * baud) / fs), len(bits) - 1)] for k in range(total)]


def rachas(muestras):
    """Cuántas muestras seguidas hay con el mismo valor."""
    salida, n = [], 1
    for a, b in zip(muestras, muestras[1:]):
        if a == b:
            n += 1
        else:
            salida.append(n)
            n = 1
    salida.append(n)
    return salida


def estimar_baud(muestras, fs):
    """La racha más corta es un bit: se calcula la velocidad y se busca la estándar más cercana."""
    ancho = min(rachas(muestras)[1:-1])               # sin el reposo del principio y del final
    crudo = fs / ancho
    return round(crudo), min(BAUDIOS, key=lambda b: abs(b - crudo))


def nivel(muestras, inicio, k, por_bit):
    j = int(inicio + (k + 0.5) * por_bit)             # la mitad del bit k
    return muestras[j] if j < len(muestras) else 1


def decodificar(muestras, fs, baud):
    por_bit = fs / baud
    datos, errores, i = [], 0, 1
    while i < len(muestras):
        if muestras[i - 1] == 1 and muestras[i] == 0 and nivel(muestras, i, 0, por_bit) == 0:
            v = sum(nivel(muestras, i, 1 + k, por_bit) << k for k in range(8))
            if nivel(muestras, i, 9, por_bit) == 1:
                datos.append(v)
            else:
                errores += 1                          # el bit de parada no está en alto: error de encuadre
            i = int(i + 9.5 * por_bit)
        else:
            i += 1
    return bytes(datos), errores


# ---------- Lo que ve un analizador de tramas: bytes ----------
def buscar_tramas(datos):
    tramas, crc_malo, descartados, i = [], 0, 0, 0
    while i < len(datos):
        if datos[i] != 0xA5 or i + 1 >= len(datos) or not 3 <= datos[i + 1] <= 35:
            descartados += 1
            i += 1
            continue
        total = datos[i + 1] + 4
        if i + total > len(datos):
            break                                     # trama cortada al final
        if crc16(datos[i + 1:i + total]) == 0:
            tramas.append((i, datos[i:i + total].hex(" ").upper()))
            i += total
        else:
            crc_malo += 1                             # el A5 era falso, o la trama estaba dañada
            descartados += 1
            i += 1
    return tramas, crc_malo, descartados


lectura = armar(2, 1, 0x01, struct.pack("<BBBhHH", 0, 1, 7, 2350, 5500, 3300))
confirmacion = armar(1, 2, 0x41, bytes([0]))
captura = lectura + confirmacion
fs = 1_000_000
m = muestrear(captura, 9600, fs)
print(f"{len(captura)} bytes -> {len(m)} muestras a {fs // 1000} kHz ({fs / 9600:.1f} por bit)")
print("racha más corta:", min(rachas(m)[1:-1]), "muestras | baud medido y más cercano:", estimar_baud(m, fs))

datos, err = decodificar(m, fs, 9600)
print("a 9600:", datos.hex(" ").upper(), "| errores de encuadre:", err)
print("tramas:", [(p, t[:23] + "...") for p, t in buscar_tramas(datos)[0]])

datos, err = decodificar(m, fs, 4800)
print("a 4800 (equivocada):", len(datos), "bytes,", err, "errores de encuadre, primeros:", datos[:4].hex(" ").upper())

for fs2 in (200_000, 20_000, 15_000, 10_000):
    m2 = muestrear(captura, 9600, fs2)
    d2, e2 = decodificar(m2, fs2, 9600)
    print(f"a {fs2 // 1000} kHz ({fs2 / 9600:.1f} muestras por bit): {'bien' if d2 == captura else 'mal'}, {len(d2)} bytes, {e2} errores de encuadre")

dañada = bytearray(captura)
dañada[9] ^= 0x04                                     # un bit invertido en la temperatura
tramas, crc_malo, descartados = buscar_tramas(bytes(dañada))
print("con un bit dañado:", len(tramas), "tramas válidas,", crc_malo, "rechazada por CRC,", descartados, "bytes descartados")

Resultado: la captura de 24 bytes (una lectura y su confirmación) da 25 625 muestras a 1 MHz, 104,2 por bit. La racha más corta es de 104 muestras, que corresponde a 9615 baudios y a la velocidad estándar más cercana, 9600. Decodificada a 9600 devuelve los 24 bytes, A5 0C 02 01 01 00 01 07 2E 09 7C 15 E4 0C 90 CB A5 04 01 02 41 00 45 AC, sin errores de encuadre, y el analizador de tramas encuentra las dos, en las posiciones 0 y 16. Decodificada con la velocidad equivocada (4800), entrega 3 bytes 04 A3 D0 y 8 errores de encuadre. Con el muestreo reducido: a 200 kHz (20,8 muestras por bit) y a 20 kHz (2,1) la captura se decodifica bien; a 15 kHz (1,6) devuelve 24 bytes, sin ningún error de encuadre y con los valores equivocados; y a 10 kHz (1,0) se pierden bytes (19) y aparecen 5 errores de encuadre. Con un solo bit invertido en la temperatura (byte 9), el analizador de tramas encuentra una trama válida (la confirmación), rechaza una por el CRC y descarta 16 bytes (la lectura entera, porque el inicio falso se rescanea byte a byte).

Tres lecciones del modelo. Primera: la velocidad se mide, no se supone: la racha más corta y una regla de tres dan la velocidad con un error del 0,16 % en este caso, suficiente para reconocer la estándar. Segunda: un muestreo insuficiente no siempre avisa: a 15 kHz la decodificación «sale» sin errores y con los datos mal, el peor tipo de falla; por eso se muestrea con margen y se verifica con el CRC lo que sale. Tercera: el CRC convierte un daño de un bit en un diagnóstico: la trama dañada no se pasa por válida, y el sniffer dice cuántas se rechazaron, que es lo que se busca cuando se persigue una falla intermitente.

12 · Exploración interactiva

Laboratorio: UART, muestreo, I²C y capturas

El laboratorio tiene cinco herramientas. La primera calcula los tiempos de una UART. La segunda decodifica una UART con la velocidad del receptor desajustada, muestreando cada bit como lo haría el hardware. La tercera calcula el muestreo, la memoria y el ancho de banda de los instrumentos. La cuarta genera la secuencia de una transacción I²C y calcula los tiempos y las resistencias de elevación. La quinta analiza una captura de tramas del protocolo del tema 47, como lo haría un sniffer.

En la herramienta 1, un byte tiene un bit de inicio, los de datos, una paridad opcional y una o dos paradas; el silencio de fin de trama es el de 3,5 caracteres de Modbus RTU. En la 2, el receptor busca el flanco de bajada del inicio y mira cada bit en su mitad con su propio reloj; los formatos son iguales en los dos extremos y lo que varía es la velocidad (un 7E1 enviado a un receptor de 8 bits perdería el octavo bit; acá se ve que A5 no entra en 7 bits y se lee 25). En la 3, la incertidumbre de un ancho es de una muestra. En la 4, el tiempo de subida se mide entre el 30 y el 70 % de la excursión (0,8473 · R · C) y el mínimo de la resistencia supone que un pin puede hundir 3 mA con 0,4 V. En la 5, la captura se explora como el decodificador del tema 41 con el CRC-16 del tema 44.

Recorrido guiado

1. En la herramienta 1, con 9600 8N1: 104,2 µs por bit, 1,04 ms por byte, 960 bytes por segundo (80 % de datos), una ráfaga de 16 bytes en 16,67 ms, un silencio de fin de trama de 3,65 ms y 4,8 kHz en el patrón más rápido (0x55). Con 115 200 8E1: 8,7 µs, 11 bits por byte (95,5 µs), 10 473 bytes por segundo (73 % de datos) y 1,53 ms para los 16 bytes.
2. En la herramienta 2, con A5 0C a 9600 contra 9600: se lee A5 0C sin errores. A 9800 (2,1 % de desajuste, un desfase de 0,20 bits): sigue bien. A 10 200 (6,3 %, 0,59 bits): A5 sale bien y el 0C sale con un error de encuadre (✗): el límite está en el filo, y que un byte salga bien y otro mal depende de los datos que lleva. A 10 500 (9,4 %): hasta el primer byte es incorrecto (45). Con el receptor a 4800: lee un único byte, CA, y dos inicios falsos. Con 19 200: tres bytes en lugar de dos y dos errores de encuadre. Con el formato 7E1: A5 se lee como 25, porque el octavo bit no existe.
3. En la herramienta 3, con 9600 baudios y 1 MHz: 104 muestras por bit (cómodo), incertidumbre del 1 %, una ventana de 1 s con 1000 mil muestras (960 bytes, 60 tramas de 16 bytes) y, para un flanco de 5 ns, un osciloscopio de 70 MHz como mínimo. Con 115 200 y 0,5 MHz: 4,3 muestras por bit (justo), con una incertidumbre del 23 %: decodifica pero no sirve para medir. Con 1 Mbaud y 2 MHz: 2 muestras por bit, insuficiente.
4. En la herramienta 4, con la dirección 76, lectura de 1 byte, 100 kHz, 4,7 kΩ y 100 pF: S · EC A · reg A · Sr · ED A · 1 byte · P, 39 bits en 390 µs, subida de 398 ns (el límite es 1000 ns; con 4,7 kΩ el bus soportaría hasta 251 pF) y resistencia mínima de 0,97 kΩ. Con 400 kHz, 10 kΩ y 200 pF: la subida es de 1695 ns contra un límite de 300, el bus ya no cumple (con 10 kΩ solo aguantaría 35 pF). Con 0,5 kΩ y 5 V: el mínimo es de 1,53 kΩ y el pin no lograría bajar la línea. Con escritura de 2 bytes a 400 kHz, 4,7 kΩ y 50 pF: 29 bits en 72,5 µs y 199 ns de subida: correcto.
5. En la herramienta 5, con la captura de ejemplo (62 bytes): 3 tramas válidas (una LECTURA #0 en la posición 0, un ACK #0 en la 18 y una LECTURA #2 en la 42), 1 rechazada por el CRC (la lectura con un bit invertido), 18 bytes descartados (los dos de ruido, FF 00, y los 16 de la trama dañada) y una trama cortada de 4 bytes al final. Probá borrar un byte del medio de una trama, o cambiar uno solo: aparece una nueva candidata rechazada.

13 · Hábitos

Buenas prácticas de depuración

• Diseñar para poder depurar. Lo más barato es incluirlo desde el principio: un contador por cada cosa que puede salir mal (CRC, largo, desborde, copias, rendidos), un informe periódico, un modo de registro de tramas en hexadecimal y un pin de depuración libre (tema 47).
• Dejar puntos de prueba. En una placa propia, pads accesibles para TX, RX, masa y alimentación, y un conector para el analizador. Cuesta un centavo en el diseño y ahorra horas en el campo.
• Usar un vector de prueba conocido. Un mensaje fijo (la trama de ejemplo) con su resultado esperado permite comprobar los dos extremos sin depender de los datos de un sensor.
• El registro no debe cambiar el comportamiento. Un Serial.print a 9600 baudios de 40 caracteres tarda 42 ms: puede ser mayor que el viaje que se mide. Se usa una velocidad alta para la consola (115 200), mensajes cortos, un pin de depuración que cambia en eventos clave, o un búfer que se vuelca fuera de la parte crítica.
• Guardar las capturas. Una captura buena y una mala del mismo evento, con una nota de las condiciones, valen más que cualquier descripción. Sirven también para reportar el problema a un compañero o al fabricante.
• Sospechar de lo físico primero cuando es intermitente. Una falla que aparece y desaparece sola suele ser un contacto, una masa, un conector o ruido; una que ocurre siempre en las mismas condiciones suele ser lógica. Las fallas lógicas se reproducen; las eléctricas, se correlacionan.
• No creer en un solo instrumento. Si el analizador y el programa discrepan, algo de lo que se supone está mal: el umbral, la velocidad, el disparo, el cableado de la sonda.
• Cambiar una cosa y volver. Un arreglo que «funcionó» sin entender por qué es una promesa sin garantía: se revierte, se comprueba que la falla vuelve, y se reaplica.

14 · Comprensión

Confusiones frecuentes

15 · Práctica guiada

Predecí antes de comprobar

1. La velocidad a partir de un pulso

En un analizador, el pulso más angosto de una UART mide 26 µs. ¿A qué velocidad estándar corresponde, y cuánto dura un byte 8N1?

2. Leer un byte a mano

Una UART 8N1 muestra, después del inicio, los bits de datos 1, 0, 0, 0, 0, 0, 1, 0 y la parada en alto. ¿Qué byte es? ¿Qué se leería si se tomara el primer bit como el más significativo?

3. El muestreo del analizador

Se quiere analizar una UART de 115 200 baudios. ¿Qué frecuencia de muestreo mínima y cuál recomendada usarías? ¿Cuánta memoria hace falta para capturar 100 ms?

4. El límite de la velocidad

El emisor transmite a 115 200 con un error de +2 % y el reloj del receptor tiene un error de −4 %. Con 10 bits por byte, ¿se lee bien? ¿Y con −2 % y +2 %?

5. Las resistencias de un bus I²C

Un bus de 400 kHz a 3,3 V tiene 150 pF de capacidad. Se probó con resistencias de 10 kΩ. ¿Cumple? ¿Qué valor elegirías?

6. Qué hace un sniffer ante una trama dañada

Un sniffer ve A5 0C 02 01 01 … con un byte dañado en el medio y el CRC no verifica. ¿Por qué sigue buscando desde el byte siguiente al A5 y no desde el final de la supuesta trama?

7. Un diagnóstico con el espía

Después de 10 s el espía informa: línea del emisor, 20 buenas y 0 malas; línea de la receptora, 12 buenas y 8 malas, todas «cortada (faltan bytes)». Las tramas de la receptora son confirmaciones de 8 bytes. ¿Qué hipótesis plantearías y qué medirías?

8. El orden de las mediciones

Dos placas conectadas por UART no se entienden y no llega ningún byte. Ordená estas mediciones de la primera a la última: decodificar los bytes en el analizador, medir la tensión de cada placa, ver si hay actividad en TX del emisor, comprobar la continuidad de la masa y de los dos cables, medir el bit más corto.

16 · Síntesis

Ideas para recordar

¿Listo para el siguiente tema?

Antes de avanzar, explicá cómo deducirías la velocidad de una UART desconocida con un analizador lógico y qué muestreo usarías para 57 600 baudios; calculá la resistencia de elevación máxima para un bus I²C de 400 kHz con 120 pF; y describí el orden en que medirías un enlace RS-485 que no funciona. Si podés justificar las tres respuestas, sabés cómo se mira un enlace antes de suponer.

En el próximo tema, seguridad en la comunicación, se agrega lo que ni el CRC ni los reintentos resuelven: que alguien con mala intención lea, falsifique o repita los mensajes. Se estudian el cifrado, la autenticación, TLS, la gestión de claves y los mensajes repetidos, y se verá que los sniffers de este tema son también las herramientas que usa un atacante.