Rede sem fio Arduino com vários módulos NRF24L01

Neste tutorial vamos aprender a construir uma rede sem fio Arduino, composta por vários módulos transceptores NR24L01. Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo.

Visão geral

Como exemplo fiz uma rede de 5 nós e cada um deles pode se comunicar com qualquer nó da rede e ao mesmo tempo podem funcionar como transmissores e receptores. Este exemplo está realmente configurado de uma forma que explica como fazer uma rede muito maior, ou para ser mais preciso, podemos ter um total de 3125 módulos se comunicando entre si em um único canal de RF. Então vamos ver como funciona.

Nos meus tutoriais anteriores já aprendemos como fazer uma comunicação sem fio entre duas placas Arduino usando os módulos NRF24L01 e a biblioteca RF24. Agora além desta biblioteca, vamos utilizar a biblioteca RF24Network, que possibilita de forma fácil construir uma rede sem fio Arduino com várias placas comunicando entre si. Veja como a topologia de rede funciona.

Comunicação de vários módulos NRF24L01

Um único módulo NRF24L01 pode escutar ativamente até 6 outros módulos ao mesmo tempo.

Essa capacidade é utilizada pela biblioteca RF24Network para gerar uma rede organizada em uma topologia de árvore, onde um nó é a base e todos os outros nós são filhos desse nó ou de outro. Cada nó pode ter até 5 filhos, e isso pode atingir 5 níveis de profundidade, o que significa que podemos criar uma rede com um total de 3125 nós. Cada nó deve ser definido com um endereço de 15 bits, que descreve com precisão a posição do nó dentro da árvore.

Na verdade, podemos definir os endereços dos nós em formato octal. Assim, o endereço do mestre ou da base é 00, os endereços dos filhos da base são de 01 a 05, os endereços dos filhos de 01 nó são de 011 a 051 e assim por diante.

Note que se o nó 011 quiser falar com o nó 02, a comunicação terá que passar pelo nó 01 e pelo nó base 00, então esses dois nós devem estar ativos o tempo todo para que a comunicação seja bem sucedida.

Controle de servo motor sem fio do Arduino usando a biblioteca RF24Network

Antes de explicarmos o exemplo principal deste tutorial, para entender melhor como a biblioteca funciona vamos fazer um exemplo mais simples de duas placas Arduino se comunicando. Aqui está o diagrama de circuito para este exemplo.

Você pode obter os componentes necessários para este tutorial do Arduino nos links abaixo:

Módulo Transceptor NRF24L01………..
Servomotor ……………………………………
Potenciômetro …………………………………..
Arduino Nano …………………………………..

Assim, usando o potenciômetro no primeiro Arduino, controlaremos o servo motor no segundo Arduino. Vamos dar uma olhada nos códigos-fonte agora.

Aqui está o código no lado do 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)

Primeiro precisamos incluir as bibliotecas RF24 e RF24Network, bem como a biblioteca SPI. Em seguida, precisamos criar o objeto RF24 e incluí-lo no objeto RF24Network. Aqui precisamos definir os endereços dos nós em formato octal, ou 00 para este nó, e 01 para o outro nó do lado servo.

Na seção de configuração, precisamos inicializar a rede, definindo o canal e o endereço deste nó.

Na seção de loop, precisamos constantemente chamar a função update() através da qual todas as ações na rede acontecem. Em seguida, lemos o valor do potenciômetro e o convertemos em um valor de 0 a 180 adequado para o servocontrole. Em seguida, criamos um cabeçalho de rede onde atribuímos o endereço do nó para onde os dados estão indo. No final, usando a função write() enviamos os dados para o outro nó. Então aqui o primeiro parâmetro contém as informações de endereços, o segundo parâmetro aponta quais dados serão enviados e o terceiro parâmetro é o tamanho dos dados.

Aqui está o código no lado do 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 outro lado, no servo motor, precisamos definir as bibliotecas e os objetos da mesma forma que explicamos anteriormente. Aqui o endereço deste nó em formato octal é 01. Após definir o servo motor, na seção de loop, usando o loop while() e a função available() verificamos constantemente se há algum dado de entrada. Se true, criamos um cabeçalho de rede através do qual os dados serão aceitos e também uma variável onde os dados serão armazenados. Em seguida, usando a função read(), lemos os dados e os armazenamos na variável entryData. Ao final utilizamos esses dados para movimentar o servo motor de acordo com o potenciômetro do outro nó.

Rede sem fio Arduino com vários módulos NRF24L01

Depois de entender este exemplo podemos seguir com o exemplo principal deste tutorial e construir uma rede sem fio de 5 Arduinos comunicando-se entre si. Aqui está um diagrama de blocos do exemplo.

Então da base, usando um potenciômetro vamos controlar o servo motor no nó 01, com o segundo potenciômetro vamos controlar os LEDs no nó 022, usando o botão vamos controlar o LED no nó 012, e o LED aqui no a base será controlada usando o potenciômetro no nó 02. Também usando o sensor infravermelho no nó 012 vamos controlar o LED no nó 01. Assim podemos notar que este exemplo explica como transmitir e receber dados ao mesmo tempo, bem como comunicar-se com nós de diferentes ramificações. Vamos dar uma olhada nos códigos do Arduino agora.

Relacionado: Transmissor RC Arduino DIY

Código-fonte de 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)

Portanto, na base ou no nó mestre precisamos definir as bibliotecas e os objetos conforme explicado anteriormente, e também definir todos os outros nós para os quais o mestre enviará dados. Na seção de loop, começamos verificando constantemente se há algum dado de entrada. Em caso afirmativo, lemos os dados, armazenamos na variável entryData e usamos para controlar o brilho do LED. Esses dados na verdade estão vindo do potenciômetro do nó 02. Se dermos uma olhada em seu código, podemos notar que a configuração é praticamente a mesma. O importante é atribuir o endereço certo para onde queremos enviar os dados. Nesse caso, esse é o mestre 00. Então, depois de ler o valor do potenciômetro e convertê-lo em valor PWM adequado de 0 a 255, enviamos esses dados para o mestre. Podemos notar aqui que usei a função millis() para enviar os dados em intervalos de 10 milissegundos.

Código-fonte do nó 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)

Em seguida, a partir do mestre, enviamos os dados do potenciômetro para o nó 01 para controle do servo motor.

Código-fonte do nó 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)

O nodo 01 está na verdade recebendo dados de dois nodos diferentes, um para o servocontrole e outro para o controle do LED que vem do sensor infravermelho do nodo 012.

Código-fonte do nó 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)

Nesse caso, usamos o atributo header.from_node para obter informações de qual nó os dados vêm. Caso os dados de entrada sejam do mestre, usamos para controlar o servo, e caso os dados de entrada sejam do nó 012, usamos para controlar o LED.

No nó 012 temos transmissão e recepção. O sensor infravermelho controla o LED mencionado anteriormente no nó 01 e o LED aqui é controlado pelo botão no mestre.

Código-fonte do nó 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)

Por fim, os LEDs no nó 022 são controlados usando os dados provenientes do outro potenciômetro do mestre.

Então, para resumir, se tudo estiver conectado corretamente e todos os nós estiverem ativos o tempo todo, nosso trabalho se resume a apenas endereçar precisamente os nós e todo o trabalho pesado por trás é realizado pela incrível biblioteca RF24Network.

Então isso seria tudo, espero que você tenha gostado deste projeto Arduino e aprendido algo novo. Sinta-se à vontade para fazer qualquer pergunta na seção de comentários abaixo.

Braço de robô DIY Arduino com controle de smartphone Projeto de estação meteorológica sem fio Arduino