Otras tecnologías inalámbricas

01 · Objetivo

Qué comparar

Antes de mirar cada tecnología conviene fijar con qué se las compara. Hay cinco ejes, y los tres primeros se contradicen entre sí:

• Alcance. Depende de la frecuencia (las bajas atraviesan mejor los obstáculos y se propagan más lejos), de la potencia de salida, de la sensibilidad del receptor y de la antena. La sensibilidad empeora al subir la velocidad: para recibir más bits por segundo hace falta más señal.
• Velocidad. Desde los 300 bit/s de LoRa a máximo alcance hasta los megabits de Wi-Fi. Importa la velocidad útil (con cabeceras, confirmaciones y esperas), no la que anuncia el fabricante.
• Consumo. Lo que cuenta es la energía por mensaje y el tiempo despierto, no solo la corriente de transmisión (tema 34). Un radio de 10 mA que está activo 10 ms gasta mucho menos que uno de 35 mA activo 185 ms.
• Topología. Punto a punto, estrella (todos hablan con una puerta de enlace) o malla (los nodos se retransmiten entre sí).
• Costo y ecosistema. Un módulo nRF24L01+ cuesta un par de dólares y exige armar todo el protocolo; un módulo Zigbee o LoRaWAN cuesta más, pero trae red, direccionamiento y seguridad hechos. También cuenta si hay teléfonos, puertas de enlace o servicios públicos que la entiendan.

02 · Radio barata

El módulo nRF24L01+

El nRF24L01+ de Nordic es un transceptor de 2,4 GHz, económico y muy extendido en proyectos de aficionados. Se conecta por SPI (SCK, MOSI, MISO, CSN), más un pin de habilitación (CE) y uno de interrupción (IRQ), y se alimenta con 1,9 a 3,6 V (las entradas toleran 5 V, pero la alimentación no). Admite 126 canales de 1 MHz (el canal n está en 2400 + n MHz), tres velocidades (250 kbit/s, 1 y 2 Mbit/s), potencia de −18 a 0 dBm y hasta 6 canales lógicos de recepción (pipes), con una dirección de 3 a 5 bytes cada uno: un receptor puede escuchar a seis emisores distintos.

Lo importante es que implementa en hardware el protocolo Enhanced ShockBurst: arma el paquete (preámbulo, dirección, 9 bits de control con la longitud, un número de secuencia de 2 bits y un indicador de «sin confirmación», los datos y un CRC), lo transmite, espera la confirmación y reintenta sin intervención del programa. Es lo que se vio en el tema 45 (ACK, tiempo de espera y reintentos) resuelto dentro del chip. El receptor valida el CRC y la dirección, y si todo coincide, responde con un paquete de confirmación vacío (o con datos, si se configuró la carga útil en la confirmación).

Cuánto tarda de verdad

Con 2 Mbit/s y 32 bytes de datos, el paquete mide 329 bits y ocupa 164,5 µs. Pero la velocidad útil no es 2 Mbit/s: tras transmitir hay que pasar a recepción (130 µs), recibir la confirmación (36,5 µs) y volver (130 µs). El ciclo completo es de 461 µs para 256 bits de datos: unos 555 kbit/s útiles, la cuarta parte de la cifra del aire. A 250 kbit/s, el mismo paquete dura 1316 µs y el ciclo, 1868 µs: 137 kbit/s. La herramienta 1 del laboratorio calcula todo esto, incluida la espera entre reintentos (ARD, de 250 a 4000 µs en pasos de 250): debe ser mayor que lo que tarda la confirmación, y por eso a 250 kbit/s el mínimo sube a 500 µs.

Lo que el nRF24L01+ no trae es una red: no hay descubrimiento, ni direccionamiento más allá de las direcciones de canal, ni cifrado, ni malla. Esa parte la pone el programa (temas 41 y 42). Con las bibliotecas RF24 (la principal) y RF24Network y RF24Mesh (que agregan árbol y malla) se llega mucho más lejos de lo que se esperaría de un chip de dos dólares. Es una excelente tecnología para muchos emisores simples y un solo receptor cerca, y mala para cualquier cosa que deba convivir con redes ajenas, porque comparte la banda con el Wi-Fi sin ninguna coordinación.

03 · Largo alcance

LoRa

LoRa (Long Range) es una modulación de la empresa Semtech que opera en las bandas libres de menos de 1 GHz: 433 MHz, 868 MHz en Europa y 915 MHz en América y Oceanía (el uso concreto depende del país). Las frecuencias bajas se propagan mejor y rodean mejor los obstáculos que las de 2,4 GHz, pero el secreto está en la modulación: espectro ensanchado por barrido (chirp spread spectrum). Cada símbolo es un barrido de frecuencia que recorre todo el ancho de banda, y el dato está en el punto donde empieza. El receptor correlaciona la señal con el barrido conocido, lo que le permite recibir señales por debajo del ruido: hasta 20 dB por debajo en el factor más alto.

Dos parámetros definen el compromiso entre velocidad y alcance:

• Factor de ensanchamiento (Spreading Factor, SF, de 7 a 12): cada símbolo lleva SF bits y dura 2^SF/B segundos. Subir un paso duplica el tiempo en el aire y gana unos 2,5 dB de sensibilidad.
• Ancho de banda (B: 125, 250 o 500 kHz): duplicarlo reduce el tiempo a la mitad, a cambio de unos 3 dB de sensibilidad y de más ruido admitido.
• Tasa de codificación (4/5 a 4/8): bits de corrección de errores añadidos, que se pagan con tiempo.

La sensibilidad se calcula como −174 dBm/Hz + 10·log₁₀(B) + figura de ruido (unos 6 dB) + relación señal a ruido mínima del factor (de −7,5 dB en SF7 a −20 dB en SF12). Con una potencia de 14 dBm y una sensibilidad de −137 dBm, el presupuesto de enlace es de 151 dB (el tema 34): suficiente para varios kilómetros en entornos urbanos y más de diez en campo abierto.

El ciclo de trabajo y el costo del tiempo en el aire

Las bandas libres de menos de 1 GHz tienen una regla que Wi-Fi no tiene: en Europa, en 868 MHz, la mayoría de los canales limita el ciclo de trabajo al 1 % (algunos, al 0,1 % o al 10 %): un transmisor solo puede estar en el aire el 1 % del tiempo, o sea 36 s por hora. Un mensaje de 20 bytes en SF12 dura 1,3 s: tras enviarlo hay que esperar 132 s. En América (915 MHz) la norma es distinta: no hay ciclo de trabajo, pero sí un tiempo máximo de permanencia en el canal y salto de frecuencias. En los dos casos, y aunque no existiera ninguna regla, el tiempo en el aire manda: se usa el SF más bajo con el que el enlace aún funciona, y los mensajes se mantienen cortos. Los 255 bytes de datos máximos de LoRa son casi siempre excesivos; un mensaje típico tiene entre 4 y 20 bytes con enteros y formato binario (tema 46).

LoRa y LoRaWAN

Hay que distinguir las dos cosas. LoRa es solo la capa física: dos módulos con un chip SX1276, SX1262 o equivalente pueden intercambiar paquetes sin más, y se programan con bibliotecas como RadioLib o LoRa. LoRaWAN es un protocolo de red por encima (de la LoRa Alliance): los dispositivos finales envían a cualquier puerta de enlace en alcance, que los reenvía por Internet a un servidor de red (por ejemplo, The Things Network), con direccionamiento, adaptación de velocidad, cifrado AES-128 de extremo a extremo y comprobación de contadores contra la repetición (tema 49). A cambio, los dispositivos de clase A (los de menor consumo) solo pueden recibir justo después de transmitir, de modo que la comunicación hacia el sensor es lenta y limitada. Para cientos de sensores con pila en un campo, una ciudad o una red de medidores, LoRaWAN es la herramienta; para dos placas propias a 3 km, LoRa a secas alcanza.

Se carga un módulo SX127x con 3,3 V (SPI más los pines de reinicio y de interrupción), una antena adecuada a la frecuencia (un cable de 1/4 de onda, 8,2 cm en 868 MHz) y nunca se transmite sin antena: la potencia reflejada puede dañar el amplificador. Se consume más de lo que la tabla anterior sugiere para la transmisión (unos 120 mA a 20 dBm, 30 a 40 mA a 14 dBm, 10 a 12 mA recibiendo) y casi nada dormido (de 0,2 a 1 µA).

04 · Redes de malla

Zigbee e IEEE 802.15.4

Zigbee es una red de malla de bajo consumo construida sobre el estándar IEEE 802.15.4, que define la radio y el acceso al medio de las redes personales de baja velocidad. En 2,4 GHz usa 16 canales de 2 MHz, numerados del 11 al 26 y separados de a 5 MHz (el canal n está en 2405 + 5·(n − 11) MHz), con modulación O-QPSK a 250 kbit/s y tramas de hasta 127 bytes. También existe en 868 y 915 MHz, con canales de 20 y 40 kbit/s. Como la radio es de corto alcance, de baja potencia y se usa poco tiempo, es ideal para sensores con pila.

Su rasgo distintivo es la malla. Una red Zigbee tiene tres tipos de nodo:

• Coordinador: uno por red. Forma la red, elige el canal y el identificador (PAN ID), y reparte las claves de seguridad.
• Enrutador: siempre encendido (alimentado por red eléctrica, como una lámpara o un enchufe), retransmite los mensajes de otros y extiende el alcance.
• Dispositivo final: un sensor o un interruptor que casi siempre duerme y se comunica a través de un padre (coordinador o enrutador). Es el que dura años con pilas.

Si un enrutador se apaga, los mensajes buscan otro camino: la red se repara sola. A cambio, la complejidad es alta: un módulo suele programarse con un SDK del fabricante (Silicon Labs, Texas Instruments, Espressif con sus ESP32-H2 y ESP32-C6), y la interoperabilidad se logra con perfiles estandarizados (Zigbee 3.0) para luces, interruptores, sensores y cerraduras. El camino más corto para un aficionado es un módulo XBee (de Digi), que oculta la malla detrás de una UART: en modo transparente funciona como un cable serie inalámbrico, y en modo API los datos van en tramas con el delimitador 0x7E, dos bytes de largo, el contenido y una suma de verificación (0xFF menos la suma de los bytes del contenido): el mismo diseño de protocolo del tema 41, con la dirección del destino dentro del contenido.

Dos advertencias. Primero, Zigbee comparte banda con el Wi-Fi y con una potencia diez a cien veces menor, de modo que un canal de Zigbee que se solape con una red Wi-Fi cercana pierde casi todo. La herramienta 3 muestra qué canales esquivan los de Wi-Fi 1, 6 y 11. Segundo, Thread (la red de malla de Matter) usa la misma radio 802.15.4, pero con otra pila de protocolos, basada en IPv6: cada nodo tiene una dirección IP. Zigbee y Thread comparten el chip, no el lenguaje.

05 · Sin router

ESP-NOW

ESP-NOW es un protocolo de Espressif para que los ESP32 y los ESP8266 se comuniquen entre sí sin punto de acceso, sin conexión y sin asociación. Usa la radio de Wi-Fi (la misma de 2,4 GHz) pero, en lugar de la pila completa de IP y TCP del tema 35, envía una trama de acción de 802.11 directamente a la dirección MAC del destino. Por eso es muy rápido: no hay que escanear, asociarse, pedir una dirección IP ni abrir un socket.

La consecuencia práctica más importante es la última: si el ESP32 está conectado a un router, ESP-NOW usa el canal del router, y si el router cambia de canal, el enlace con el otro extremo se rompe. Una forma robusta de usarlo es no conectarse a ningún router: emisor y receptor fijan el mismo canal (por ejemplo, el 1 o el 6) y eso es todo. Otra es que el receptor esté conectado al Wi-Fi y reenvíe lo que recibe a Internet, y que los emisores se adapten a su canal.

Como no hay conexión, el emisor no sabe si alguien escucha más que por la confirmación de la capa MAC, y la fiabilidad la definen los temas 44 y 45: un número de secuencia para detectar pérdidas, un CRC (ya lo trae la capa MAC, pero sirve para la lógica propia) y reintentos si hacen falta. En el consumo, el truco es que un ESP32 despierta, envía y vuelve a dormir en pocas decenas de milisegundos si el canal es fijo, mucho menos que los 0,5 a 3 s de reconectar al Wi-Fi (tema 36). Aun así, un ESP32 despierto gasta mucho más que un microcontrolador pequeño con un nRF24L01+ o un SoC de BLE: la herramienta 6 lo cuantifica con supuestos prudentes de 0,2 s activo.

ESP-NOW encaja cuando todas las placas son de Espressif, la distancia no supera unas decenas o cientos de metros y se quiere latencia mínima: un control remoto entre dos placas, una red de sensores que reporta a un nodo central, un timbre inalámbrico. No sirve para hablar con un teléfono (sin soporte) ni con placas de otras marcas.

06 · Sin pila

RFID y NFC

En RFID (identificación por radiofrecuencia) un lector genera un campo electromagnético y una etiqueta o tarjeta, que no tiene pila, toma energía de ese campo por acoplamiento inductivo para responder. Como la energía llega por el campo, el alcance es muy corto y cae rápidamente con la distancia (con una antena de bobina, la intensidad del campo disminuye con la inversa del cubo de la distancia). Por eso las etiquetas son baratas y no se gastan. Hay tres familias:

NFC (Near Field Communication) es un subconjunto de la familia de 13,56 MHz, a menos de 10 cm, con un formato de datos común (NDEF: mensajes con registros de tipo, como un enlace o un texto) y tres modos: lector y escritor (el teléfono lee una etiqueta), emulación de tarjeta (el teléfono se comporta como una tarjeta de pago o de acceso) y punto a punto (entre dos teléfonos). Es la forma de «tocar para configurar»: una etiqueta NTAG213 de 50 centavos con una URL abre una página en cualquier teléfono, y un módulo PN532 permite que un microcontrolador lea y escriba.

El lector de 125 kHz

El módulo RDM6300 lee tarjetas EM4100 y entrega el resultado por una UART a 9600 baudios, en cuanto detecta una tarjeta y mientras esté presente. Cada lectura es una trama de 14 bytes: 0x02 (inicio), 10 caracteres ASCII hexadecimales (5 bytes: la versión o código de cliente y el ID de 32 bits de la tarjeta), 2 caracteres ASCII con la suma de verificación (el XOR de los 5 bytes) y 0x03 (fin). Un receptor serie sigue el patrón del tema 41: espera el inicio, acumula caracteres, al llegar el fin valida el largo y la suma y recién entonces usa el ID. Una trama cortada o con ruido da un ID falso, y la herramienta 4 permite verlo cambiando un solo carácter.

Qué seguridad ofrecen

Aquí hay que ser claro: una tarjeta de 125 kHz solo dice un número, y ese número se puede copiar. Hay clonadores por unos pocos dólares que leen la tarjeta y la repiten, y los lectores no tienen forma de distinguirlos. Usar el ID como contraseña es una barrera de comodidad, no de seguridad. Las tarjetas de 13,56 MHz modernas (MIFARE DESFire, NTAG con contraseña, tarjetas con criptografía asimétrica) sí autentican, con un desafío con respuesta (tema 49) que no se puede repetir. La clásica MIFARE Classic (la del módulo MFRC522 de los kits) usa un cifrado propio, Crypto1, roto desde 2008: sirve para identificar, pero no para proteger nada de valor. Para dar acceso a algo importante, el ID no alcanza: se combina con un segundo factor (clave, teclado, validación en un servidor) o se elige una tarjeta con autenticación real.

07 · Luz invisible

Infrarrojo

El control remoto de un televisor usa un LED infrarrojo de 940 nm, invisible, y un receptor integrado (como el TSOP38238 o el VS1838B) en el aparato. Para distinguir la señal de la luz ambiente, que es mucho más intensa, el emisor no enciende el LED de forma continua sino que lo modula con una portadora de 38 kHz: cada «1 lógico» es una ráfaga de pulsos de 38 kHz, y el receptor tiene un filtro sintonizado a esa frecuencia, un demodulador y entrega una salida digital limpia, invertida (en nivel bajo mientras hay ráfaga). Es la misma idea de modulación del tema 34 en la forma más simple.

Hay muchos protocolos (NEC, Sony SIRC, RC5 de Philips, Samsung). El más difundido es NEC: la trama empieza con una ráfaga de 9 ms y una pausa de 4,5 ms; sigue una dirección de 8 bits, su complemento, una orden de 8 bits y su complemento (el bit menos significativo primero); y termina con una ráfaga corta. Un «0» es una ráfaga de 562,5 µs y una pausa de 562,5 µs; un «1», una ráfaga de 562,5 µs y una pausa tres veces mayor. Con el complemento de cada byte, cada trama tiene siempre 16 unos y 16 ceros y dura 68,06 ms: el complemento sirve para detectar errores y para que la duración sea constante. Mientras se mantiene el botón apretado se envía cada 108 ms un código de repetición corto (9 ms, 2,25 ms y una ráfaga final: 11,81 ms), en lugar de la trama completa. La herramienta 5 arma y mide una trama.

En la práctica, con una placa y la biblioteca IRremote se puede recibir con tres líneas (IrReceiver.begin(PIN), IrReceiver.decode() y la lectura de IrReceiver.decodedIRData.address y .command, seguida de IrReceiver.resume()) y transmitir con IrSender.sendNEC(direccion, orden, repeticiones). Es una buena forma de capturar las órdenes de un control existente y repetirlas desde un microcontrolador, para manejar un televisor o un aire acondicionado. Las limitaciones son las de la luz: visión directa (no atraviesa paredes), alcance de 5 a 10 m, interferencias de lámparas fluorescentes y del sol, y velocidad de unos 2 kbit/s. No es una tecnología de datos: es una de órdenes, y para eso es insuperable en costo.

08 · Decidir

Elegir la tecnología

Elegir bien es contestar unas pocas preguntas en orden. Las dos primeras eliminan casi todas las opciones:

1. ¿A qué distancia? A menos de 10 cm: RFID o NFC. De 5 a 10 m con visión directa y órdenes sueltas: infrarrojo. Hasta unas decenas de metros: BLE, nRF24L01+, ESP-NOW o Zigbee. A cientos de metros: ESP-NOW, nRF24L01+ con antena. A kilómetros: LoRa.
2. ¿Quién escucha? Si es un teléfono: BLE (tema 38) o NFC; el resto no existe en él (salvo Wi-Fi). Si es Internet directamente: Wi-Fi (tema 35). Si es otra placa del mismo diseño: cualquiera.
3. ¿Cuánta energía? Con red eléctrica, cualquiera. Con pila y años de vida, hay que pasar los números por la herramienta 6: el tiempo activo por mensaje y la frecuencia mandan.
4. ¿Cuántos nodos, y quién los reúne? Un par: lo más simple. Decenas con una puerta de enlace: LoRaWAN, Zigbee. Una casa con enchufes que retransmiten: Zigbee o Thread.
5. ¿Cuánto cuesta construir la red? El módulo barato (nRF24L01+) exige armar direccionamiento, reintentos y seguridad con lo visto en los temas 41 a 49; un módulo de red (Zigbee, LoRaWAN) lo trae, pero con su propia complejidad.

Conviene no perder de vista que el alcance anunciado en los catálogos es el de condiciones ideales: antena externa, visión directa, sin interferencias. En interiores, con paredes y con otras redes, se reduce a una fracción. La única forma segura de saber es medir: el RSSI (la potencia recibida) o la tasa de paquetes perdidos (tema 43) a la distancia real, con la antena real.

09 · Con el microcontrolador

ESP-NOW, nRF24L01+ y un lector RFID

Tres programas cortos, cada uno de una tecnología distinta, con el mismo criterio de diseño: un mensaje de formato fijo con versión y número de secuencia (para detectar pérdidas y cambios de versión), tamaños y orden de bytes explícitos, y validación de todo lo que llega por el aire.

ESP-NOW: un emisor de difusión

El emisor envía cada 5 segundos una lectura a todos los receptores en alcance (dirección de difusión), sin registrarse en ningún par. Se carga en cualquier ESP32 (con el núcleo 3.x; en versiones anteriores cambian las firmas de las funciones de retorno).

#include <WiFi.h>
#include <esp_now.h>

// Formato del mensaje: igual en el emisor y el receptor; tamaños fijos y sin relleno
struct __attribute__((packed)) Mensaje {
    uint8_t  version;                                          // para poder cambiar el formato en el futuro
    uint8_t  nodo;                                             // quién envía
    uint16_t secuencia;                                        // cuenta los envíos: el receptor detecta las pérdidas
    int16_t  temperatura;                                      // centésimas de grado
    uint16_t bateria_mv;
};

const uint8_t TODOS[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };   // difusión
const uint8_t NODO = 1;
uint16_t secuencia = 0;

void setup() {
    Serial.begin(115200);
    WiFi.mode(WIFI_STA);                                       // ESP-NOW usa la radio de Wi-Fi, sin conectarse a nada
    if (esp_now_init() != ESP_OK) {
        Serial.println("No se pudo iniciar ESP-NOW");
        return;
    }
    esp_now_peer_info_t par = {};
    memcpy(par.peer_addr, TODOS, 6);
    par.channel = 0;                                           // 0 = el canal actual (todos deben coincidir)
    par.encrypt = false;                                       // la difusión no admite cifrado
    esp_now_add_peer(&par);
}

void loop() {
    Mensaje m = { 1, NODO, secuencia++, (int16_t)lroundf(temperatureRead() * 100), 3300 };
    esp_err_t r = esp_now_send(TODOS, (const uint8_t *)&m, sizeof(m));
    Serial.printf("Mensaje %u: %s\n", m.secuencia, r == ESP_OK ? "enviado a la radio" : "error");
    delay(5000);                                               // en una batería: dormir en lugar de esperar
}

El receptor registra una función que se llama con cada mensaje. Lo que llega puede ser de cualquiera: se comprueba el largo y la versión antes de usarlo.

#include <WiFi.h>
#include <esp_now.h>

struct __attribute__((packed)) Mensaje {                       // idéntica a la del emisor
    uint8_t  version;
    uint8_t  nodo;
    uint16_t secuencia;
    int16_t  temperatura;
    uint16_t bateria_mv;
};

void alRecibir(const esp_now_recv_info_t *info, const uint8_t *datos, int largo) {
    if (largo != sizeof(Mensaje)) return;                      // lo que llega por el aire no es confiable
    Mensaje m;
    memcpy(&m, datos, sizeof(m));
    if (m.version != 1) return;
    Serial.printf("nodo %u, n.º %u, %.2f °C, %u mV, %d dBm\n", m.nodo, m.secuencia, m.temperatura / 100.0, m.bateria_mv, info->rx_ctrl->rssi);
}

void setup() {
    Serial.begin(115200);
    WiFi.mode(WIFI_STA);
    Serial.println(WiFi.macAddress());                         // la MAC sirve para enviar solo a este receptor
    if (esp_now_init() != ESP_OK) {
        Serial.println("No se pudo iniciar ESP-NOW");
        return;
    }
    esp_now_register_recv_cb(alRecibir);
}

void loop() {}

• Para enviar solo a un receptor se reemplaza la dirección de difusión por la MAC que imprime el receptor, y con par.encrypt = true y una clave (par.lmk, 16 bytes, y esp_now_set_pmk en los dos extremos) el mensaje va cifrado.
• esp_now_send devuelve ESP_OK cuando el mensaje se entregó a la radio, no cuando llegó. Para saber si el par lo recibió se registra una función de envío con esp_now_register_send_cb (su firma cambió entre versiones del núcleo).
• El número de secuencia permite que el receptor detecte saltos (mensajes perdidos) y repeticiones (tema 45) comparándolo con el anterior de cada nodo.
• El orden de los bytes es el del ESP32 (little-endian) en los dos extremos. Para hablar con una placa de otra arquitectura hay que fijarlo explícitamente (tema 46).

nRF24L01+: un par con RF24

Con la biblioteca RF24 (disponible en el gestor de bibliotecas de Arduino), el emisor es:

#include <SPI.h>
#include <RF24.h>

RF24 radio(9, 10);                                             // pines CE y CSN
const byte DIRECCION[6] = "NODO1";                             // 5 bytes más el terminador
struct __attribute__((packed)) Lectura { uint8_t nodo; uint16_t secuencia; int16_t temperatura; };
uint16_t secuencia = 0;

void setup() {
    Serial.begin(115200);
    if (!radio.begin()) {
        Serial.println("El nRF24L01+ no responde: revisar cableado y alimentación");
        while (true) {}
    }
    radio.setPALevel(RF24_PA_LOW);
    radio.setDataRate(RF24_250KBPS);                           // la velocidad más baja: el mayor alcance
    radio.setChannel(76);                                      // 2476 MHz: por encima de los canales 1, 6 y 11 de Wi-Fi
    radio.setRetries(5, 15);                                   // espera de (5 + 1) × 250 = 1500 µs entre reintentos, hasta 15
    radio.openWritingPipe(DIRECCION);
    radio.stopListening();
}

void loop() {
    Lectura l = { 1, secuencia++, 2350 };
    bool ok = radio.write(&l, sizeof(l));                      // true solo si llegó la confirmación del receptor
    Serial.println(ok ? "confirmado" : "sin confirmación tras los reintentos");
    delay(5000);
}

El receptor usa los mismos parámetros, abre el canal de lectura y lee cuando hay algo disponible:

#include <SPI.h>
#include <RF24.h>

RF24 radio(9, 10);
const byte DIRECCION[6] = "NODO1";
struct __attribute__((packed)) Lectura { uint8_t nodo; uint16_t secuencia; int16_t temperatura; };

void setup() {
    Serial.begin(115200);
    if (!radio.begin()) { Serial.println("El nRF24L01+ no responde"); while (true) {} }
    radio.setPALevel(RF24_PA_LOW);
    radio.setDataRate(RF24_250KBPS);                           // los dos extremos deben coincidir en canal, velocidad y dirección
    radio.setChannel(76);
    radio.openReadingPipe(1, DIRECCION);
    radio.startListening();
}

void loop() {
    if (radio.available()) {
        Lectura l;
        radio.read(&l, sizeof(l));
        Serial.print("nodo ");       Serial.print(l.nodo);
        Serial.print(", n.º ");      Serial.print(l.secuencia);
        Serial.print(", ");          Serial.print(l.temperatura / 100.0);
        Serial.println(" °C");
    }
}

• El canal, la velocidad y la dirección deben coincidir en los dos extremos: es el motivo de casi todos los «no recibe nada».
• radio.write() bloquea hasta que llega la confirmación o se agotan los reintentos, y su valor de retorno es la confirmación del receptor, no del chip.
• radio.begin() devuelve false si el chip no responde por SPI: casi siempre es el cableado o la fuente (el condensador de la sección 2).
• Los dos extremos comparten el formato Lectura: el emisor y el receptor son programas distintos que dependen del mismo contrato, que conviene tener en un solo archivo de cabecera.

RDM6300: leer una tarjeta de 125 kHz

El módulo se alimenta con 5 V y transmite a 9600 baudios. Se conecta a una UART del ESP32 (aquí, la Serial2, con el pin 16 como RX); si el TX del módulo entrega 5 V, se usa el divisor del tema 37. La función implementa el mismo patrón de recepción por estados del tema 41: espera el inicio, acumula, valida al llegar el fin.

const uint32_t AUTORIZADOS[] = { 9185884UL, 1193046UL };       // IDs de las tarjetas permitidas

int nibble(char c) {
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    return -1;
}

bool leerTarjeta(uint32_t &id) {                               // trama: 0x02, 10 caracteres de datos, 2 de suma y 0x03
    static char buf[12];
    static uint8_t n = 0;
    static bool dentro = false;
    while (Serial2.available()) {
        char c = Serial2.read();
        if (c == 0x02) { dentro = true; n = 0; continue; }     // el inicio descarta lo que hubiera
        if (!dentro) continue;
        if (c != 0x03) {
            if (n < sizeof(buf)) buf[n++] = c; else dentro = false;   // demasiado largo: descartar
            continue;
        }
        dentro = false;                                        // llegó el fin: validar
        if (n != 12) continue;
        uint8_t b[6];
        bool ok = true;
        for (int i = 0; i < 6; i++) {
            int alto = nibble(buf[2 * i]), bajo = nibble(buf[2 * i + 1]);
            if (alto < 0 || bajo < 0) { ok = false; break; }
            b[i] = (alto << 4) | bajo;
        }
        if (!ok || (b[0] ^ b[1] ^ b[2] ^ b[3] ^ b[4]) != b[5]) continue;   // la suma de verificación no coincide
        id = ((uint32_t)b[1] << 24) | ((uint32_t)b[2] << 16) | ((uint32_t)b[3] << 8) | b[4];
        return true;
    }
    return false;
}

void setup() {
    Serial.begin(115200);
    Serial2.begin(9600, SERIAL_8N1, 16, -1);                   // solo se recibe
}

void loop() {
    static uint32_t ultimoId = 0;
    static unsigned long ultimaLectura = 0;
    uint32_t id;
    if (leerTarjeta(id)) {
        bool nueva = id != ultimoId || millis() - ultimaLectura > 1000;   // el módulo repite la trama mientras la tarjeta está cerca
        ultimoId = id;
        ultimaLectura = millis();
        if (nueva) {
            bool permitida = false;
            for (uint32_t a : AUTORIZADOS) if (a == id) permitida = true;
            Serial.printf("Tarjeta %lu: %s\n", (unsigned long)id, permitida ? "permitida" : "no registrada");
        }
    }
}

Qué hay que notar: la validación completa (largo, caracteres hexadecimales y suma) antes de usar el ID; el descarte de la trama si llega un nuevo inicio a medias; la supresión de repeticiones (el módulo reenvía la trama una y otra vez mientras la tarjeta está presente, y no es una lectura nueva cada vez); y que la lista de IDs permitidos es solo una comodidad: como se explicó en la sección 6, un ID de 125 kHz se copia con facilidad.

10 · Analogía con programación

Las cuentas de cada tecnología en Python

Casi todo lo que se calcula en este tema se prueba sin hardware: el tamaño y el tiempo del paquete del nRF24L01+, el tiempo en el aire y la velocidad de LoRa, la frecuencia de un canal de Zigbee y su choque con el Wi-Fi, la validación de una trama RDM6300, la trama y la duración de NEC y la corriente media de un sensor. El modelo siguiente reproduce las reglas de los programas y de la página.

import math


def paquete_nrf(kbps, datos, direccion, crc):
    bits = 8 + 8 * direccion + 9 + 8 * datos + 8 * crc       # preámbulo, dirección, control de paquete, datos, CRC
    ack = 8 + 8 * direccion + 9 + 8 * crc                    # la confirmación va sin datos
    t_paq = bits * 1000 / kbps                               # µs
    t_ack = ack * 1000 / kbps
    ciclo = 130 + t_paq + 130 + t_ack                        # 130 µs por cada cambio entre transmisión y recepción
    return bits, t_paq, t_ack, ciclo, datos * 8 / ciclo * 1e6


def tiempo_aire_lora(sf, bw_khz, cr, carga):                 # cr = 5 a 8 (4/5 a 4/8); encabezado explícito y CRC
    tsym = 2 ** sf / (bw_khz * 1000)
    de = 1 if tsym > 0.016 else 0                            # optimización de baja velocidad
    n = 8 + max(math.ceil((8 * carga - 4 * sf + 28 + 16) / (4 * (sf - 2 * de))) * cr, 0)
    return tsym, (8 + 4.25) * tsym + n * tsym


def velocidad_lora(sf, bw_khz, cr):
    return sf * (bw_khz * 1000 / 2 ** sf) * 4 / cr


def frecuencia_zigbee(canal):
    return 2405 + 5 * (canal - 11)


def choca_con_wifi(canal_zigbee):
    f = frecuencia_zigbee(canal_zigbee)
    return [w for w in (1, 6, 11) if abs(f - (2407 + 5 * w)) < 12]


def validar_rdm6300(texto):
    datos = bytes.fromhex(texto)
    xor = 0
    for b in datos[:5]:
        xor ^= b
    return int.from_bytes(datos[1:5], "big"), xor, xor == datos[5]


def trama_nec(direccion, orden):
    return bytes([direccion, direccion ^ 0xFF, orden, orden ^ 0xFF])


def duracion_nec_ms(trama):
    unos = sum(bin(b).count("1") for b in trama)
    return 9 + 4.5 + (32 - unos) * 1.125 + unos * 2.25 + 0.5625


def corriente_media_ma(activo_s, i_activa_ma, sueno_ua, periodo_s):
    return (i_activa_ma * activo_s + sueno_ua / 1000 * (periodo_s - activo_s)) / periodo_s


for kbps in (2000, 1000, 250):
    bits, tp, ta, ciclo, thr = paquete_nrf(kbps, 32, 5, 2)
    print(f"nRF24 a {kbps:>4} kbit/s: {bits} bits, {tp:.1f} µs, ACK {ta:.1f} µs, ciclo {ciclo:.0f} µs, {thr / 1000:.0f} kbit/s útiles")

for sf in (7, 9, 12):
    tsym, toa = tiempo_aire_lora(sf, 125, 5, 20)
    print(f"LoRa SF{sf}, 125 kHz, 20 bytes: símbolo {tsym * 1000:.3f} ms, {toa * 1000:.1f} ms, {velocidad_lora(sf, 125, 5):.0f} bit/s, mínimo entre mensajes con 1 %: {toa * 100:.1f} s")

for canal in (11, 15, 20, 26):
    print(f"Zigbee canal {canal}: {frecuencia_zigbee(canal)} MHz, choca con Wi-Fi {choca_con_wifi(canal) or 'ninguno'}")

print("RDM6300:", validar_rdm6300("0A008C2A5CF0"), validar_rdm6300("0A008C2A5CF1"))
t = trama_nec(0x00, 0xFF)
print("NEC 00/FF:", t.hex(" ").upper(), f"{duracion_nec_ms(t):.2f} ms")
t = trama_nec(0x20, 0x0C)
print("NEC 20/0C:", t.hex(" ").upper(), f"{duracion_nec_ms(t):.2f} ms")

for nombre, activo, i, sueno in (("ESP-NOW", 0.2, 100, 20), ("nRF24", 0.01, 15, 5), ("LoRa", 0.185, 35, 5), ("BLE", 0.003, 8, 3), ("Wi-Fi", 0.94, 120, 20)):
    ma = corriente_media_ma(activo, i, sueno, 600)
    print(f"{nombre:8} cada 10 min: {ma:.4f} mA, {2000 / ma / 24:.0f} días con 2000 mAh")

Resultado: el nRF24L01+ con 32 bytes, dirección de 5 y CRC de 2 arma un paquete de 329 bits; a 2000 kbit/s ocupa 164,5 µs, la confirmación 36,5 µs, el ciclo 461 µs y se obtienen 555 kbit/s útiles; a 1000 kbit/s, 329 µs, 73 µs, 662 µs y 387 kbit/s; a 250 kbit/s, 1316 µs, 292 µs, 1868 µs y 137 kbit/s. LoRa con 125 kHz, 4/5 y 20 bytes: SF7 dura 1,024 ms por símbolo y 56,6 ms en el aire, con 5469 bit/s y 5,7 s de espera mínima con el 1 %; SF9, 4,096 ms, 185,3 ms, 1758 bit/s y 18,5 s; SF12, 32,768 ms, 1318,9 ms, 293 bit/s y 131,9 s. En Zigbee, el canal 11 está en 2405 MHz y se pisa con el Wi-Fi 1, mientras que los canales 15, 20 y 26 (2425, 2450 y 2480 MHz) no chocan con ninguno de los tres. La trama RDM6300 0A008C2A5CF0 da el ID 9185884, suma 240 (0xF0) y es válida; con F1 final, la suma coincide en el cálculo pero no con la recibida (False). Las tramas NEC son 00 FF FF 00 y 20 DF 0C F3, y las dos duran 68,06 ms. Cada 10 minutos y con 2000 mAh: ESP-NOW usa 0,0533 mA y dura 1563 días (4,3 años); el nRF24L01+, 0,0052 mA y 15 873 días; LoRa, 0,0158 mA y 5278 días; BLE, 0,0030 mA y 27 412 días; y el Wi-Fi con conexión rápida, 0,2080 mA y 401 días. Esas duraciones ignoran la autodescarga de la batería.

Una lección de esta cuenta: la tecnología importa menos que el tiempo activo por mensaje. Un nRF24L01+ y un ESP-NOW tienen potencia de radio parecida, pero uno vive en un microcontrolador pequeño que despierta 10 ms y el otro en un ESP32 que tarda 200 ms: la diferencia es de diez veces en la energía de cada envío.

11 · Exploración interactiva

Laboratorio: paquete, tiempo en el aire, canales, tarjetas, infrarrojo y batería

El laboratorio tiene seis herramientas. La primera calcula el paquete del nRF24L01+ y su velocidad útil. La segunda, el tiempo en el aire de LoRa y lo que permite el ciclo de trabajo. La tercera ubica un canal de Zigbee frente al Wi-Fi. La cuarta valida una trama del lector RFID RDM6300. La quinta arma una trama infrarroja NEC. La sexta compara la duración de la batería de las tecnologías del tema.

Para la herramienta 6, cada tecnología se modela con estos supuestos por cada envío (valores prudentes de un diseño típico; los reales varían bastante con el chip y la placa):

En la herramienta 1, el paquete cuenta preámbulo, dirección, 9 bits de control, datos y CRC, y el ciclo incluye 130 µs en cada cambio entre transmisión y recepción. En la 2, la fórmula supone encabezado explícito, CRC y 8 símbolos de preámbulo. En la 3, el solapamiento se evalúa con la separación de 12 MHz entre centros (la mitad del ancho de un canal de Wi-Fi más la de uno de Zigbee). En la 4, la suma es el XOR de los cinco bytes de datos. En la 5, las ráfagas y las pausas siguen los tiempos de NEC. La 6 ignora la autodescarga.

Recorrido guiado

1. En la herramienta 1, con los valores iniciales (2000 kbit/s, 32 bytes, dirección de 5 y CRC de 2): 329 bits, 165 µs, 36,5 µs de confirmación, ciclo de 461 µs (2169 paquetes por segundo) y 555,3 kbit/s útiles. Con 250: 1316 µs, ciclo de 1868 µs, 137 kbit/s y espera de reintento de 500 µs. Con 1000 kbit/s, 8 bytes, dirección de 3 y CRC de 1: 113 bits y 151,7 kbit/s; con 0 bytes de datos, el ciclo de 358 µs es solo costo. Con 500: no es una velocidad válida.
2. En la herramienta 2, con los valores iniciales (SF9, 125 kHz, 4/5, 20 bytes, 1 %): 4,096 ms por símbolo, 185,3 ms en el aire, 1,8 kbit/s, −129,5 dBm, 194 mensajes por hora y uno cada 19 s. Con SF7: 56,6 ms, −124,5 dBm y 636 mensajes por hora. Con SF12 y 51 bytes: 2,47 s, −137 dBm, solo 14 mensajes por hora (uno cada 247 s, marcado en rojo). Con SF7, 500 kHz, 10 bytes y 10 %: 10,3 ms, 21,9 kbit/s y −118,5 dBm: más velocidad y menos alcance.
3. En la herramienta 3, con el canal 15 y 127 bytes: 2425 MHz, 4256 µs en el aire (133 bytes a 250 kbit/s), 235 tramas por segundo y ninguno de los Wi-Fi 1, 6 y 11 pisado. Con el 11: 2405 MHz, se pisa con el Wi-Fi 1 (en rojo). Con el 25: 2475 MHz, sin choque con 1, 6 y 11 (solo con los canales 12 y 13, que en América no se usan). Con el 18 y 20 bytes: 2440 MHz, 832 µs, 1202 tramas por segundo y choque con el Wi-Fi 6.
4. En la herramienta 4, con 0A008C2A5CF0: versión 0x0A, ID 00 8C 2A 5C, 9 185 884, suma calculada 0xF0 y recibida 0xF0: trama válida. Cambiá el último carácter a 1: la suma recibida es 0xF1, la trama se descarta. Con 0A008C (cortada): no hay resultados.
5. En la herramienta 5, con dirección 00 y orden FF: 00 FF FF 00, 16 unos y 16 ceros y 68,06 ms. Con 20 y 0C: 20 DF 0C F3, con los bits 00000100 11111011 00110000 11001111 (el menos significativo primero), y otra vez 16 unos, 16 ceros y 68,06 ms: la duración no depende de la orden.
6. En la herramienta 6, con los valores iniciales (2000 mAh, un envío cada 10 minutos): BLE usa 0,0030 mA y es la más eficiente, el nRF24L01+ 0,0052 mA, LoRa 0,0158 mA, Zigbee 0,0042 mA, ESP-NOW 0,0533 mA (4,3 años) y Wi-Fi 0,208 mA (401 días). Con un envío por minuto (60): ESP-NOW cae a 236 días y el Wi-Fi a 44 días (en rojo). Con 3600 s y 220 mAh (una pila de botón): BLE, 8,4 años; Zigbee, 7,8; LoRa, 3,7; nRF24L01+, 5,0; ESP-NOW, 359 días. Con un envío cada 5 s (y los 220 mAh): solo BLE (3,2 años) y el nRF24L01+ (262 días) superan los 90 días.

12 · Comprensión

Confusiones frecuentes

13 · Práctica guiada

Predecí antes de comprobar

1. Paquete del nRF24L01+

Un nRF24L01+ a 1 Mbit/s envía 10 bytes con dirección de 5 bytes y CRC de 2. ¿Cuántos bits tiene el paquete, cuánto tarda el ciclo con su confirmación y cuál es la velocidad útil?

2. Tiempo en el aire de LoRa

Un mensaje de 10 bytes con SF7, 125 kHz y codificación 4/5. ¿Cuánto dura el símbolo, cuánto el mensaje y cuántos mensajes por hora permite el 1 %?

3. Canal de Zigbee

¿En qué frecuencia está el canal 17 de Zigbee? ¿Se pisa con algún canal de Wi-Fi de 1, 6 y 11? Nombrá dos canales de Zigbee que no se pisen con ninguno.

4. Trama del RDM6300

El lector entrega los cinco bytes 0A 00 12 34 56. ¿Qué dos caracteres de suma de verificación lleva la trama, y qué ID decimal da?

5. Trama NEC

Una trama NEC envía la dirección 04 y la orden 08. ¿Qué cuatro bytes se transmiten, cómo salen los bits del primero y cuánto dura la trama?

6. La batería de un sensor ESP-NOW

Un sensor con ESP32 y ESP-NOW despierta 0,2 s a 100 mA cada 10 minutos y duerme con 20 µA, con una batería de 2000 mAh. ¿Cuál es la corriente media y la duración? ¿Qué pesa más, el envío o el sueño?

7. Elegir la tecnología

Elegí una tecnología y justificala con alcance, energía y quién escucha: (a) sensores de temperatura en invernaderos distribuidos en 3 km, con pilas, un mensaje cada 15 minutos; (b) un timbre inalámbrico entre dos placas ESP32 de una casa; (c) abrir una puerta con una tarjeta; (d) encender un televisor desde un microcontrolador.

14 · Síntesis

Ideas para recordar

¿Listo para el siguiente tema?

Antes de avanzar, calculá cuánto tarda un mensaje de 20 bytes con SF9 en LoRa y cuántos mensajes por hora permite el 1 %; explicá por qué el nRF24L01+ a 2 Mbit/s no entrega 2 Mbit/s útiles; y elegí entre ESP-NOW, LoRa y BLE para un sensor de pila que reporta a 800 m de una casa, justificando con alcance, energía y quién lo recibe. Si podés justificar las tres respuestas, entendés el mapa de las tecnologías inalámbricas.

En el próximo tema se reúne todo lo de esta parte del curso en un taller: un sensor inalámbrico de bajo consumo. Se mide, se envía por BLE o por LoRa, se usa el sueño profundo para dormir casi siempre y se calcula la duración real de la batería: la cuenta de la herramienta 6 de este tema, ahora con un circuito y un multímetro.