Domine el nRF24L01: Comunicación inalámbrica, integración con Arduino, circuitos y guía de código

En este tutorial aprenderemos cómo hacer comunicación inalámbrica entre dos placas Arduino usando los módulos transceptores nRF24L01. El módulo nRF24L01 es una opción muy popular para comunicación inalámbrica cuando se usa Arduino.

Ya he usado este módulo para numerosos proyectos de Arduino y puede ver algunos de ellos aquí:

• Transmisor RC Arduino DIY
• Avión RC Arduino | 100% DIY
• Hovercraft RC basado en Arduino DIY
• Proyecto Estación Meteorológica Inalámbrica Arduino

Puede ver el siguiente video o leer el tutorial escrito a continuación. Incluye todo lo que necesitamos saber sobre el módulo transceptor nRF24L01, como el pinout del módulo, principio de funcionamiento, cableado y varios ejemplos de código.

Resumen

Para explicar la comunicación inalámbrica haremos dos ejemplos: el primero será enviar un simple mensaje «Hola Mundo» de un Arduino a otro, y en el segundo ejemplo tendremos comunicación bidireccional entre las placas Arduino, donde usando el Joystick en el primer Arduino controlaremos el motor servo en el segundo Arduino, y viceversa, usando el pulsador en el segundo Arduino controlaremos el LED en el primero.

Módulo Transceptor nRF24L01

Veamos más de cerca el módulo transceptor NRF24L01. Usa la banda de 2.4 GHz y puede operar con tasas de baudios desde 250 kbps hasta 2 Mbps. Si se usa en espacio abierto y con tasa de baudios más baja, su alcance puede llegar hasta 100 metros.

Aquí están las especificaciones completas:

Rango de frecuencia	2.4 – 2.5GHz banda ISM
Tasas de datos	250Kbps / 1Mbps / 2Mbps
Potencia de salida máx.	0dBm
Voltaje de operación	1.9 – 3.6V
Corriente de operación máx.	12.3mA
Corriente en espera	22µA
Entradas lógicas	Tolerante a 5V
Alcance de comunicación	100m (espacio abierto)

Cómo Funciona

El módulo puede usar 125 canales diferentes, lo que da la posibilidad de tener una red de 125 módems funcionando independientemente en un lugar. Cada canal puede tener hasta 6 direcciones, o cada unidad puede comunicarse con hasta 6 otras unidades al mismo tiempo.

El consumo de energía de este módulo es de solo alrededor de 12mA durante la transmisión, lo cual es incluso menor que un solo LED. El voltaje de operación del módulo es de 1.9 a 3.6V, pero lo bueno es que los otros pines toleran lógica de 5V, así que podemos conectarlo fácilmente a un Arduino sin usar convertidores de nivel lógico.

Tres de estos pines son para la comunicación SPI y necesitan conectarse a los pines SPI del Arduino, pero tenga en cuenta que cada placa Arduino tiene diferentes pines SPI. Los pines CSN y CE pueden conectarse a cualquier pin digital de la placa Arduino y se usan para poner el módulo en modo espera o activo, así como para cambiar entre modo transmisión o comando. El último pin es un pin de interrupción que no tiene que usarse.

Variaciones del módulo

Hay varias variaciones de los módulos NRF24L01. La más popular es la que tiene antena integrada. Esto hace que el módulo sea más compacto, pero por otro lado, reduce el alcance de transmisión a una distancia de unos 100 metros.

La segunda variación, en lugar de antena integrada, tiene un conector SMA al que podemos conectar una antena duck para mejor alcance de transmisión.

La tercera variación mostrada aquí, además de la antena duck, tiene un chip RFX2401C que incluye PA (Amplificador de Potencia) y LNA (Amplificador de Bajo Ruido). Esto amplifica la señal del NRF24L01 y permite un alcance de transmisión aún mejor de hasta 1000 metros en espacio abierto.

Pinout del módulo nRF24L01

Aquí tiene una vista detallada del pinout del NRF24L01, así como del módulo NRF24L01+ PA/LNA.

Ambos módulos, el NRF24L01 y el NRF24L01+ PA/LNA tienen el mismo pinout, así que podemos conectarlos en nuestro circuito de la misma manera.

Cómo conectar el nRF24L01 a Arduino

Aquí está cómo necesitamos conectar los módulos NRF24L01 a las placas Arduino.

Como ya mencioné, cada placa Arduino tiene diferentes pines SPI, así que tenga eso en cuenta al conectar los módulos a su placa Arduino.

Arduino	SCK	MISO	MOSI	SS
Uno	13	12	11	10
Nano	13	12	11	10
Mega	52	50	51	53

Puede conseguir los componentes necesarios para este tutorial de Arduino en los enlaces a continuación:

• Módulo Transceptor NRF24L01………
• Placa Arduino ………………………………
• Protoboard y Cables Jumper …………

Código Arduino y nRF24L01

Una vez conectados los módulos NRF24L01 a las placas Arduino, estamos listos para hacer los códigos para tanto el transmisor como el receptor.

Primero necesitamos descargar e instalar la librería RF24 que hace la programación menos difícil. También podemos instalar esta librería directamente desde el Gestor de Librerías del Arduino IDE. Solo busque «rf24» y encuentre e instale la de «TMRh20, Avamander».

Aquí están los dos códigos para la comunicación inalámbrica y abajo está su descripción.

Código del Transmisor

/* * Tutorial de Comunicación Inalámbrica Arduino * Ejemplo 1 - Código del Transmisor * * por Dejan Nedelkovski, www.HowToMechatronics.com * * Librería: TMRh20/RF24, https://github.com/tmrh20/RF24/ */ #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> RF24 radio(7, 8); // CE, CSN const byte address[6] = "00001"; void setup() { radio.begin(); radio.openWritingPipe(address); radio.setPALevel(RF24_PA_MIN); radio.stopListening(); } void loop() { const char text[] = "Hello World"; radio.write(&text, sizeof(text)); delay(1000); }

Código del Receptor

/* * Tutorial de Comunicación Inalámbrica Arduino * Ejemplo 1 - Código del Receptor * * por Dejan Nedelkovski, www.HowToMechatronics.com * * Librería: TMRh20/RF24, https://github.com/tmrh20/RF24/ */ #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> RF24 radio(7, 8); // CE, CSN const byte address[6] = "00001"; void setup() { Serial.begin(9600); radio.begin(); radio.openReadingPipe(0, address); radio.setPALevel(RF24_PA_MIN); radio.startListening(); } void loop() { if (radio.available()) { char text[32] = ""; radio.read(&text, sizeof(text)); Serial.println(text); } }

Descripción del Código

Necesitamos incluir la librería SPI básica y la recién instalada RF24 y crear un objeto RF24. Los dos argumentos aquí son los pines CSN y CE.

RF24 radio(7, 8); // CE, CSN

Luego necesitamos crear un array de bytes que representará la dirección, o la llamada tubería a través de la cual los dos módulos se comunicarán.

const byte address[6] = "00001";

Podemos cambiar el valor de esta dirección a cualquier cadena de 5 letras y esto permite elegir a qué receptor hablaremos, así que en nuestro caso tendremos la misma dirección tanto en el receptor como en el transmisor.

En la sección setup necesitamos inicializar el objeto radio y usando la función radio.openWritingPipe() establecemos la dirección del receptor a la que enviaremos datos, la cadena de 5 letras que establecimos previamente.

radio.openWritingPipe(address);

En el otro lado, en el receptor, usando la función radio.openReadingPipe() establecemos la misma dirección y de esa manera habilitamos la comunicación entre los dos módulos.

radio.openReadingPipe(0, address);

Luego, usando la función radio.setPALevel() establecemos el nivel del Amplificador de Potencia, en nuestro caso lo pondré al mínimo ya que mis módulos están muy cerca el uno del otro.

radio.setPALevel(RF24_PA_MIN);

Tenga en cuenta que si usa un nivel más alto se recomienda usar condensadores de derivación entre GND y 3.3V de los módulos para que tengan voltaje más estable mientras operan.

Luego tenemos la función radio.stopListening() que configura el módulo como transmisor, y en el otro lado, tenemos la función radio.startListening() que configura el módulo como receptor.

// en el Transmisor radio.stopListening();

// en el Receptor radio.startListening();

En la sección loop, en el transmisor, creamos un array de caracteres al que asignamos el mensaje «Hello World». Usando la función radio.write() enviaremos ese mensaje al receptor. El primer argumento aquí es la variable que queremos enviar.

void loop() { const char text[] = "Hello World"; radio.write(&text, sizeof(text)); delay(1000); }

Al usar el «&» antes del nombre de la variable, en realidad establecemos un indicador de la variable que almacena los datos que queremos enviar y usando el segundo argumento establecemos el número de bytes que queremos tomar de esa variable. En este caso, la función sizeof() obtiene todos los bytes de la cadena «text». Al final del programa agregaremos 1 segundo de retraso.

Usando la función radio.write() podemos enviar un máximo de 32 bytes a la vez.

En el otro lado, en el receptor, en la sección loop, usando la función radio.available() verificamos si hay datos para recibir. Si es cierto, primero creamos un array de 32 elementos, llamado «text», en el que guardaremos los datos entrantes.

void loop() { if (radio.available()) { char text[32] = ""; radio.read(&text, sizeof(text)); Serial.println(text); } }

Usando la función radio.read() leemos y almacenamos los datos en la variable «text». Al final solo imprimimos el texto en el monitor serial. Así que una vez subamos ambos programas, podemos ejecutar el monitor serial en el receptor y notaremos que el mensaje «Hello World» se imprime cada segundo.

Solución de Problemas

Vale la pena notar que el ruido de la fuente de alimentación es uno de los problemas más comunes que experimentan las personas al intentar hacer comunicación exitosa con los módulos NRF24L01. Generalmente, los circuitos RF o señales de radiofrecuencia son sensibles al ruido de la fuente de alimentación. Por lo tanto, siempre es buena idea incluir un condensador de desacoplamiento a través de la línea de alimentación. El condensador puede ser de 10uF a 100uF.

Otro problema común es que el pin 3.3V de las placas Arduino no siempre puede suministrar suficiente energía al módulo NRF24L01. Así que alimentar el módulo con una fuente de energía externa también es una buena idea.

Comunicación Inalámbrica Bidireccional con dos NRF24L01 y Arduino

Veamos el segundo ejemplo, una comunicación inalámbrica bidireccional entre dos placas Arduino. Aquí está el esquema del circuito:

Puede conseguir los componentes necesarios para este ejemplo en los enlaces a continuación:

• Módulo Transceptor NRF24L01…………
• Placa Arduino………………………………….
• Módulo Joystick ……………………………….
• Motor Servo …………………………………….
• Pulsador ……………………………………..
• LED …………………………………………………

Código Fuente nRF24L01

Aquí están los dos códigos y su descripción a continuación.

Código del Transmisor

/* * Tutorial de Comunicación Inalámbrica Arduino * Ejemplo 2 - Código del Transmisor * * por Dejan Nedelkovski, www.HowToMechatronics.com * * Librería: TMRh20/RF24, https://github.com/tmrh20/RF24/ */ #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> #define led 12 RF24 radio(7, 8); // CE, CSN const byte addresses[][6] = {"00001", "00002"}; boolean buttonState = 0; void setup() { pinMode(12, OUTPUT); radio.begin(); radio.openWritingPipe(addresses[1]); // 00002 radio.openReadingPipe(1, addresses[0]); // 00001 radio.setPALevel(RF24_PA_MIN); } void loop() { delay(5); radio.stopListening(); int potValue = analogRead(A0); int angleValue = map(potValue, 0, 1023, 0, 180); radio.write(&angleValue, sizeof(angleValue)); delay(5); radio.startListening(); while (!radio.available()); radio.read(&buttonState, sizeof(buttonState)); if (buttonState == HIGH) { digitalWrite(led, HIGH); } else { digitalWrite(led, LOW); } }

Código del Receptor

/* * Tutorial de Comunicación Inalámbrica Arduino * Ejemplo 2 - Código del Receptor * * por Dejan Nedelkovski, www.HowToMechatronics.com * * Librería: TMRh20/RF24, https://github.com/tmrh20/RF24/ */ #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> #include <Servo.h> #define button 4 RF24 radio(7, 8); // CE, CSN const byte addresses[][6] = {"00001", "00002"}; Servo myServo; boolean buttonState = 0; void setup() { pinMode(button, INPUT); myServo.attach(5); radio.begin(); radio.openWritingPipe(addresses[0]); // 00001 radio.openReadingPipe(1, addresses[1]); // 00002 radio.setPALevel(RF24_PA_MIN); } void loop() { delay(5); radio.startListening(); if ( radio.available()) { while (radio.available()) { int angleV = 0; radio.read(&angleV, sizeof(angleV)); myServo.write(angleV); } delay(5); radio.stopListening(); buttonState = digitalRead(button); radio.write(&buttonState, sizeof(buttonState)); } }

Lo que es diferente aquí del ejemplo anterior es que necesitamos crear dos tuberías o direcciones para la comunicación bidireccional.

const byte addresses[][6] = {"00001", "00002"};

En la sección setup necesitamos definir ambas tuberías, y note que la dirección de escritura en el primer Arduino necesita ser la dirección de lectura en el segundo Arduino, y viceversa, la dirección de lectura en el primer Arduino necesita ser la dirección de escritura en el segundo Arduino.

// en el Transmisor radio.openWritingPipe(addresses[1]); // 00001 radio.openReadingPipe(1, addresses[0]); // 00002

// en el Receptor radio.openWritingPipe(addresses[0]); // 00002 radio.openReadingPipe(1, addresses[1]); // 00001

En la sección loop, usando la función radio.stopListening() configuramos el primer Arduino como transmisor, leemos y mapeamos el valor del Joystick de 0 a 180, y usando la función radio.write() enviamos los datos al receptor.

radio.stopListening(); int potValue = analogRead(A0); int angleValue = map(potValue, 0, 1023, 0, 180); radio.write(&angleValue, sizeof(angleValue));

En el otro lado, usando la función radio.startListening() configuramos el segundo Arduino como receptor y verificamos si hay datos disponibles. Mientras hay datos disponibles, los leeremos, los guardaremos en la variable «angleV» y luego usaremos ese valor para rotar el motor servo.

radio.startListening(); if ( radio.available()) { while (radio.available()) { int angleV = 0; radio.read(&angleV, sizeof(angleV)); myServo.write(angleV); }

Luego, en el transmisor, configuramos el primer Arduino como receptor y con un bucle «while» vacío esperamos a que el segundo Arduino envíe datos, y esos son los datos para el estado del pulsador si está presionado o no. Si el botón está presionado, el LED se encenderá. Así que estos procesos se repiten constantemente y ambas placas Arduino están enviando y recibiendo datos constantemente.

Ejemplo 3 – Enviar múltiples variables en un solo paquete

Veamos un ejemplo más de código usando los módulos NRF24L01. Todo permanece igual que en los ejemplos anteriores, excepto por la forma en que estructuramos y enviamos los datos.

Código del Transmisor

/* Tutorial de Comunicación Inalámbrica Arduino Ejemplo 1 - Código del Transmisor por Dejan Nedelkovski, www.HowToMechatronics.com Librería: TMRh20/RF24, https://github.com/tmrh20/RF24/ */ #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> RF24 radio(7, 8); // CE, CSN const byte address[6] = "00001"; // Tamaño máx de esta struct es 32 bytes - límite buffer NRF24L01 struct Data_Package { byte a = 0; byte b = 125; byte c = 255; int d = 1024; float e = 3.141592; String f = "Test"; }; Data_Package data; // Crear una variable con la estructura anterior void setup() { radio.begin(); radio.openWritingPipe(address); radio.setPALevel(RF24_PA_MIN); radio.stopListening(); } void loop() { // Enviar todos los datos de la estructura al receptor radio.write(&data, sizeof(Data_Package)); delay(500); }

Así que podemos crear una struct que es en realidad una colección de varios tipos de variables.

// Tamaño máx de esta struct es 32 bytes - límite buffer NRF24L01 struct Data_Package { byte a = 0; byte b = 125; byte c = 255; int d = 1024; float e = 3.141592; String f = "Test"; }; Data_Package data; // Crear una variable con la estructura anterior

Debemos tener en cuenta que el tamaño máximo de estos datos struct puede ser 32 bytes. Aquí vemos que incluí tres variables tipo byte, una variable entera (4 bytes), una variable float (4 bytes) y un String que contiene cuatro caracteres (4 bytes). Eso es un total de 15 bytes.

Código del Receptor

/* Tutorial de Comunicación Inalámbrica Arduino Ejemplo 1 - Código del Receptor por Dejan Nedelkovski, www.HowToMechatronics.com Librería: TMRh20/RF24, https://github.com/tmrh20/RF24/ */ #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> RF24 radio(7, 8); // CE, CSN const byte address[6] = "00001"; // Tamaño máx de esta struct es 32 bytes - límite buffer NRF24L01 struct Data_Package { byte a = 0; byte b = 125; byte c = 255; int d = 1024; float e = 3.141592; String f = "Test"; }; Data_Package data; //Crear una variable con la estructura anterior void setup() { Serial.begin(9600); radio.begin(); radio.openReadingPipe(0, address); radio.setPALevel(RF24_PA_MIN); radio.startListening(); } void loop() { // Verificar si hay datos para recibir if (radio.available()) { radio.read(&data, sizeof(Data_Package)); // Leer todos los datos y almacenarlos en la estructura 'data' } Serial.print("a: "); Serial.print(data.a); Serial.print(" b: "); Serial.print(data.b); Serial.print(" c: "); Serial.print(data.c); Serial.print(" d: "); Serial.print(data.d); Serial.print(" e: "); Serial.print(data.e); Serial.print(" f: "); Serial.println(data.f); }

En el lado del receptor, tenemos que definir la misma struct data para poder recibir los datos entrantes. Para probar si la comunicación inalámbrica funciona correctamente, imprimí cada variable en el monitor serial.

Conclusión

El módulo NRF24L01 es una gran opción para cuando necesita comunicación inalámbrica para su proyecto Arduino. Ya he usado este módulo en muchos de mis proyectos Arduino.

Aquí listaré todos mis proyectos en los que he usado estos módulos.

• Control Inalámbrico de Robot Car Arduino usando HC-05 Bluetooth, NRF24L01 y Módulos Transceptores HC-12
• Proyecto Estación Meteorológica Inalámbrica Arduino
• Transmisor RC Arduino DIY
• Robot Hexápodo Hormiga Arduino
• Hovercraft RC basado en Arduino DIY
• Robot Mecanum Wheels Arduino
• Receptor RC Arduino DIY para Modelos RC y Proyectos Arduino
• Avión RC Arduino | 100% DIY

Cada uno de estos proyectos/tutoriales tiene una explicación detallada de cómo usar el módulo NRF24L01, incluyendo diagramas de circuito, implementación de código mejorada para mejor comunicación, etc.

Mi proyecto favorito es este transmisor RC Arduino diseñado a medida. En realidad es un controlador RC de 14 canales que puede usarse para controlar prácticamente cualquier proyecto Arduino.

Eso es todo por este tutorial, espero que lo haya disfrutado y aprendido algo nuevo. Como siempre, siéntase libre de hacer cualquier pregunta en la sección de comentarios a continuación.