¿Alguna vez has soñado con crear una red inalámbrica con Arduino? Con la ayuda de los módulos NRF24L01, ahora es posible. En este artículo, descubrirás cómo configurar una red inalámbrica con múltiples módulos NRF24L01 usando Arduino. ¡Sigue leyendo para aprender todo lo que necesitas saber para llevar tus proyectos de Arduino al siguiente nivel!
En este tutorial, aprenderemos cómo construir una red inalámbrica Arduino que consta de múltiples módulos transceptores NR24L01. Puede ver el vídeo a continuación o leer el tutorial escrito a continuación.
descripción general
Como ejemplo, creé una red de 5 nodos y cada uno de ellos puede comunicarse con cada nodo de la red, actuando como remitente y receptor al mismo tiempo. En realidad, este ejemplo está diseñado para explicar cómo construir una red mucho más grande o, para ser más precisos, podemos tener un total de 3125 módulos comunicándose entre sí a través de un único canal de RF. Así que echemos un vistazo a cómo funciona.
En>Red RF24 Biblioteca que te permite construir fácilmente una red Arduino inalámbrica con muchas placas comunicándose entre sí. Así es como funciona la topología de la red.
Comunicación de múltiples módulos NRF24L01
Un único módulo NRF24L01 puede monitorear activamente hasta otros 6 módulos al mismo tiempo.
La>
De>
Tenga en cuenta que si el nodo 011 quiere comunicarse con el nodo 02, la comunicación debe realizarse a través del nodo 01 y el nodo base 00. Por lo tanto, estos dos nodos deben estar constantemente activos para que la comunicación sea exitosa.
Control de servomotor inalámbrico Arduino mediante la biblioteca RF24Network
Antes de explicar el ejemplo principal de este tutorial, para comprender mejor cómo funciona la biblioteca, creemos un ejemplo más simple de dos placas Arduino comunicándose entre sí. Aquí está el esquema de este ejemplo.
Puede>
- Módulo transceptor NRF24L01……….. Amazon / Banggood / AliExpress
- Servo motor …………………………………… Amazon / Banggood / AliExpress
- Potenciómetro ……………………………….. Amazon / Banggood / AliExpress
- Arduino Nano……………………………….. Amazon / Banggood / AliExpress
Divulgación: estos son enlaces de afiliados. Como asociado de Amazon, gano con compras que califican.
Entonces, con el potenciómetro del primer Arduino controlamos el servomotor del segundo Arduino. Ahora echemos un vistazo a los códigos fuente.
Aquí está el código en la página del potenciómetro:
/*
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); // Include the radio in the network
const uint16_t this_node = 00; // Address of this node in Octal format ( 04,031, etc)
const uint16_t node01 = 01;
void setup() {
SPI.begin();
radio.begin();
network.begin(90, this_node); //(channel, node address)
}
void loop() {
network.update();
unsigned long potValue = analogRead(A0); // Read the potentiometer value
unsigned long angleValue = map(potValue, 0, 1023, 0, 180); // Convert the value to 0-180
RF24NetworkHeader header(node01); // (Address where the data is going)
bool ok = network.write(header, &angleValue, sizeof(angleValue)); // Send the data
}Code language: Arduino (arduino)Primero tenemos que integrar las dos bibliotecas RF24 y RF24Network así como la biblioteca SPI. Luego necesitamos crear el objeto RF24 y envolverlo en el objeto RF24Network. Aquí necesitamos definir las direcciones de los nodos en formato octal, por lo que 00 para este nodo y 01 para el otro nodo en el lado del servo.
En la sección de configuración, necesitamos inicializar la red configurando el canal y la dirección de este nodo.
En la sección de bucle tenemos que llamar constantemente a la función update() mediante la cual se realizan todas las acciones en la red. Luego leemos el valor del potenciómetro y lo convertimos a un valor de 0 a 180 adecuado para el servocontrol. Luego creamos una cabecera de red en la que asignamos la dirección del nodo al que se enviarán los datos. Al final, enviamos los datos al otro nodo usando la función write(). Entonces, aquí el primer parámetro contiene la información de la dirección, el segundo parámetro indica qué datos se enviarán y el tercer parámetro es el tamaño de los datos.
Aquí está el código del lado del servo:
/*
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); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 01; // Address of our node in Octal format ( 04,031, etc)
Servo myservo; // create servo object to control a servo
void setup() {
SPI.begin();
radio.begin();
network.begin(90, this_node); //(channel, node address)
myservo.attach(3); // (servo pin)
}
void loop() {
network.update();
while ( network.available() ) { // Is there any incoming data?
RF24NetworkHeader header;
unsigned long incomingData;
network.read(header, &incomingData, sizeof(incomingData)); // Read the incoming data
myservo.write(incomingData); // tell servo to go to a particular angle
}
}Code language: Arduino (arduino)Por otro lado, para el servomotor, necesitamos definir las bibliotecas y objetos de la misma forma que se explicó anteriormente. Aquí la dirección de este nodo es 01 en formato octal. Después de definir el servomotor, en la sección de bucle, verificamos constantemente los datos entrantes usando el bucle while() y la función disponible(). Si es verdadero, creamos un encabezado de red para aceptar los datos y una variable para almacenar los datos. Luego usamos la función read() para leer los datos y almacenarlos en la variable incomingData. Al final usamos estos datos para mover el servomotor desde el otro nodo según el potenciómetro.
Red inalámbrica Arduino con múltiples módulos NRF24L01
Después de comprender este ejemplo, podemos pasar al ejemplo principal de este tutorial y construir una red inalámbrica de 5 Arduinos comunicándose entre sí. A continuación se muestra un diagrama de bloques del ejemplo.
Entonces>
Relacionado: Transmisor DIY Arduino RC
Código fuente base 00
/*
Arduino Wireless Network - Multiple NRF24L01 Tutorial
== Base/ Master Node 00==
by Dejan, www.HowToMechatronics.com
Libraries:
nRF24/RF24, https://github.com/nRF24/RF24
nRF24/RF24Network, https://github.com/nRF24/RF24Network
*/
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#define button 2
#define led 3
RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 00; // Address of this node in Octal format ( 04,031, etc)
const uint16_t node01 = 01; // Address of the other node in Octal format
const uint16_t node012 = 012;
const uint16_t node022 = 022;
void setup() {
SPI.begin();
radio.begin();
network.begin(90, this_node); //(channel, node address)
radio.setDataRate(RF24_2MBPS);
pinMode(button, INPUT_PULLUP);
pinMode(led, OUTPUT);
}
void loop() {
network.update();
//===== Receiving =====//
while ( network.available() ) { // Is there any incoming data?
RF24NetworkHeader header;
unsigned long incomingData;
network.read(header, &incomingData, sizeof(incomingData)); // Read the incoming data
analogWrite(led, incomingData); // PWM output to LED 01 (dimming)
}
//===== Sending =====//
// Servo control at Node 01
unsigned long potValue = analogRead(A0);
unsigned long angleValue = map(potValue, 0, 1023, 0, 180); // Suitable for servo control
RF24NetworkHeader header2(node01); // (Address where the data is going)
bool ok = network.write(header2, &angleValue, sizeof(angleValue)); // Send the data
// LED Control at Node 012
unsigned long buttonState = digitalRead(button);
RF24NetworkHeader header4(node012); // (Address where the data is going)
bool ok3 = network.write(header4, &buttonState, sizeof(buttonState)); // Send the data
// LEDs control at Node 022
unsigned long pot2Value = analogRead(A1);
RF24NetworkHeader header3(node022); // (Address where the data is going)
bool ok2 = network.write(header3, &pot2Value, sizeof(pot2Value)); // Send the data
}Code language: Arduino (arduino)Por lo tanto, en el nodo base o maestro, debemos definir las bibliotecas y los objetos como se explicó anteriormente y también definir todos los demás nodos a los que el maestro enviará datos. En la sección de bucle, primero comprobamos constantemente si entran datos. En caso afirmativo, leemos los datos, los almacenamos en la variable incomingData y los usamos para controlar el brillo del LED. Estos datos en realidad provienen del potenciómetro del nodo 02. Si miramos su código, podemos ver que la configuración es más o menos la misma. Es importante que asignemos la dirección correcta a la ubicación donde queremos enviar datos. En este caso, ese es el maestro 00. Entonces, después de leer el valor del potenciómetro y convertirlo a un valor PWM adecuado de 0 a 255, enviamos estos datos al maestro. Podemos notar aquí que utilicé la función millis() para enviar los datos en intervalos de 10 milisegundos.
Código fuente del nodo 02
/*
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); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 02; // Address of our node in Octal format ( 04,031, etc)
const uint16_t master00 = 00; // Address of the other node in Octal format
const unsigned long interval = 10; //ms // How often to send data to the other unit
unsigned long last_sent; // When did we last send?
void setup() {
SPI.begin();
radio.begin();
network.begin(90, this_node); //(channel, node address)
radio.setDataRate(RF24_2MBPS);
}
void loop() {
network.update();
//===== Sending =====//
unsigned long now = millis();
if (now - last_sent >= interval) { // If it's time to send a data, send it!
last_sent = now;
unsigned long potValue = analogRead(A0);
unsigned long ledBrightness = map(potValue, 0, 1023, 0, 255);
RF24NetworkHeader header(master00); // (Address where the data is going)
bool ok = network.write(header, &ledBrightness, sizeof(ledBrightness)); // Send the data
}
}Code language: Arduino (arduino)A continuación, enviamos los datos del potenciómetro desde el maestro al nodo 01 para controlar el servomotor.
Código fuente del nodo 01
/*
Arduino Wireless Network - Multiple NRF24L01 Tutorial
== Node 02 (Child of Master node 00) ==
*/
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#include <Servo.h>
#define led 2
RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 01; // Address of our node in Octal format ( 04,031, etc)
const uint16_t master00 = 00; // Address of the other node in Octal format
Servo myservo; // create servo object to control a servo
void setup() {
SPI.begin();
radio.begin();
network.begin(90, this_node); //(channel, node address)
radio.setDataRate(RF24_2MBPS);
myservo.attach(3); // (servo pin)
pinMode(led, OUTPUT);
}
void loop() {
network.update();
//===== Receiving =====//
while ( network.available() ) { // Is there any incoming data?
RF24NetworkHeader header;
unsigned long incomingData;
network.read(header, &incomingData, sizeof(incomingData)); // Read the incoming data
if (header.from_node == 0) { // If data comes from Node 02
myservo.write(incomingData); // tell servo to go to a particular angle
}
if (header.from_node == 10) { // If data comes from Node 012
digitalWrite(led, !incomingData); // Turn on or off the LED 02
}
}
}Code language: Arduino (arduino)En realidad, el nodo 01 recibe datos de dos nodos diferentes, uno para el servocontrol y el otro para el control de LED, que proviene del sensor de infrarrojos del nodo 012.
Código fuente para el nodo 012
/*
Arduino Wireless Network - Multiple NRF24L01 Tutorial
== Node 012 (child of Node 02)==
*/
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#define led 2
#define IR 3
RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 012; // Address of our node in Octal format ( 04,031, etc)
const uint16_t node01 = 01; // Address of the other node in Octal format
void setup() {
SPI.begin();
radio.begin();
network.begin(90, this_node); //(channel, node address)
radio.setDataRate(RF24_2MBPS);
pinMode(led, OUTPUT);
pinMode(IR, INPUT);
}
void loop() {
network.update();
//===== Receiving =====//
while ( network.available() ) { // Is there any incoming data?
RF24NetworkHeader header;
unsigned long buttonState;
network.read(header, &buttonState, sizeof(buttonState)); // Read the incoming data
digitalWrite(led, !buttonState); // Turn on or off the LED
}
//===== Sending =====//
unsigned long irV = digitalRead(IR); // Read IR sensor
RF24NetworkHeader header8(node01);
bool ok = network.write(header8, &irV, sizeof(irV)); // Send the data
}Code language: Arduino (arduino)En tal caso, utilizamos el atributo header.from_node para obtener información sobre de qué nodo provienen los datos. Si los datos entrantes son del maestro, los usamos para controlar el servo, y si los datos entrantes son del nodo 012, los usamos para controlar el LED.
En el nodo 012 tenemos tanto envío como recepción. El sensor de infrarrojos controla el LED mencionado anteriormente en el nodo 01 y el LED aquí se controla mediante el botón del maestro.
Código fuente para el nodo 022
/*
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); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 022; // Address of our node in Octal format ( 04,031, etc)
const uint16_t master00 = 00; // Address of the other node in Octal format
void setup() {
SPI.begin();
radio.begin();
network.begin(90, this_node); //(channel, node address)
radio.setDataRate(RF24_2MBPS);
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
}
void loop() {
network.update();
//===== Receiving =====//
while ( network.available() ) { // Is there any incoming data?
RF24NetworkHeader header;
unsigned long potValue;
network.read(header, &potValue, sizeof(potValue)); // Read the incoming data
// Turn on the LEDs as depending on the incoming value from the potentiometer
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);
}
}
}Code language: Arduino (arduino)Finalmente, los LED del nodo 022 se controlan utilizando los datos provenientes del otro potenciómetro del maestro.
En resumen, cuando todo está conectado correctamente y todos los nodos están activos todo el tiempo, nuestro trabajo se reduce a apuntar con precisión a los nodos y todo el trabajo pesado detrás de esto lo realiza la increíble biblioteca RF24Network.
Eso es todo. Espero que hayas disfrutado este proyecto Arduino y hayas aprendido algo nuevo. No dude en hacer sus preguntas en la sección de comentarios a continuación.
En este tutorial aprenderás cómo construir una red inalámbrica Arduino, compuesta por múltiples módulos transceptores NRF24L01. Veremos cómo configurar una red de 5 nodos que pueden comunicarse entre sí y actuar tanto como transmisores como receptores. Este ejemplo está configurado para explicar cómo hacer una red mucho más grande, en la que hasta 3125 módulos pueden comunicarse en un solo canal de RF.
En tutoriales anteriores hemos aprendido cómo realizar una comunicación inalámbrica entre dos placas Arduino utilizando los módulos NRF24L01 y la biblioteca RF24. Además de esta biblioteca, utilizaremos la biblioteca RF24Network, que facilita la creación de una red inalámbrica Arduino con múltiples placas comunicándose entre sí. Así es como funciona la topología de la red.
Un solo módulo NRF24L01 puede escuchar activamente hasta 6 otros módulos al mismo tiempo. Esta capacidad es aprovechada por la biblioteca RF24Network para generar una red organizada en una topología de árbol, donde un nodo es la base y todos los demás nodos son hijos de ese nodo o de otro. Cada nodo puede tener hasta 5 hijos y esto puede llegar a ser 5 niveles de profundidad, lo que nos permite crear una red de un total de 3125 nodos. Cada nodo debe definirse con una dirección de 15 bits que describe la posición del nodo dentro del árbol.
En este tutorial aprenderás a controlar un servo motor inalámbrico con Arduino utilizando la biblioteca RF24Network. Implementaremos un ejemplo más simple de dos placas Arduino en comunicación inalámbrica y luego ampliaremos el proyecto para incluir una red de 5 placas Arduino con diferentes funciones asignadas.
Para replicar este proyecto, necesitarás los siguientes componentes: módulos NRF24L01, servo motor, potenciómetro, placas Arduino Nano. Puedes encontrar estos componentes en tiendas online como Amazon, Banggood o AliExpress.
En resumen, este tutorial te guiará paso a paso sobre cómo construir una red inalámbrica Arduino con múltiples módulos NRF24L01. Aprenderás a configurar cada nodo de la red y a controlar diferentes dispositivos como servo motores y LEDs de forma inalámbrica. Esperamos que este tutorial te sea de utilidad y que puedas aprender algo nuevo en el proceso. ¡Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios!
¡Qué chido! Nunca había pensado en usar múltiples módulos NRF24L01 con mi Arduino. Definitivamente quiero probar esto ahora, gracias por compartir. ¡Saludos!
¡No sabía que se podía hacer eso con los módulos NRF24L01! ¡Qué descubrimiento! Definitivamente tengo que intentarlo en mi proyecto de Arduino. ¡Gracias por el dato! ¡Saludos!
¡Interesante artículo! Me gustaría probar esto en mi proyecto de Arduino. ¡Gracias por la información!
¡Vaya, no tenía ni idea de que se podía hacer una red inalámbrica con tantos módulos NRF24L01 en Arduino! Definitivamente voy a experimentar con esto en mi proyecto. ¡Gracias por la inspiración! ¡Saludos!