Documentos de Académico
Documentos de Profesional
Documentos de Cultura
¿QUÉ ES EL NRF24L01?
El NRF24L01 también incorpora la lógica necesaria para que la comunicación sea robusta,
como corrección de errores y reenvío de datos si es necesario, liberando de esta tarea al procesador.
El control del módulo se realiza a través de bus SPI, por lo que es sencillo controlarlo desde un
procesador como Arduino.
La banda de frecuencia es de 2400 a 2525 MHz, pudiendo elegir entre 125 canales espaciados
a razón de 1MHz. Se recomienda usar las frecuencias de 2501 a 2525 MHz para evitar
interferencias con las redes Wifi.
La tensión de alimentación del NRF24L01 es de 1.9 a 3.6V, aunque los pines de datos son
tolerantes a 5V. El consumo eléctrico en Stand By es bajo, y de unos 15mA durante el envío y
recepción.
Existen dos versiones de módulos que montan el NRF24L01, uno con antena integrada en
forma de zig-zag y un alcance máximo de 20-30 metros, y la versión de alta potencia que incorpora
amplificador y antena externa, con un alcance máximo de 700-1000 metros.
Sin embargo, el alcance real se ve limitado por muchos factores, incluso en condiciones
visibilidad directa sin obstáculos. Con el módulo de antena integrada y alimentación desde Arduino
y velocidad de transmisión de 2 Mbps el alcance será apenas de 2-3 metros.
Los módulos NRF24L01 son ampliamente empleados por su bajo precio y buenas
características. Podemos emplearlos, por ejemplo, para recepción remota de sensores como
temperatura presión, aplicaciones de domótica y edificios inteligentes, activación remota de
dispositivos como iluminación, alarmas, y control o monitorización de robots en el rango de hasta
700 metros.
Le versión con amplificador y antena externa tiene un precio superior de 1.70€, pero a cambio
mejoran el alcance hasta 700-1000 metros, aunque para conseguir este alcance obligatoriamente
necesitaremos alimentar el módulo con una fuente externa de 3.3V.
Lógicamente, en ambos casos, necesitaremos dos módulos NRF24L01, uno como emisor y
otro como receptor.
ESQUEMA DE MONTAJE
EJEMPLOS DE CÓDIGO
Para realizar el control del NRF24L01 usaremos la librería RF24, disponible en este enlace.
La librería proporciona ejemplos de código, que resulta aconsejable revisar. Los siguientes
ejemplos son modificaciones a partir de los disponibles en la librería
ENVIAR UN STRING
CÓDIGO EMISOR
1 #include <nRF24L01.h>
2 #include <RF24.h>
3 #include <RF24_config.h>
4 #include <SPI.h>
5
6 const intpinCE = 9;
7 const intpinCSN = 10;
8 RF24 radio(pinCE, pinCSN);
9
10 // Single radio pipe address for the 2 nodes to communicate.
11 const uint64_t pipe = 0xE8E8F0F0E1LL;
12
13 char data[16]="Hola mundo" ;
14
15 void setup(void)
16 {
17 radio.begin();
18 radio.openWritingPipe(pipe);
19 }
20
21 void loop(void)
22 {
23 radio.write(data, sizeof data);
24 delay(1000);
25 }
Código receptor
1 #include <nRF24L01.h>
2 #include <RF24.h>
3 #include <RF24_config.h>
4 #include <SPI.h>
5
6 const intpinCE = 9;
7 const intpinCSN = 10;
8 RF24 radio(pinCE, pinCSN);
9
10 // Single radio pipe address for the 2 nodes to communicate.
11 const uint64_t pipe = 0xE8E8F0F0E1LL;
12
13 char data[16];
14
15 void setup(void)
16 {
17 Serial.begin(9600);
18 radio.begin();
19 radio.openReadingPipe(1,pipe);
20 radio.startListening();
21 }
22
23 void loop(void)
24 {
25 if (radio.available())
26 {
27 int done = radio.read(data, sizeof data);
28 Serial.println(data);
29 }
30 }
ENVIAR VARIABLES INTEGER O FLOAT
El siguiente ejemplo muestra el envío de variables integer o float desde un Arduino emisor a
otro receptor, que muestra los datos por puerto serie. El Arduino emisor envía dos datos cualquiera,
en el ejemplo millis()/1000 como integer y 3.14 como float.
Por su parte, el receptor recibe los datos, y en función del identificador convierte los datos
recibidos a integer o float, y muestra el resultado por el puerto serie.
CODIGO EMISOR
1 #include <SPI.h>
2 #include <nRF24L01.h>
3 #include <RF24.h>
4
5 const intpinCE = 9;
6 const intpinCSN = 10;
7 RF24 radio(pinCE, pinCSN);
8
9 // Single radio pipe address for the 2 nodes to communicate.
10 const uint64_t pipe = 0xE8E8F0F0E1LL;
11
12 float data[2];
13
14 void setup()
15 {
16 radio.begin();
17 radio.openWritingPipe(pipe);
18 }
19
20 void loop()
21 {
22 data[0]= 3.14;
23 data[1] = millis()/1000.0;
24
25 radio.write(data, sizeof data);
26 delay(1000);
27 }
CODIGO RECEPTOR
1 #include <SPI.h>
2 #include <nRF24L01.h>
3 #include <RF24.h>
4
5 const intpinCE = 9;
6 const intpinCSN = 10;
7 RF24 radio(pinCE, pinCSN);
8
9 // Single radio pipe address for the 2 nodes to communicate.
10 const uint64_t pipe = 0xE8E8F0F0E1LL;
11
12 float data[3];
13
14 void setup()
15 {
16 radio.begin();
17 Serial.begin(9600);
18 radio.openReadingPipe(1, pipe);
19 radio.startListening();
20 }
21
22 void loop()
23 {
24 if (radio.available())
25 {
26 radio.read(data, sizeof data);
27 Serial.print("Dato0= " );
28 Serial.print(data[0]);
29 Serial.print("Dato1= " );
30 Serial.print(data[1]);
31 Serial.println("");
32 }
33 delay(1000);
34 }