Usar o módulo NRF24L01 com o Arduino

O módulo de rádio NRF24L01 é um transceptor que permite estabelecer uma comunicação por ondas de rádio entre dois dispositivos e possibilitar a transferência de dados entre eles.

Material

• Computador
• 2 x Arduino UNO
• Cabo USB A Macho/B Macho
• 2 x NRF24L01

Princípio de funcionamento

O módulo NRF24l01 é um transceptor de baixa potência que permite a troca de dados sem o uso de cabos na faixa de radiofrequência de 2,4GHz. Ele estabelece uma comunicação eficaz entre dispositivos posicionados a distâncias médias (50 m) e em vista direta, ou seja, sem obstáculos interpostos. Para comunicar a longas distâncias ao ar livre, é preferível usar um módulo RF433 ou LoRa. Em ambientes fechados, se houver uma ou mais paredes entre o transmissor e o receptor, é melhor optar pela comunicação WiFi ou Bluetooth.

Esquema

O módulo NRF24L01 utiliza o protocolo SPI para comunicar com o microcontrolador e deve ser alimentado entre 1,9 e 3,6V. A comunicação SPI usa pinos específicos ligados da seguinte forma (lado esquerdo NRF24L01, lado direito Arduino UNO):

• Vcc (Fonte de alimentação) <-> 3V3
• CE (Reinicialização) <-> 2
• GND (Terra) <-> GND
• MOSI (Master Output Slave Input) <-> 11
• MISO (Master Input Slave Output) <-> 12
• SCK (Serial Clock) <-> 13
• CS (chip select) <-> 4

Em alguns módulos, para melhorar o alcance e a estabilidade da comunicação, é recomendado soldar um condensador entre os pinos Vcc e GND.

Código

Para gerir o módulo NRF24L01, utilizamos as bibliotecas RF24.h, nRF24L01.h e SPI.h. No código a seguir, que funciona para o master (role=0) e para o slave (role=1), definimos um nó para cada módulo, sendo um para enviar os dados e outro para recebê-los.

//Libraries
#include <RF24.h>//https://github.com/nRF24/RF24
#include <nRF24L01.h>//https://github.com/nRF24/RF24/blob/master/nRF24L01.h
#include <SPI.h>//https://www.arduino.cc/en/reference/SPI

//Parameters
byte addresses[2] [6] = {"Node1", "Node2"};
bool radioNumber  = 0;
bool role  = 0;

//Variables
int masterStatus  = 0;
byte cmd  = 0;
int slaveStatus  = 0;
unsigned long myData  = 0;

//Objects
RF24 radio(2, 4);

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  //Init radio rf24

  radio.begin();
  //radio.setChannel(125);
  radio.setPALevel(RF24_PA_LOW); // Set the PA Level low to prevent power supply related issues. RF24_PA_MAX is default.
  //radio.setDataRate(RF24_250KBPS);//(RF24_250KBPS);//(RF24_2MBPS);
  //radio.setAutoAck(1);                    // Ensure autoACK is enabled
  //radio.enableAckPayload();               // Allow optional ack payloads
  //radio.setRetries(2,15);                 // Smallest time between retries, max no. of retries
  //radio.setAddressWidth(3);
  //radio.setCRCLength(RF24_CRC_8);          // Use 8-bit CRC for performance
  //radio.setPayloadSize(16);                // Here we are sending 1-byte payloads to test the call-response speed
  //radio.printDetails();                   // Dump the configuration of the rf unit for debugging. Not working on nano



  // Open a writing and reading pipe on each radio, with opposite addresses
  if (radioNumber) {
    radio.openWritingPipe(addresses[1]);
    radio.openReadingPipe(1, addresses[0]);
  } else {
    radio.openWritingPipe(addresses[0]);
    radio.openReadingPipe(1, addresses[1]);
  }

  myData = 1.22;
  // Start the radio listening for data
  radio.startListening();
}

void loop() {
  testRF24();
}

void testRF24( ) { /* function testRF24 */
  ////Test RF24communication change radioNumber and radio to 0(receiver) or 1(transmitter)
  if (role == 1) {
    masterRole();
  } else {
    slaveRole();
  }
}

void masterRole( ) { /* function masterRole */
  ////emit data
  radio.stopListening();                                    // First, stop listening so we can talk.


  Serial.println(F("Now sending"));

  myData = micros();
  if (!radio.write( &myData, sizeof(myData) )) {
    Serial.println(F("failed"));
  }
  //Serial.print("width :  ");Serial.println(radio.R_RX_PL_WID );
  radio.startListening();                                    // Now, continue listening

  unsigned long started_waiting_at = micros();               // Set up a timeout period, get the current microseconds
  boolean timeout = false;                                   // Set up a variable to indicate if a response was received or not

  while ( ! radio.available() ) {                            // While nothing is received
    if (micros() - started_waiting_at > 200000 ) {           // If waited longer than 200ms, indicate timeout and exit while loop
      timeout = true;
      break;
    }
  }

  if ( timeout ) {                                            // Describe the results
    Serial.println(F("Failed, response timed out."));
  } else {
    // Grab the response, compare, and send to debugging spew
    radio.read( &myData, sizeof(myData) );
    myData = micros();

    // Spew it
    Serial.print(F("Sent "));
    Serial.print(myData);
    Serial.print(F(", Got response "));
    Serial.print(myData);
    //Serial.println(myData.value);
  }

  // Try again 1s later
  delay(1000);
}

void slaveRole( ) { /* function slaveRole */
  ////recieve data
  if ( radio.available()) {
    // Variable for the received timestamp
    while (radio.available()) {                          // While there is data ready
      radio.read( &myData, sizeof(myData) );             // Get the payload
    }

    radio.stopListening();                               // First, stop listening so we can talk
    Serial.print(F("Transmission "));
    Serial.println(myData);
    //myData.value += 0.01;                                // Increment the float value
    radio.write( &myData, sizeof(myData) );              // Send the final one back.
    radio.startListening();                              // Now, resume listening so we catch the next packets.
    Serial.print(F(" - Sent response "));
    Serial.println(myData);
    //Serial.print(F(" : "));
    //Serial.println();
  }
}

Aplicações

• Criar um controle remoto para controlar o seu projeto Arduino
• Troca de dados entre dois Arduinos

Fontes

• https://github.com/nRF24/RF24
• https://github.com/nRF24/RF24/blob/master/nRF24L01.h
• https://www.arduino.cc/en/reference/SPI
• Protocolos de comunicação