nRF24L01 – Como Funciona, Interface Arduino, Circuitos, Códigos
Neste tutorial vamos aprender como fazer comunicação sem fio entre duas placas Arduino usando o nRF24L01 módulos transceptores. O módulo nRF24L01 é uma escolha muito popular para comunicação sem fio ao usar o Arduino.
Eu já usei este módulo para vários projetos do Arduino e você pode conferir alguns deles aqui:
- Transmissor RC Arduino DIY
- Arduino RC Avião | 100% faça você mesmo
- Hovercraft RC baseado em Arduino DIY
- Projeto da estação meteorológica sem fio Arduino
Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo. Inclui tudo o que precisamos saber sobre o módulo transceptor nRF24L01, como a pinagem do módulo, princípio de funcionamento, fiação e vários exemplos de código.
Visão geral
Para explicar a comunicação sem fio faremos dois exemplos, o primeiro será o envio de uma simples mensagem “Hello World” de um Arduino para outro, e no segundo exemplo teremos uma comunicação bidirecional entre as placas Arduino, onde usando o Joystick no primeiro Arduino vamos controlar o servo motor no segundo Arduino, e vice-versa, usando o botão no segundo Arduino vamos controlar o LED no primeiro Arduino.
Módulo Transceptor nRF24L01
Vamos dar uma olhada no módulo transceptor NRF24L01. Ele usa a banda de 2,4 GHz e pode operar com taxas de transmissão de 250 kbps até 2 Mbps. Se usado em espaço aberto e com menor taxa de transmissão seu alcance pode chegar a 100 metros.
Aqui estão as especificações completas:
| Intervalo de frequência | 2,4 – banda ISM de 2,5 GHz |
| Taxas de dados | 250 Kbps / 1 Mbps / 2 Mbps |
| Máx. potência de saída | 0dBm |
| Tensão de operação | 1,9 – 3,6 V |
| Máx. corrente de operação | 12,3mA |
| Atual em espera | 22µA |
| Entradas lógicas | 5V tolerante |
| Intervalo de comunicação | 100m (espaço aberto) |
Como funciona
O módulo pode usar 125 canais diferentes o que dá a possibilidade de ter uma rede de 125 modems funcionando independentemente em um só lugar. Cada canal pode ter até 6 endereços, ou cada unidade pode se comunicar com até 6 outras unidades ao mesmo tempo.
O consumo de energia deste módulo é de apenas 12mA durante a transmissão, o que é ainda menor do que um único LED. A tensão de operação do módulo é de 1,9 a 3,6V, mas o bom é que os outros pinos toleram a lógica de 5V, então podemos conectá-lo facilmente a um Arduino sem usar nenhum conversor de nível lógico.
Três desses pinos são para a comunicação SPI e eles precisam ser conectados aos pinos SPI do Arduino, mas observe que cada placa Arduino possui pinos SPI diferentes. Os pinos CSN e CE podem ser conectados a qualquer pino digital da placa Arduino e são utilizados para colocar o módulo em modo standby ou ativo, bem como para alternar entre modo de transmissão ou comando. O último pino é um pino de interrupção que não precisa ser usado.
Variações do módulo
Existem diversas variações dos módulos NRF24L01. O mais popular é aquele com antena integrada. Isso torna o módulo mais compacto, mas, por outro lado, diminui o alcance de transmissão para uma distância de cerca de 100 metros.
A segunda variação, em vez de antena on-board, possui um conector SMA e podemos anexar uma antena de pato para melhor alcance de transmissão.
A terceira variação mostrada aqui, além da antena de pato, possui um chip RFX2401C que inclui PA (amplificador de potência) e LNA (Amplificador de baixo ruído). Isso amplifica o sinal NRF24L01 e permite um alcance de transmissão ainda melhor de até 1000 metros em espaço aberto.
Pinagem do módulo nRF24L01
Aqui está uma visão detalhada da pinagem NRF24L01, bem como do módulo NRF24L01+ PA/LNA.
Ambos os módulos, o NRF24L01 e o NRF24L01+ PA/LNA possuem a mesma pinagem, então podemos conectá-los em nosso circuito da mesma forma.
Como conectar o nRF24L01 ao Arduino
Veja como precisamos conectar os módulos NRF24L01 às placas Arduino.
Como já mencionei, cada placa Arduino possui pinos SPI diferentes, portanto, lembre-se disso ao conectar os módulos à sua placa Arduino.
| Arduino | SCK | MISO | MOSI | SS |
| Uno | 13 | 12 | 11 | 10 |
| Nano | 13 | 12 | 11 | 10 |
| Mega | 52 | 50 | 51 | 53 |
Você pode obter os componentes necessários para este tutorial do Arduino nos links abaixo:
- Módulo Transceptor NRF24L01………
- Placa Arduino …………………………………
- Breadboard e jump wires …………
Código do Arduino e nRF24L01
Uma vez que conectamos os módulos NRF24L01 às placas Arduino, estamos prontos para fazer os códigos tanto para o transmissor quanto para o receptor.
Primeiro, precisamos baixar e instalar a biblioteca RF24 o que torna a programação menos difícil. Também podemos instalar esta biblioteca diretamente do Arduino IDE Library Manager. Basta procurar por “rf24” e encontrar e instalar o de “TMRh20, Avamander”.
Aqui estão os dois códigos para a comunicação sem fio e abaixo está a descrição deles.
Código do transmissor
/*
* Arduino Wireless Communication Tutorial
* Example 1 - Transmitter Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
* Library: 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);
}Code language: Arduino (arduino)Código do receptor
/*
* Arduino Wireless Communication Tutorial
* Example 1 - Receiver Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
* Library: 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);
}
}Code language: Arduino (arduino)Descrição do código
Portanto, precisamos incluir o SPI básico e as bibliotecas RF24 recém-instaladas e criar um objeto RF24. Os dois argumentos aqui são os pinos CSN e CE.
RF24 radio(7, 8); // CE, CSNCode language: Arduino (arduino)Em seguida, precisamos criar um array de bytes que representará o endereço, ou o chamado pipe através do qual os dois módulos se comunicarão.
const byte address[6] = "00001";Code language: Arduino (arduino)Podemos alterar o valor deste endereço para qualquer string de 5 letras e isso permite escolher com qual receptor vamos falar, então no nosso caso teremos o mesmo endereço tanto no receptor quanto no transmissor.
Na seção de configuração precisamos inicializar o objeto de rádio e usando a função radio.openWritingPipe() definimos o endereço do receptor para o qual enviaremos os dados, a string de 5 letras que definimos anteriormente.
radio.openWritingPipe(address);Code language: Arduino (arduino)Por outro lado, no receptor, usando a função radio.setReadingPipe() definimos o mesmo endereço e dessa forma habilitamos a comunicação entre os dois módulos.
radio.openReadingPipe(0, address);Code language: Arduino (arduino)Em seguida, usando a função radio.setPALevel() definimos o nível do Amplificador de Potência, no nosso caso vou definir no mínimo, pois meus módulos estão muito próximos um do outro.
radio.setPALevel(RF24_PA_MIN);Code language: Arduino (arduino)Observe que, se estiver usando um nível mais alto, é recomendável usar capacitores de bypass em GND e 3,3V dos módulos para que tenham uma tensão mais estável durante a operação.
Em seguida temos a função radio.stopListening() que configura o módulo como transmissor, e do outro lado temos a função radio.startListening() que configura o módulo como receptor.
// at the Transmitter
radio.stopListening();Code language: Arduino (arduino)// at the Receiver
radio.startListening();Code language: Arduino (arduino)Na seção de loop, no transmissor, criamos um array de caracteres aos quais atribuímos a mensagem “Hello World”. Usando a função radio.write(), enviaremos essa mensagem ao receptor. O primeiro argumento aqui é a variável que queremos que seja enviada.
void loop() {
const char text[] = "Hello World";
radio.write(&text, sizeof(text));
delay(1000);
}Code language: Arduino (arduino)Usando o “&” antes do nome da variável, na verdade definimos uma indicação da variável que armazena os dados que queremos que sejam enviados e usando o segundo argumento definimos o número de bytes que queremos tirar dessa variável. Neste caso, a função sizeof() obtém todos os bytes das strings “texto”. No final do programa, adicionaremos 1 segundo de atraso.
Usando a função radio.write() podemos enviar no máximo 32 bytes por vez.
Por outro lado, no receptor, na seção de loop usando a função radio.available() verificamos se há dados a serem recebidos. Se isso for verdade, primeiro criamos um array de 32 elementos, chamado “texto”, no qual salvaremos os dados recebidos.
void loop() {
if (radio.available()) {
char text[32] = "";
radio.read(&text, sizeof(text));
Serial.println(text);
}
}Code language: Arduino (arduino)Usando a função radion.read() lemos e armazenamos os dados na variável “texto”. No final, apenas imprimimos o texto no monitor serial. Assim que carregarmos os dois programas, podemos executar o monitor serial no receptor e notamos que a mensagem “Hello World” é impressa a cada segundo.
Solução de problemas
Vale a pena notar que ruído da fonte de alimentação é um dos problemas mais comuns que as pessoas enfrentam ao tentar fazer uma comunicação bem-sucedida com os módulos NRF24L01. Geralmente, circuitos de RF ou sinais de radiofrequência são sensíveis ao ruído da fonte de alimentação. Portanto, é sempre uma boa ideia incluir um capacitor de desacoplamento na linha de alimentação. O capacitor pode ser qualquer coisa de 10uF a 100uF.
Outro problema comum é que o pino de 3,3V das placas Arduino nem sempre pode fornecer energia suficiente ao módulo NRF24L01. Portanto, alimentar o módulo com uma fonte de alimentação externa também é uma boa ideia.
Comunicação sem fio bidirecional com dois NRF24L01 e Arduino
Vamos ver o segundo exemplo, uma comunicação sem fio bidirecional entre duas placas Arduino. Segue os esquemas do circuito:
Você pode obter os componentes necessários para este exemplo nos links abaixo:
- Módulo Transceptor NRF24L01…………
- Placa Arduino………………………………….
- Módulo Joystick ……………………………….
- Servomotor ……………………………………….
- Botão ………………………………………..
- LED …………………………………………………
Código-fonte nRF24L01
Aqui estão os dois códigos e sua descrição abaixo.
Código do transmissor
/*
* Arduino Wireless Communication Tutorial
* Example 2 - Transmitter Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
* Library: 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);
}
}Code language: Arduino (arduino)Código do receptor
/*
* Arduino Wireless Communication Tutorial
* Example 2 - Receiver Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
* Library: 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));
}
}Code language: Arduino (arduino)A diferença aqui do exemplo anterior é que precisamos criar dois pipes ou endereços para a comunicação bidirecional.
const byte addresses[][6] = {"00001", "00002"};Code language: Arduino (arduino)Na seção de configuração, precisamos definir os dois pipes e observar que o endereço de escrita no primeiro Arduino precisa ser o endereço de leitura no segundo Arduino e vice-versa, o endereço de leitura no primeiro Arduino precisa ser o endereço de escrita em o segundo arduino.
// at the Transmitter
radio.openWritingPipe(addresses[1]); // 00001
radio.openReadingPipe(1, addresses[0]); // 00002Code language: Arduino (arduino)// at the Receiver
radio.openWritingPipe(addresses[0]); // 00002
radio.openReadingPipe(1, addresses[1]); // 00001Code language: Arduino (arduino)Na seção de loop usando a função radio.stopListening() definimos o primeiro Arduino como transmissor, lemos e mapeamos o valor do Joystick de 0 a 180, e usando a função radio.write() enviamos os dados para o receptor.
radio.stopListening();
int potValue = analogRead(A0);
int angleValue = map(potValue, 0, 1023, 0, 180);
radio.write(&angleValue, sizeof(angleValue));Code language: Arduino (arduino)Por outro lado, usando a função radio.startListening() definimos o segundo Arduino como receptor e verificamos se há dados disponíveis. Enquanto houver dados disponíveis, vamos lê-los, salvá-los na variável “angleV” e depois usar esse valor para girar o servo motor.
radio.startListening();
if ( radio.available()) {
while (radio.available()) {
int angleV = 0;
radio.read(&angleV, sizeof(angleV));
myServo.write(angleV);
}Code language: Arduino (arduino)Em seguida, no transmissor, configuramos o primeiro Arduino como receptor e com um loop “while” vazio, esperamos pelo segundo Arduino os dados de envio, e esses são os dados para o estado do botão pressionado ou não. Se o botão for pressionado, o LED acenderá. Portanto, esses processos se repetem constantemente e ambas as placas Arduino estão constantemente enviando e recebendo dados.
Exemplo 3 – Enviando várias variáveis em um único pacote
Vamos dar uma olhada em mais um código de exemplo usando os módulos NRF24L01. Tudo continua igual aos exemplos anteriores, exceto pela forma como estruturamos e enviamos a data.
Código do transmissor
/*
Arduino Wireless Communication Tutorial
Example 1 - Transmitter Code
by Dejan Nedelkovski, www.HowToMechatronics.com
Library: 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";
// Max size of this struct is 32 bytes - NRF24L01 buffer limit
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; // Create a variable with the above structure
void setup() {
radio.begin();
radio.openWritingPipe(address);
radio.setPALevel(RF24_PA_MIN);
radio.stopListening();
}
void loop() {
// Send the whole data from the structure to the receiver
radio.write(&data, sizeof(Data_Package));
delay(500);
}Code language: Arduino (arduino)Assim, podemos criar uma estrutura que é na verdade uma coleção de vários tipos de variáveis.
// Max size of this struct is 32 bytes - NRF24L01 buffer limit
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; // Create a variable with the above structureCode language: Arduino (arduino)Devemos ter em mente que o tamanho máximo desses dados de estrutura pode ser de 32 bytes. Aqui podemos ver que incluí três variáveis do tipo byte, uma variável inteira (4 bytes), uma variável float (4 bytes) e uma String contendo quatro caracteres (4 bytes). Isso é um total de 15 bytes.
Código do receptor
/*
Arduino Wireless Communication Tutorial
Example 1 - Receiver Code
by Dejan Nedelkovski, www.HowToMechatronics.com
Library: 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";
// Max size of this struct is 32 bytes - NRF24L01 buffer limit
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; //Create a variable with the above structure
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address);
radio.setPALevel(RF24_PA_MIN);
radio.startListening();
}
void loop() {
// Check whether there is data to be received
if (radio.available()) {
radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
}
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);
}Code language: Arduino (arduino)No lado do receptor, temos que definir os mesmos dados de estrutura para poder receber os dados de entrada. Para testar se a comunicação sem fio funciona corretamente, imprimi cada variável no monitor serial.
Conclusão
O módulo NRF24L01 é uma ótima opção para quando você precisa de comunicação sem fio para seu projeto Arduino. Eu já usei este módulo em muitos dos meus projetos Arduino.
Aqui vou listar todos os meus projetos em que usei esses módulos.
- Controle sem fio do carro robô Arduino usando os módulos de transceptor HC-05 Bluetooth, NRF24L01 e HC-12
- Projeto da estação meteorológica sem fio Arduino
- Transmissor RC Arduino DIY
- Arduino Ant Hexapod Robot
- Hovercraft RC baseado em Arduino DIY
- Robô de Rodas Arduino Mecanum
- Receptor RC Arduino DIY para modelos RC e projetos Arduino
- Arduino RC Avião | 100% faça você mesmo
Cada um desses projetos/tutoriais tem uma explicação detalhada de como usar o módulo NRF24L01, incluindo diagramas de circuitos, implementação de código aprimorada para melhor comunicação e assim por diante.
Meu projeto favorito é este transmissor Arduino RC personalizado. Na verdade, é um controlador RC de 14 canais que pode ser usado para controlar praticamente qualquer projeto Arduino.
Isso é tudo para este tutorial, espero que tenham gostado e aprendido algo novo. Como sempre, sinta-se à vontade para fazer qualquer pergunta na seção de comentários abaixo.
Processo de manufatura
- Como medir a qualidade do ar em OpenSensors
- Como hackear IR Remotes
- Qual é sua altura?
- JX Wave Generator
- Faça você mesmo skate de realidade virtual
- Como fazer a interface do Arduino Mega com o Módulo GPS NEO-6M
- Quão fácil é usar um termistor ?!
- Como fazer música com um Arduino
- Como usar o Modbus com Arduino
- Aqui está uma ideia:como funciona uma interface cérebro-computador