Construya una Red Malla Inalámbrica Arduino Robusta con Módulos NRF24L01

En este tutorial aprenderemos a construir una red inalámbrica Arduino compuesta por múltiples módulos transceptores NRF24L01. Puede ver el siguiente video o leer el tutorial escrito a continuación.

Resumen

Como ejemplo, he creado una red de 5 nodos donde cada uno puede comunicarse con cualquier otro nodo de la red y, al mismo tiempo, funcionar tanto como transmisor como receptor. Este ejemplo está configurado de forma que explica cómo crear una red mucho mayor; para ser precisos, podemos tener un total de 3125 módulos comunicándose entre sí en un solo canal RF. Veamos cómo funciona.

En tutoriales previos ya aprendimos a hacer comunicación inalámbrica entre dos placas Arduino usando módulos NRF24L01 y la librería RF24. Ahora, además de esta librería, usaremos la librería RF24Network, que permite de forma sencilla construir una red inalámbrica Arduino con muchas placas comunicándose entre sí. Así funciona la topología de red.

Comunicación Múltiple con Módulos NRF24L01

Un solo módulo NRF24L01 puede escuchar activamente hasta 6 otros módulos simultáneamente.

Esta capacidad es utilizada por la librería RF24Network para generar una red dispuesta en topología de árbol, donde un nodo es la base y todos los demás son hijos de ese nodo o de otro. Cada nodo puede tener hasta 5 hijos, y esto puede llegar a 5 niveles de profundidad, lo que permite crear una red de 3125 nodos totales. Cada nodo debe definirse con una dirección de 15 bits, que describe precisamente la posición del nodo dentro del árbol.

Podemos definir las direcciones de los nodos en formato octal. Así, la dirección del maestro o base es 00, los hijos de la base son 01 a 05, los hijos del nodo 01 son 011 a 051, y así sucesivamente.

Nota: Si el nodo 011 quiere hablar con el nodo 02, la comunicación debe pasar por el nodo 01 y el nodo base 00, por lo que estos dos nodos deben estar activos todo el tiempo para que la comunicación sea exitosa.

Control Inalámbrico de Servomotor Arduino con la Librería RF24Network

Antes de explicar el ejemplo principal, para entender mejor cómo funciona la librería, haremos un ejemplo más simple de dos placas Arduino comunicándose. Aquí está el diagrama de conexiones.

Puede conseguir los componentes necesarios en los enlaces siguientes:

• Módulo Transceptor NRF24L01
• Servomotor
• Potenciómetro
• Arduino Nano

Usando el potenciómetro en el primer Arduino controlaremos el servomotor en el segundo. Veamos los códigos fuente.

Código en el lado del potenciómetro (Nodo 00)

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial
   == Example 01 - Servo Control / Node 00 - Potentiometer
   by Dejan, www.HowToMechatronics.com
   Libraries: nRF24/RF24, https://github.com/nRF24/RF24
              nRF24/RF24Network, https://github.com/nRF24/RF24Network */
#include <RF24.h>
#include <RF24Network.h>
#include <SPI.h>

RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Incluir radio en la red
const uint16_t this_node = 00; // Dirección de este nodo en octal
const uint16_t node01 = 01;    // Dirección del otro nodo

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node); // (canal, dirección nodo)
}

void loop() {
  network.update();
  unsigned long potValue = analogRead(A0); // Leer potenciómetro
  unsigned long angleValue = map(potValue, 0, 1023, 0, 180); // Convertir a 0-180
  RF24NetworkHeader header(node01); // Dirección destino
  bool ok = network.write(header, &angleValue, sizeof(angleValue)); // Enviar datos
}

Primero incluimos las librerías RF24, RF24Network y SPI. Creamos el objeto RF24 y lo incluimos en el objeto RF24Network. Definimos las direcciones en formato octal: 00 para este nodo, 01 para el nodo del servo.

En setup() inicializamos la red configurando canal y dirección. En loop() llamamos constantemente a update() (motor de la red), leemos el potenciómetro, convertimos a 0-180°, creamos una cabecera con la dirección de destino y enviamos los datos con write().

Código en el lado del servo (Nodo 01)

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial
   == Example 01 - Servo Control / Node 01 - Servo motor == */
#include <RF24.h>
#include <RF24Network.h>
#include <SPI.h>
#include <Servo.h>

RF24 radio(10, 9);
RF24Network network(radio);
const uint16_t this_node = 01; // Dirección de nuestro nodo en octal
Servo myservo;

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node);
  myservo.attach(3); // Pin del servo
}

void loop() {
  network.update();
  while ( network.available() ) { // ¿Hay datos entrantes?
    RF24NetworkHeader header;
    unsigned long incomingData;
    network.read(header, &incomingData, sizeof(incomingData)); // Leer datos
    myservo.write(incomingData); // Mover servo al ángulo recibido
  }
}

En el lado del servo definimos librerías y objetos igual. La dirección es 01. En loop(), con while() y available() comprobamos constantemente si hay datos entrantes. Si es así, creamos cabecera y variable de almacenamiento, leemos con read() y usamos el dato para mover el servo según el potenciómetro del otro nodo.

Red Inalámbrica Arduino con Múltiples Módulos NRF24L01

Entendido este ejemplo, pasamos al principal: construir una red inalámbrica de 5 Arduinos comunicándose. Aquí el diagrama de bloques.

Desde la base, con un potenciómetro controlamos el servo en nodo 01; con segundo potenciómetro controlamos LEDs en nodo 022; con un botón controlamos LED en nodo 012; y el LED en la base se controla con el potenciómetro en nodo 02. Además, con el sensor infrarrojo en nodo 012 controlamos el LED en nodo 01. Este ejemplo muestra cómo transmitir y recibir a la vez, y cómo comunicar nodos de ramas diferentes. Veamos los códigos.

Código Base 00 (Maestro)

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial
   == Base/ Master Node 00 ==
   by Dejan, www.HowToMechatronics.com */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#define button 2
#define led 3
RF24 radio(10, 9);
RF24Network network(radio);
const uint16_t this_node = 00;
const uint16_t node01 = 01;
const uint16_t node012 = 012;
const uint16_t node022 = 022;

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node);
  radio.setDataRate(RF24_2MBPS);
  pinMode(button, INPUT_PULLUP);
  pinMode(led, OUTPUT);
}

void loop() {
  network.update();
  //===== Recepción =====//
  while ( network.available() ) {
    RF24NetworkHeader header;
    unsigned long incomingData;
    network.read(header, &incomingData, sizeof(incomingData));
    analogWrite(led, incomingData); // PWM al LED 01 (atenuación)
  }
  //===== Envío =====//
  // Control servo en Nodo 01
  unsigned long potValue = analogRead(A0);
  unsigned long angleValue = map(potValue, 0, 1023, 0, 180);
  RF24NetworkHeader header2(node01);
  bool ok = network.write(header2, &angleValue, sizeof(angleValue));
  // Control LED en Nodo 012
  unsigned long buttonState = digitalRead(button);
  RF24NetworkHeader header4(node012);
  bool ok3 = network.write(header4, &buttonState, sizeof(buttonState));
  // Control LEDs en Nodo 022
  unsigned long pot2Value = analogRead(A1);
  RF24NetworkHeader header3(node022);
  bool ok2 = network.write(header3, &pot2Value, sizeof(pot2Value));
}

En el maestro definimos librerías, objetos y todos los nodos a los que enviará datos. En loop() comprobamos datos entrantes (del potenciómetro del nodo 02) y los usamos para atenuar el LED local. Luego enviamos tres datos: ángulo de servo a nodo 01, estado de botón a nodo 012, y valor de potenciómetro a nodo 022.

Código Nodo 02 (Hijo de Maestro 00)

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial
   == Node 02 (Child of Master node 00) == */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
RF24 radio(10, 9);
RF24Network network(radio);
const uint16_t this_node = 02;
const uint16_t master00 = 00;
const unsigned long interval = 10; // ms
unsigned long last_sent;

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node);
  radio.setDataRate(RF24_2MBPS);
}

void loop() {
  network.update();
  //===== Envío =====//
  unsigned long now = millis();
  if (now - last_sent >= interval) {
    last_sent = now;
    unsigned long potValue = analogRead(A0);
    unsigned long ledBrightness = map(potValue, 0, 1023, 0, 255);
    RF24NetworkHeader header(master00);
    bool ok = network.write(header, &ledBrightness, sizeof(ledBrightness));
  }
}

El nodo 02 envía periódicamente (cada 10 ms) el valor de su potenciómetro convertido a PWM (0-255) al maestro 00.

Código Nodo 01 (Hijo de Maestro 00)

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial
   == Node 01 (Child of Master node 00) == */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#include <Servo.h>
#define led 2
RF24 radio(10, 9);
RF24Network network(radio);
const uint16_t this_node = 01;
const uint16_t master00 = 00;
Servo myservo;

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node);
  radio.setDataRate(RF24_2MBPS);
  myservo.attach(3);
  pinMode(led, OUTPUT);
}

void loop() {
  network.update();
  //===== Recepción =====//
  while ( network.available() ) {
    RF24NetworkHeader header;
    unsigned long incomingData;
    network.read(header, &incomingData, sizeof(incomingData));
    if (header.from_node == 0) { // Dato del maestro
      myservo.write(incomingData);
    }
    if (header.from_node == 10) { // Dato de nodo 012 (octal 012 = decimal 10)
      digitalWrite(led, !incomingData); // LED encendido/apagado
    }
  }
}

El nodo 01 recibe de dos nodos distintos: del maestro para el servo, y del nodo 012 para el LED. Usamos header.from_node para identificar el origen.

Código Nodo 012 (Hijo de Nodo 01)

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial
   == Node 012 (child of Node 01) == */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#define led 2
#define IR 3
RF24 radio(10, 9);
RF24Network network(radio);
const uint16_t this_node = 012;
const uint16_t node01 = 01;

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node);
  radio.setDataRate(RF24_2MBPS);
  pinMode(led, OUTPUT);
  pinMode(IR, INPUT);
}

void loop() {
  network.update();
  //===== Recepción =====//
  while ( network.available() ) {
    RF24NetworkHeader header;
    unsigned long buttonState;
    network.read(header, &buttonState, sizeof(buttonState));
    digitalWrite(led, !buttonState);
  }
  //===== Envío =====//
  unsigned long irV = digitalRead(IR); // Leer sensor IR
  RF24NetworkHeader header8(node01);
  bool ok = network.write(header8, &irV, sizeof(irV));
}

El nodo 012 recibe del maestro (botón) para controlar su LED local, y envía la lectura del sensor IR al nodo 01.

Código Nodo 022 (Hijo de Nodo 02)

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial
   == Node 022 (child of Node 02) == */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#define led1 2
#define led2 3
#define led3 4
#define led4 5
RF24 radio(10, 9);
RF24Network network(radio);
const uint16_t this_node = 022;
const uint16_t master00 = 00;

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node);
  radio.setDataRate(RF24_2MBPS);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}

void loop() {
  network.update();
  while ( network.available() ) {
    RF24NetworkHeader header;
    unsigned long potValue;
    network.read(header, &potValue, sizeof(potValue));
    // Encender LEDs según valor del potenciómetro
    if (potValue > 240) digitalWrite(led1, HIGH); else digitalWrite(led1, LOW);
    if (potValue > 480) digitalWrite(led2, HIGH); else digitalWrite(led2, LOW);
    if (potValue > 720) digitalWrite(led3, HIGH); else digitalWrite(led3, LOW);
    if (potValue > 960) digitalWrite(led4, HIGH); else digitalWrite(led4, LOW);
  }
}

El nodo 022 recibe el valor del potenciómetro del maestro y enciende 4 LEDs progresivamente según umbrales.

En resumen, si todo está conectado correctamente y todos los nodos están activos, nuestro trabajo se reduce a direccionar precisamente los nodos; todo el trabajo pesado lo realiza la increíble librería RF24Network.

¡Eso es todo! Espero que hayan disfrutado este proyecto Arduino y aprendido algo nuevo. Dejen sus preguntas en los comentarios.