Taller: depurar buses con el analizador lógico

01 · Punto de partida

Qué vamos a hacer

En los temas 32 a 34 escribiste el código de tres buses. Ahora vas a verlos. El plan es sencillo: un programa en el Arduino genera tráfico de los tres tipos (un mensaje por la UART, una lectura de registro por I2C y una escritura a un DAC por SPI), un analizador lógico de 8 canales captura las líneas, y un programa de PC (el que trae el analizador, o PulseView) las decodifica. Después cambiamos cosas a propósito: la velocidad del decodificador, una dirección, un modo, un pull-up. Es la forma más rápida de aprender a reconocer una falla: haberla provocado antes.

El taller también cierra el bloque 8. Lo importante no es el instrumento, sino el método: medir antes de suponer. Casi todos los problemas de comunicación serie se resuelven cuando se ve la señal real.

02 · Herramienta

El instrumento

Un analizador lógico muestrea varias señales digitales a la vez, a intervalos fijos, y guarda cada muestra (0 o 1) en un buffer. No mide tensiones (para eso está el osciloscopio): decide, con un umbral, si cada línea está en alto o en bajo. A cambio, captura muchos canales a la vez durante bastante tiempo y entiende los protocolos: decodificadores convierten los flancos en bytes, direcciones, ACK y errores.

Los parámetros que importan son cuatro:

• Frecuencia de muestreo: cuántas veces por segundo se lee cada canal. Debe ser mucho mayor que la velocidad de la señal (sección del laboratorio).
• Profundidad del buffer: cuántas muestras caben por canal. Con 8 millones de muestras a 24 MHz son 333 ms de captura.
• Umbral: la tensión que separa el alto del bajo. Debe coincidir con la lógica del circuito (1,65 V para 3,3 V, 2,5 V para 5 V, o una tensión programable).
• Disparador (trigger): el evento que inicia la captura (un flanco o un patrón en un canal). Sin él, se captura al azar y puede perderse justo lo que interesa.

03 · Paso 1

Un generador de tráfico

El programa del Arduino repite un ciclo con tres transacciones, separadas por pausas. Antes de cada una emite un pulso corto en un pin de marca (PD2) con tantos pulsos como el número de la transacción: uno para la UART, dos para el I2C y tres para el SPI. En la captura, esos pulsos funcionan como etiquetas y como disparador.

#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
/* uart_init, uart_texto (tema 32), i2c_init, i2c_leer_reg16 (tema 33),
   spi_init, spi_transferir, dac_escribir (tema 34) */

static void marca(uint8_t n) {                     // n pulsos de 5 µs en PD2
    while (n--) {
        PORTD |=  (1 << PD2); _delay_us(5);
        PORTD &= ~(1 << PD2); _delay_us(5);
    }
}

int main(void) {
    DDRD |= (1 << PD2);
    uart_init();                                    // 9600 baudios, 8N1
    i2c_init();                                     // 100 kHz
    spi_init();                                     // SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0): 1 MHz
    for (;;) {
        marca(1);  uart_texto("Hola\r\n");          // transacción 1: UART
        _delay_ms(50);
        marca(2);  { uint16_t t; (void)i2c_leer_reg16(0x48, 0x00, &t); }   // transacción 2: I2C
        _delay_ms(50);
        marca(3);  dac_escribir(0x080);             // transacción 3: SPI (envía 0x30 0x80)
        _delay_ms(500);
    }
}

Dos decisiones de diseño. Una: el SPI funciona a 1 MHz (divisor 16) y no a 8 MHz, porque un analizador de 24 MHz solo toma 3 muestras por período a 8 MHz, insuficiente para decodificar con confianza. La regla es adaptar el experimento al instrumento. Dos: las pausas son largas para que cada transacción quede aislada en la captura y se pueda ver el reposo entre ellas.

04 · Paso 2

Conectar y capturar

Los canales del analizador son entradas de alta impedancia: no cargan la línea. Hay tres precauciones. La masa del analizador debe estar unida a la masa del circuito (sin ella, las mediciones carecen de referencia y aparece ruido). El umbral debe corresponder a la lógica del circuito. Y nunca se conectan los canales a tensiones superiores a las que admite el analizador (normalmente 5 V, en algunos modelos 3,3 V). Los cables de prueba cortos reducen el ruido: los muy largos pueden agregar rebotes y falsos flancos.

Configurar la captura

1. Frecuencia de muestreo: 8 o 12 MHz alcanza para I2C a 100 kHz, SPI a 1 MHz y UART a 9600 (la regla es 4× el reloj más rápido; con 1 MHz de SPI son 4 MHz, y 12 MHz da 12 muestras por período). Con 24 MHz sobra.
2. Profundidad: la mayor posible. El ciclo completo dura unos 600 ms, más que lo que cabe en 8 millones de muestras a 24 MHz (333 ms), pero la parte útil cabe sin problema.
3. Disparador: flanco de subida en CH7 (el primer pulso de la marca). Así la captura comienza justo antes de la UART.
4. Umbral: 2,5 V (lógica de 5 V).

Con eso, se captura y aparecen las ocho trazas. Se reconocen a simple vista: en CH7 los pulsos de marca (1, 2 y 3 pulsos), en CH0 una ráfaga de unos 6 ms, en CH1 y CH2 el tren de pulsos del I2C, y en CH3 a CH6 los pulsos del SPI.

05 · Paso 3

Leer la UART

Se agrega un decodificador Async Serial (UART) sobre CH0 con 9600 baudios, 8 bits de datos, sin paridad y 1 bit de parada. El decodificador muestra sobre la traza los caracteres H o l a CR LF con sus valores 0x48, 0x6F, 0x6C, 0x61, 0x0D, 0x0A.

Antes de confiar en el decodificador, hacé la medición manual, que es la que desarma las suposiciones: con los cursores, medí el ancho del pulso más corto de la traza (un bit). Debe dar unos 104 µs. La velocidad es 1 / ancho. Con 104,17 µs son 9600 baudios. Si da 52 µs, la velocidad es de 19 200; si da 8,7 µs, de 115 200.

También se verifica la trama: un bit de inicio en bajo, ocho bits de datos con el menos significativo primero, y un bit de parada en alto. El carácter «H» (0x48 = 0100 1000) aparece como 0 (inicio), 0 0 0 1 0 0 1 0 (bits D0 a D7), 1 (parada). Total: 10 bits, 1,04 ms por carácter, 6,25 ms para el mensaje de 6 caracteres. Si el decodificador marca errores de trama, o los caracteres aparecen como basura, la primera sospecha es la velocidad.

06 · Paso 4

Leer el I2C

Se agrega el decodificador I2C con SDA en CH1 y SCL en CH2. Para la lectura del registro 0x00 del dispositivo 0x48, deben aparecer, en orden:

Con los cursores, se miden tres cosas. La frecuencia de SCL: 10 µs por período son 100 kHz (el TWBR = 72 del tema 33). El tiempo de la transacción: 48 pulsos a 100 kHz son 480 µs, desde el inicio hasta la parada. Y, con una frecuencia de muestreo alta, el tiempo de subida de SDA y SCL: debe ser menor que 1000 ns; si se ve claramente una curva redondeada, los pull-ups son demasiado débiles.

Si no hay dispositivo conectado, el decodificador muestra la dirección 0x90 seguida de un NACK y la parada: así se ve un bus sin respuesta. Es la prueba más rápida de que el problema es de conexión y no de código.

07 · Paso 5

Leer el SPI

Se agrega el decodificador SPI con SCK en CH3, MOSI en CH4, MISO en CH5 y CS en CH6, modo 0, MSB primero, 8 bits por palabra y CS activo en bajo. En la transacción 3 debe verse CS bajar, 16 pulsos de SCK y dos bytes en MOSI: 0x30 0x80 (la palabra de configuración del MCP4921 con el valor 0x080). MISO queda en alto o en bajo, sin información: el DAC no responde.

Los puntos a verificar: CS baja antes del primer pulso y sube después del último (la subida es la que hace que el DAC actualice su salida); SCK queda en bajo en reposo (CPOL = 0); y los datos cambian con el flanco de bajada y se leen en el de subida (modo 0). A 1 MHz, los 16 bits duran 16 µs. La salida del DAC en este caso es 5 V × 0x080 / 4096 = 0,156 V, que se puede comprobar con un multímetro.

Si el decodificador se configura con el modo equivocado (por ejemplo, modo 3 en lugar de 0), los bytes aparecen corridos: la traza no cambió, la interpretación sí. Es el mismo error que ocurriría en el dispositivo real.

08 · Paso 6

Provocar fallos

La mejor forma de aprender a diagnosticar es romper algo a propósito y mirar la captura. Cada fila de la tabla es un experimento: se cambia una cosa, se repite la captura y se anota lo que se ve.

La sección del laboratorio incluye una guía de diagnóstico con estos y otros síntomas. La idea que conviene fijar: un síntoma en la captura apunta a una causa eléctrica o lógica concreta, y casi siempre se puede confirmar con una medición más antes de tocar el código.

09 · Analogía con programación

Un analizador lógico en miniatura

Este programa construye la forma de onda de un mensaje UART, la muestrea con distintas frecuencias y fases, y la decodifica como lo haría un analizador. Prueba qué pasa cuando el decodificador está configurado con la velocidad equivocada, con qué frecuencia de muestreo se decodifica de forma confiable, y repite el ejercicio con una transacción I2C.

import math

# --- un analizador logico, en miniatura: se muestrea una forma de onda ideal y se decodifica ---

def onda_uart(texto, baud, relleno=2):
    bits = [1] * relleno
    for byte in texto.encode("ascii"):
        bits += [0] + [(byte >> i) & 1 for i in range(8)] + [1]
    return bits + [1] * 3

def muestrear(bits, baud, fs):
    n = math.ceil(len(bits) / baud * fs)
    return [bits[min(len(bits) - 1, int(i / fs * baud))] for i in range(n)]

def decodificar_uart(muestras, fs, baud):
    salida, errores, i = [], 0, 1
    while i < len(muestras):
        if muestras[i - 1] == 1 and muestras[i] == 0:
            t0 = i / fs
            def en(k):
                return muestras[min(len(muestras) - 1, int((t0 + (k + 0.5) / baud) * fs))]
            valor = sum(en(k + 1) << k for k in range(8))
            if en(9) != 1:
                errores += 1
            salida.append(valor)
            i = int((t0 + 9.5 / baud) * fs) + 1
        else:
            i += 1
    return bytes(salida), errores

print("UART 9600, texto 'Hola', decodificador a distintas velocidades (fs = 100 kHz):")
bits = onda_uart("Hola", 9600)
m = muestrear(bits, 9600, 100e3)
for dec in (9600, 19200, 4800, 2400):
    datos, err = decodificar_uart(m, 100e3, dec)
    texto = "".join(chr(b) if 32 <= b < 127 else "." for b in datos)
    print(f"  decodificador a {dec:5d}: {texto!r:12s} ({len(datos)} bytes, {err} errores de trama)")

import random
random.seed(21)

def muestrear_fase(bits, baud, fs, fase):
    n = math.ceil(len(bits) / baud * fs)
    return [bits[min(len(bits) - 1, max(0, int((i / fs + fase) * baud)))] for i in range(n)]

print()
print("UART 9600 (emisor con +1 % de error): aciertos en 200 capturas con fase aleatoria")
for fs in (14400, 19200, 28800, 38400, 48000, 100000):
    aciertos = 0
    for _ in range(200):
        fase = random.uniform(0, 1 / fs)
        m = muestrear_fase(bits, 9600 * 1.01, fs, -fase)
        datos, err = decodificar_uart(m, fs, 9600)
        if datos == b"Hola" and err == 0:
            aciertos += 1
    print(f"  fs = {fs / 1000:6.1f} kHz ({fs / 9600:4.1f} por bit): {aciertos / 2:5.1f} % correctas")

# --- I2C: cada bit de SCL se descompone en tres pasos; se muestrea y se decodifica ---
def codificar(eventos):
    m = [(1, 1)]
    paso = m.append
    for ev in eventos:
        if ev[0] == "S":
            paso((1, 0)); paso((0, 0))
        elif ev[0] == "Sr":
            paso((0, 1)); paso((1, 1)); paso((1, 0)); paso((0, 0))
        elif ev[0] == "P":
            paso((0, 0)); paso((1, 0)); paso((1, 1))
        else:
            valor, ack = ev[1], ev[2]
            for i in range(7, -1, -1):
                b = (valor >> i) & 1
                paso((0, b)); paso((1, b)); paso((0, b))
            a = 0 if ack else 1
            paso((0, a)); paso((1, a)); paso((0, a))
    return m

def decodificar_i2c(muestras):
    salida, bits, previo = [], [], muestras[0]
    for scl, sda in muestras[1:]:
        pscl, psda = previo
        if scl == 1 and pscl == 1 and psda == 1 and sda == 0:
            salida.append("S" if not salida or salida[-1] == "P" else "Sr"); bits = []
        elif scl == 1 and pscl == 1 and psda == 0 and sda == 1:
            salida.append("P"); bits = []
        elif scl == 1 and pscl == 0:
            bits.append(sda)
            if len(bits) == 9:
                valor = int("".join(map(str, bits[:8])), 2)
                salida.append(f"{valor:02X}{'a' if bits[8] == 0 else 'n'}")
                bits = []
        previo = (scl, sda)
    return " ".join(salida)

eventos = [("S",), ("B", 0x90, True), ("B", 0x00, True), ("Sr",), ("B", 0x91, True),
           ("B", 0x19, True), ("B", 0x80, False), ("P",)]
pasos = codificar(eventos)
f_scl = 400e3
duracion = 1 / (3 * f_scl)                     # cada bit ocupa tres pasos = un periodo de SCL
esperado = decodificar_i2c(pasos)
print()
print("I2C a 400 kHz, decodificado con distintas frecuencias de muestreo del analizador:")
for veces in (1.5, 2, 3, 4, 10):
    fs = veces * f_scl
    n = int(len(pasos) * duracion * fs)
    muestras = [pasos[min(len(pasos) - 1, int(i / fs / duracion))] for i in range(n)]
    resultado = decodificar_i2c(muestras)
    estado = "correcto" if resultado == esperado else "INCORRECTO"
    print(f"  fs = {veces:4.1f} x SCL ({fs / 1e6:5.2f} MHz): {estado}")
print("transaccion esperada:", esperado, "(a = ACK, n = NACK)")

# --- cuanto dura una captura ---
print()
print("duracion de una captura de 8 millones de muestras:")
for fs in (24e6, 4e6, 1e6):
    print(f"  a {fs / 1e6:4.0f} MHz: {8e6 / fs * 1000:6.0f} ms")

Resultado: con el decodificador a 9600 baudios sale «Hola»; con 19 200 salen 8 bytes basura y un error de trama; con 4800, 2 bytes y 2 errores. En la UART, con 3 muestras por bit o más el 100 % de las capturas con fase aleatoria se decodifica bien; con 2 por bit acierta el 28 % y con 1,5, el 43 %. En I2C a 400 kHz, un muestreo de 1,5×, 2× o 3× el reloj falla y con 4× decodifica la transacción completa (S 90a 00a Sr 91a 19a 80n P). Una captura de 8 millones de muestras dura 333 ms a 24 MHz, 2 s a 4 MHz y 8 s a 1 MHz.

La forma de onda es ideal y el único error es el de muestreo; un cable real agrega rebotes, ruido y flancos lentos que hacen falta más muestras para resolver.

10 · Exploración interactiva

Muestreo, UART y diagnóstico

La primera herramienta calcula si tu analizador es suficiente para un protocolo. La segunda construye una captura UART y la decodifica con la velocidad que elijas. La tercera es una guía de síntomas: elegí el bus y lo que ves, y obtené la causa probable.

Recorrido guiado

1. I2C a 400 kHz con 24 MHz: 60 muestras por período, «Excelente». Bajá el muestreo a 1 MHz: 2,5 muestras por período y el veredicto «Justo». Con 4 MHz: 10 muestras por período.
2. SPI a 8 MHz con 24 MHz de muestreo: 3 muestras por período, «Justo»; necesitarías 32 MHz o más. Por eso el taller usa SPI a 1 MHz.
3. En la herramienta 2, «Hola» a 9600 con el decodificador a 9600 y 100 kHz sale limpio. Cambiá el decodificador a 19 200: 8 bytes de basura. A 4800: solo 2.
4. Bajá el muestreo a 20 kHz (2,1 muestras por bit): todavía sale «Hola» pero por poco margen; a 10 kHz (1 por bit) se rompe un carácter.
5. Pasá el emisor a 115 200 con 100 kHz: 0,9 muestras por bit y la captura es ilegible; con 1 MHz vuelve a decodificar.
6. En la guía, elegí I2C y «No hay ACK»: la causa más probable es la dirección de 8 bits frente a 7. Cambiá a SPI y «MISO siempre vale 0xFF».

11 · Cierre del bloque 8

Lo aprendido en el bloque

1. La comunicación serie ahorra pines: la síncrona usa un reloj compartido y la asíncrona se sincroniza con un bit de inicio y exige velocidades parecidas (±2 %).
2. La UART es el enlace punto a punto de dos cables: baudios, formato 8N1, divisor UBRR0 y buffers con interrupciones para no perder bytes.
3. I2C conecta muchos dispositivos con dos cables, direcciones y ACK, a costa de pull-ups y velocidad (100 a 400 kHz).
4. SPI es rápido y simple, con una línea de selección por esclavo y cuatro modos de reloj que deben coincidir.
5. El analizador lógico convierte líneas en bytes: se muestrea a 4× como mínimo, se dispara en el evento correcto y se decodifica con el protocolo y la velocidad correctos.
6. Diagnosticar es medir: un síntoma en la captura apunta a una causa concreta (velocidad, dirección, modo, pull-up, CS).

Con este taller termina el bloque 8. Hasta ahora el microcontrolador aprendió a leer tensiones y a hablar con otros chips. El bloque 9 junta ambas cosas para trabajar con sensores y actuadores reales: cómo acondicionar y calibrar una señal, leer un sensor por bus, y manejar cargas de potencia como motores, relés y servos.

12 · Comprensión

Confusiones frecuentes

13 · Práctica guiada

Predecí antes de comprobar

1. Medir una velocidad

En la captura de una UART, el pulso más corto mide 52 µs. ¿Qué velocidad tiene?

2. Muestreo para el SPI

Un SPI a 4 MHz: ¿qué frecuencia de muestreo mínima y ideal necesita el analizador? ¿Sirve uno de 24 MHz?

3. Leer una captura I2C

El decodificador muestra: S, 0x90 ACK, 0x0F ACK, 0x80 ACK, P. ¿Qué hizo el maestro?

4. Leer una captura SPI

En MOSI se ven los bytes 0x30 y 0x80 con CS bajo. Si es un MCP4921 con referencia de 5 V, ¿qué tensión entrega?

5. Una transacción sin respuesta

En una captura I2C se ve S, 0x90 y NACK, P. ¿Cuáles son las tres causas más probables?

14 · Síntesis

Ideas para recordar

¿Listo para el bloque 9?

Antes de avanzar, calculá la frecuencia de muestreo que necesita tu analizador para un bus dado, medí la velocidad de una UART con el ancho del bit y explicá qué verías en la captura si un dispositivo I2C no estuviera conectado. Si podés justificar las tres respuestas, cerraste el bloque de comunicación serie.

En el próximo tema empieza el bloque de sensores y actuadores con lectura de sensores: acondicionamiento y calibración: cómo preparar la señal de un sensor, corregir sus errores y convertir su lectura en una medida confiable.