Modos SPI, velocidad y orden de bits

01 · El problema

El problema: cuándo se lee el bit

En SPI el maestro marca el ritmo con SCLK, y en cada pulso cada lado hace dos cosas: poner un bit nuevo en su línea y leer el bit que le llega. Si las dos operaciones ocurrieran en el mismo instante habría una carrera: el dato estaría cambiando justo cuando el otro lo mira. Por eso cada pulso de reloj tiene dos flancos y se reparten el trabajo: un flanco cambia el dato y el otro lo muestrea, medio período después, cuando el nivel ya se estabilizó (los tiempos de establecimiento y de retención del tema 3).

El problema es que hay dos decisiones de diseño y ningún estándar que las fije:

• ¿El reloj reposa en nivel bajo o alto cuando no hay transferencia?
• ¿Se muestrea en el primer o en el segundo flanco de cada pulso?

Cuatro combinaciones, cuatro modos SPI. Cada fabricante eligió el suyo, y el maestro tiene que usar el que espera el esclavo. Y como el comportamiento de un modo equivocado no es un error visible, sino bytes que llegan con bits corridos, conviene entenderlo bien.

02 · Las dos configuraciones

CPOL y CPHA: los cuatro modos

Los dos parámetros tienen nombres poco amigables, pero ideas simples:

Hay una regla para no memorizar la tabla: se muestrea en el flanco de subida cuando CPOL y CPHA son iguales (modos 0 y 3), y en el de bajada cuando son distintos (modos 1 y 2). El dato cambia en el otro flanco. El número de modo es, simplemente, CPOL × 2 + CPHA.

En la práctica, los modos 0 y 3 son los más usados, porque ambos muestrean en el flanco de subida. Muchos dispositivos aceptan los dos («modo 0 o modo 3»), y la mayoría de las tarjetas SD, memorias flash y sensores aparecen con uno de ellos. Los modos 1 y 2 son más raros, pero existen.

Una sutileza de CPHA = 0: como el primer flanco ya es el de muestreo, el primer bit tiene que estar listo antes de que el reloj se mueva. El maestro lo coloca en MOSI cuando baja CS, y el esclavo debe poner el suyo en MISO también al ser seleccionado. En CPHA = 1 el primer flanco todavía solo cambia el dato, así que el dispositivo tiene más tiempo para preparar su primer bit.

03 · Verlo en el tiempo

Diagramas de tiempo

Los diagramas siguientes muestran un byte (0xA5 = 10100101) en dos modos. En ambos el reloj reposa en bajo (CPOL = 0), así que los pulsos suben primero. La diferencia está en dónde está el dato respecto de cada flanco.

Los modos 2 y 3 son idénticos a 0 y 1, pero con el reloj invertido (reposa en alto y los pulsos son hacia abajo). El dato se mantiene en el mismo lugar respecto del primer y del segundo flanco. Para el programador el resumen es el que dio la regla: modos 0 y 3 muestrean en la subida; 1 y 2, en la bajada.

04 · Cuánto se puede acelerar

La frecuencia máxima

SPI no fija una velocidad: la limita el dispositivo, el cableado y el propio microcontrolador. La limitación del dispositivo surge de un razonamiento de tiempos. Entre el flanco que cambia el dato y el que lo muestrea pasa medio período del reloj, y en ese lapso tiene que cumplirse todo lo siguiente:

• El que transmite necesita un tiempo desde el flanco hasta que el nuevo valor aparece en la línea: el retardo de salida (clock-to-output, t_co).
• La señal viaja por la placa y los cables: un retardo de propagación (t_p), de unos 5 ns por metro de pista.
• El receptor necesita el dato estable antes del flanco de muestreo: el tiempo de establecimiento (t_su, setup).

Ejemplo: un esclavo que tarda 25 ns en entregar el dato, un maestro con 10 ns de establecimiento y 5 ns de retardo de propagación en la placa. La suma es 40 ns, así que el medio período mínimo es 40 ns, el período 80 ns y la frecuencia máxima 12,5 MHz. En la práctica se usa un poco menos para dejar margen.

El tiempo de retención (hold, t_h) casi nunca es el límite, porque el dato se mantiene medio período después del flanco. Importa más a frecuencias muy altas y con cables largos.

Tres cosas más que bajan la frecuencia útil por debajo de la de la hoja de datos:

• El cableado. Pistas cortas de una placa llegan a decenas de MHz; un protoboard con cables de 20 cm se vuelve poco confiable por encima de unos 4 MHz; un cable de 50 cm, de 1 MHz en adelante. Los flancos se redondean por la capacidad (tema 5) y el cable se comporta como antena.
• La frecuencia del reloj del microcontrolador. El periférico SPI divide el reloj del sistema por potencias de dos: en un Uno de 16 MHz, los valores posibles son 8, 4, 2, 1 MHz… y 500 kHz, 250 kHz, 125 kHz. Pedir 5 MHz da 4 MHz.
• El nivel lógico. Los adaptadores de nivel (tema 5) tienen su propia velocidad máxima; un divisor resistivo ya no sirve por encima de un par de MHz.

El tiempo de una transferencia es lo ya visto: 8 / f segundos por byte. A 4 MHz, 2 µs; a 10 MHz, 0,8 µs. Pero la velocidad útil queda por debajo de la teórica, porque entre bytes el microcontrolador suele dejar una pausa y el software que baja y sube CS también cuesta. Para transferencias largas (una pantalla, una tarjeta SD) se usa DMA, que mueve los bytes sin intervención del programa.

05 · Qué bit va primero

Orden de bits y tamaño de palabra

Además del modo, el maestro tiene que acordar con el esclavo en qué orden salen los bits de cada byte (tema 2):

• MSB primero (MSBFIRST): sale primero el bit 7. Es el orden de casi todos los dispositivos SPI y el valor por defecto en las bibliotecas.
• LSB primero (LSBFIRST): sale primero el bit 0. Es raro, pero existe en algunos controladores de LED y registros de desplazamiento.

Equivocarse en el orden no desalinea el reloj ni hace perder bits: el byte llega «al revés». El valor 0x01 (00000001) se convierte en 0x80, y 0x2C (00101100), en 0x34 (00110100). Si lo que ves son valores que parecen espejados, sospechá del orden de bits.

Otras dos decisiones del mismo estilo:

• Tamaño de palabra. La mayoría de los dispositivos trabaja con bytes de 8 bits, pero algunos conversores esperan palabras de 12, 16 o 24 bits sin pausa entre ellas. El periférico de hardware suele soportar 8 y 16 bits; para otros tamaños se envían varios bytes seguidos con CS en bajo y se descartan los bits sobrantes.
• Orden de bytes en datos de varios bytes. Un valor de 16 bits puede llegar con el byte alto primero (big endian) o con el bajo primero (little endian), según el dispositivo. SPI solo mueve bytes: cómo se arma el entero es asunto del programador y de la hoja de datos.

06 · De la hoja de datos al código

Leer una hoja de datos

Casi nunca hay que deducir el modo: la hoja de datos lo dice, pero cada fabricante lo dice a su manera. Estas son las formas habituales de encontrarlo:

• Una frase directa: «el dispositivo soporta los modos SPI 0 y 3», o «CPOL = 1, CPHA = 1».
• Un diagrama de tiempo con SCK, SDI y SDO: se mira si el reloj reposa en bajo o en alto, y en qué flanco el dato es estable (flechas o marcas de captura).
• Una tabla de características: f_SCK máxima, tiempos t_su y t_h de la entrada de datos, t_co (a veces escrito t_v o t_DO) de la salida y anchos mínimos de los pulsos de reloj en alto y en bajo.

Los conceptos a buscar, en el orden en que conviene hacerlo:

1. El modo (o cuándo captura el dato y cómo reposa el reloj).
2. La frecuencia máxima, y si la tabla distingue entre lectura y escritura (a veces la lectura es más lenta).
3. El orden de bits y el formato del comando (qué bit marca lectura, cuántos bytes de dirección).
4. El mapa de registros y un registro de identificación para la primera prueba.
5. El nivel lógico de alimentación y de las entradas.

Observá que dos dispositivos pueden convivir en el mismo bus con modos diferentes. No hay conflicto, siempre que el maestro cambie los ajustes antes de cada conversación: es exactamente para lo que existe SPI.beginTransaction() en la siguiente sección.

07 · Con el microcontrolador

Con el microcontrolador

En Arduino los tres parámetros viajan juntos en un objeto SPISettings(frecuencia, orden, modo), y los modos tienen constantes SPI_MODE0 a SPI_MODE3. El mismo código sirve para ESP32 y casi todas las placas. Veamos la lectura del registro de identificación de un ADXL345 (modo 3, MSB primero) y de un segundo dispositivo en modo 0 que comparte el bus:

#include <SPI.h>

const byte CS_ACEL = 9;                          // acelerómetro ADXL345
const byte CS_FLASH = 10;                        // memoria flash W25Q

const SPISettings AJ_ACEL(2000000, MSBFIRST, SPI_MODE3);    // 2 MHz, modo 3
const SPISettings AJ_FLASH(8000000, MSBFIRST, SPI_MODE0);   // 8 MHz, modo 0

byte leerIdAcelerometro() {
    SPI.beginTransaction(AJ_ACEL);                // aplica 2 MHz y modo 3 solo a esta conversación
    digitalWrite(CS_ACEL, LOW);
    SPI.transfer(0x80 | 0x00);                    // lectura (bit 7) del registro 0x00 (DEVID)
    byte id = SPI.transfer(0x00);                 // byte de relleno: llega el dato
    digitalWrite(CS_ACEL, HIGH);
    SPI.endTransaction();
    return id;
}

uint32_t leerIdFlash() {
    SPI.beginTransaction(AJ_FLASH);               // otros ajustes: 8 MHz y modo 0
    digitalWrite(CS_FLASH, LOW);
    SPI.transfer(0x9F);                           // comando «leer identificación JEDEC»
    uint32_t id = 0;
    for (byte i = 0; i < 3; i++) id = (id << 8) | SPI.transfer(0x00);   // tres bytes, el alto primero
    digitalWrite(CS_FLASH, HIGH);
    SPI.endTransaction();
    return id;
}

void setup() {
    Serial.begin(115200);
    pinMode(CS_ACEL, OUTPUT);  digitalWrite(CS_ACEL, HIGH);
    pinMode(CS_FLASH, OUTPUT); digitalWrite(CS_FLASH, HIGH);
    SPI.begin();
}

void loop() {
    Serial.print("ADXL345 DEVID: 0x");
    Serial.println(leerIdAcelerometro(), HEX);    // debe dar 0xE5
    Serial.print("Flash JEDEC: 0x");
    Serial.println(leerIdFlash(), HEX);
    delay(1000);
}

Dos cosas a notar. Primero, cada función aplica sus propios ajustes con beginTransaction, así que las dos pueden alternarse sin que una «ensucie» a la otra. Segundo, la primera prueba de un dispositivo nuevo es siempre un registro de identificación de valor conocido: el DEVID del ADXL345 vale 0xE5. Si lo leés bien, el cableado, el modo y la frecuencia son correctos; si da 0x00 o 0xFF, no lo son.

Una advertencia sobre la API antigua: SPI.setClockDivider(), SPI.setDataMode() y SPI.setBitOrder() configuran el bus de forma global y están desaconsejadas. Con SPISettings el programa se vuelve más seguro, sobre todo cuando se mezclan bibliotecas de pantalla y de tarjeta SD sobre el mismo bus.

En el ESP32 la misma clase de objeto es compatible, pero además se pueden crear instancias independientes de bus (SPIClass) con sus propios pines, y la frecuencia pedida se respeta mucho más de cerca (el divisor es mucho más fino que en el Uno).

08 · Analogía con programación

Qué recibe un esclavo con el modo equivocado

Podemos modelar el reloj y el dato como una línea de tiempo en semiperíodos y averiguar exactamente qué bit lee un esclavo con cualquier combinación de modos. El modelo coloca los 16 flancos en los instantes 1 a 16; con CPHA = 0 el bit i es válido desde el instante 2i; con CPHA = 1, desde 2i + 1. El esclavo muestrea en el flanco que le corresponde por su propio CPOL y CPHA, aunque el reloj que ve lo haya generado un maestro de otro modo. Si el muestreo coincide con el instante en que el dato cambia, el modelo lo cuenta como carrera (c en la tabla): en un circuito real el resultado sería impredecible, y el modelo supone que se lee el valor nuevo.

MODOS = {0: (0, 0), 1: (0, 1), 2: (1, 0), 3: (1, 1)}   # modo -> (CPOL, CPHA)


def instantes_de_muestreo(modo_tx, modo_rx):
    """Instantes (en semiperíodos) en que el receptor muestrea el reloj que genera el transmisor."""
    cpol_tx, _ = MODOS[modo_tx]
    cpol_rx, cpha_rx = MODOS[modo_rx]
    rx_flanco_subida = (cpol_rx == cpha_rx)
    subida_en_impares = (cpol_tx == 0)
    desfase = 1 if rx_flanco_subida == subida_en_impares else 2
    return [2 * j + desfase for j in range(8)]


def recibir(byte, modo_tx, modo_rx, rx_msb=True):
    cpha_tx = MODOS[modo_tx][1]
    compensacion = cpha_tx                        # CPHA 0: el dato ya está antes del flanco; CPHA 1: cambia en él
    bits = [(byte >> (7 - i)) & 1 for i in range(8)]
    recibido, carreras = 0, 0
    for j, t in enumerate(instantes_de_muestreo(modo_tx, modo_rx)):
        indice = (t - compensacion) // 2
        bit = bits[indice] if 0 <= indice < 8 else 0
        if (t - compensacion) % 2 == 0:
            carreras += 1                         # el dato cambia justo cuando se muestrea
        recibido = (recibido << 1 | bit) if rx_msb else (recibido | bit << j)
    return recibido, carreras


print("Se envía 0xA5. Filas: modo del maestro. Columnas: modo del esclavo.")
print("          esclavo 0   esclavo 1   esclavo 2   esclavo 3")
for tx in range(4):
    celdas = []
    for rx in range(4):
        valor, carreras = recibir(0xA5, tx, rx)
        celdas.append(f"{valor:#04x} ({carreras}c)" if carreras else f"{valor:#04x}      ")
    print(f"maestro {tx}   " + "   ".join(celdas))
print()
for dato in (0x01, 0x2C):
    print(f"{dato:#04x} enviado MSB primero, leído LSB primero: {recibir(dato, 0, 0, rx_msb=False)[0]:#04x}")

Resultado: en la diagonal (mismo modo) el byte llega perfecto, sin carreras. Entre modos distintos hay tres comportamientos. Los modos 0 y 3, y los modos 1 y 2, se entienden entre sí: 0xA5 llega sin carreras, porque muestrean en el mismo tipo de flanco y el dato está estable en ese instante. Un maestro en modo 0 con un esclavo en modo 1 o 2 (y un maestro en modo 2 con un esclavo en modo 0 o 3) produce 8 carreras y el esclavo recibe 0x4A en lugar de 0xA5: los bits quedan corridos una posición. Los otros cuatro pares (maestro 1 con esclavo 0 o 3, maestro 3 con esclavo 1 o 2) devuelven 0xA5 con 8 carreras: coincidencia del modelo, sin valor en un circuito real. La última parte muestra el orden de bits: 0x01 se lee como 0x80 y 0x2C como 0x34.

Atención con la conclusión de «0 y 3 se entienden»: es una propiedad del modelo ideal, que solo mira el flanco de muestreo. En un dispositivo real, el reposo del reloj puede importar (algunos usan el nivel de reposo para detectar el comienzo), y las hojas de datos que anuncian «modo 0 o 3» garantizan los dos. Aun así, es una buena razón para usar el modo más conocido: el 0.

09 · Exploración interactiva

Laboratorio: modos, enlace y frecuencia

El laboratorio tiene tres herramientas. La primera dibuja la forma de onda de cualquiera de los cuatro modos para un byte que elijas, con los instantes de muestreo marcados. La segunda enfrenta un maestro de un modo con un esclavo de otro y muestra qué byte recibe. La tercera calcula si una frecuencia de reloj es viable según el dispositivo y el cableado.

En la segunda herramienta, los bits resaltados son los que difieren de lo enviado. Una «carrera» es un muestreo que cae justo en el instante en que el dato está cambiando; el resultado de esa lectura es impredecible en un circuito real (el modelo supone que se lee el valor nuevo). La tercera herramienta usa límites de cableado orientativos, no valores garantizados.

Recorrido guiado

1. Con el modo 0 y el byte 165 (0xA5), mirá la forma de onda. El reloj (_¯_¯…) reposa en bajo, los bits cambian en los flancos de bajada y las flechas de muestreo caen en el centro de cada bit, sobre el flanco de subida.
2. Pasá al modo 1. El reloj es el mismo, pero el dato se desplazó medio período: ahora las flechas caen sobre el flanco de bajada, y el primer bit recién aparece después del primer flanco.
3. Probá el modo 2 y el modo 3: el reloj reposa en alto (¯_¯_…). El 3 muestrea en la subida como el 0; el 2, en la bajada como el 1.
4. En la herramienta 2, con maestro en modo 0 y esclavo en modo 1 (valores iniciales), el esclavo recibe 0x4A en lugar de 0xA5, con 8 de 8 muestreos conflictivos: cada bit se lee corrido, y el byte queda multiplicado por 2 (con el bit final perdido). Es la «señal de modo equivocado».
5. Probá maestro en modo 0 y esclavo en modo 3: llega 0xA5 sin conflictos. En este modelo ideal ambos muestrean en la subida. Lo mismo con modo 1 y modo 2.
6. Pasá el esclavo a modo 0 con el maestro en modo 1: el byte parece correcto (0xA5), pero con 8 de 8 muestreos conflictivos; el veredicto «Casualidad» lo marca como no confiable.
7. Con los modos iguales, cambiá el orden del esclavo a LSB primero y enviá 1: el esclavo recibe 128 (0x80). Con 44 (0x2C) recibe 52 (0x34). Ningún modo equivocado, y los datos igual salen espejados.
8. En la herramienta 3, con los valores iniciales (4 MHz, dispositivo de 10 MHz, protoboard), el bit dura 250 ns, un byte 2,0 µs y la velocidad útil máxima es 500 kB/s: dentro del límite, justo en el máximo del cableado.
9. Subí a 8 MHz: el dispositivo lo admite (10 MHz), pero el veredicto es «Excede el límite» por culpa del cableado. Cambiá a «pistas cortas de una placa» y pasa. Con 16 MHz, ahora es el dispositivo quien no llega.

10 · Cuando la hoja de datos no alcanza

Cómo se encuentra el modo correcto

Si la hoja de datos no es clara, o si el módulo es de un fabricante sin documentación, se procede por eliminación, con un criterio: un registro de valor conocido y los cuatro modos.

1. Bajá la frecuencia a 100 kHz: así se descartan los problemas de velocidad y solo queda el modo.
2. Probá el modo 0, que es el más común. Leé el registro de identificación.
3. Si no coincide, probá el modo 3, después el 1 y el 2. El primer valor correcto indica el modo; confirmalo con un segundo registro.
4. Con el analizador lógico, mirá el reposo de SCLK y en qué flanco cambia MISO: si MISO cambia en la bajada, se muestrea en la subida.
5. Subí la frecuencia de a poco hasta el valor de la hoja de datos, repitiendo la lectura de identificación.

Un truco para dejar la prueba del modo lista: en el código de arranque, leer y mostrar el identificador con un mensaje explícito («DEVID correcto» o «DEVID incorrecto: 0x..»). Es la mejor defensa contra un cable flojo que, tres meses después, vuelve el sensor sordo.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Predecí antes de comprobar

1. De la descripción al modo

Un dispositivo indica «reloj en reposo en nivel alto, dato capturado en el flanco de subida». ¿Qué CPOL, qué CPHA y qué modo SPI son?

2. Del diagrama al modo

En el diagrama de una hoja de datos, el reloj reposa en bajo y el dato cambia en el flanco de subida, capturándose en el de bajada. ¿Qué modo es?

3. Frecuencia máxima

Un esclavo tiene un retardo de salida de 30 ns; el maestro necesita 12 ns de establecimiento, y el cableado agrega 8 ns. ¿Cuál es la frecuencia máxima teórica?

4. Modo equivocado

El maestro envía 0xA5 en modo 0 y el esclavo está en modo 1. ¿Qué byte recibe el esclavo y qué relación tiene con el enviado?

5. Orden de bits

El maestro envía 0x2C en MSB primero, pero el esclavo arma el byte en LSB primero. ¿Qué recibe?

6. Dos dispositivos, un bus

Un acelerómetro de modo 3 a 2 MHz y una memoria de modo 0 a 8 MHz comparten SCLK, MOSI y MISO. ¿Qué tiene que hacer el programa para que convivan, y qué fallaría si no lo hace?

13 · Síntesis

Ideas para recordar

¿Listo para el siguiente tema?

Antes de avanzar, explicá qué modo corresponde a un dispositivo que reposa en alto y captura en la bajada, calculá la frecuencia máxima con t_co = 20 ns, t_su = 8 ns y t_p = 2 ns, y decí qué recibe un esclavo en modo 1 cuando el maestro en modo 0 envía 0x30. Si podés justificar las tres respuestas, tenés dominada la configuración de un enlace SPI.

En el próximo tema pasamos del enlace punto a punto al bus compartido: varios esclavos, selección de chip, cadena en margarita y dispositivos típicos como tarjetas SD, memorias flash y conversores.