Réseau sans fil Arduino avec plusieurs modules NRF24L01

Dans ce tutoriel, nous allons apprendre à construire un réseau sans fil Arduino, composé de plusieurs modules émetteurs-récepteurs NR24L01. Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous.

Aperçu

À titre d'exemple, j'ai créé un réseau de 5 nœuds et chacun d'eux peut communiquer avec n'importe quel nœud du réseau et en même temps, ils peuvent fonctionner à la fois comme émetteurs et récepteurs. Cet exemple est en fait configuré d'une manière qui explique comment créer un réseau beaucoup plus grand, ou pour être précis, nous pouvons avoir un total de 3125 modules communiquant entre eux sur un seul canal RF. Voyons donc comment cela fonctionne.

Dans mes précédents tutos nous avons déjà appris à faire une communication sans fil entre deux cartes Arduino en utilisant les modules NRF24L01 et la librairie RF24. Maintenant, en plus de cette bibliothèque, nous allons utiliser la bibliothèque RF24Network, qui permet de construire facilement un réseau sans fil Arduino avec de nombreuses cartes communiquant entre elles. Voici comment fonctionne la topologie du réseau.

Communication de plusieurs modules NRF24L01

Un seul module NRF24L01 peut écouter activement jusqu'à 6 autres modules en même temps.

Cette capacité est utilisée par la bibliothèque RF24Network pour générer un réseau organisé dans une topologie arborescente, où un nœud est la base et tous les autres nœuds sont les enfants de ce nœud ou d'un autre. Chaque nœud peut avoir jusqu'à 5 enfants, et cela peut aller jusqu'à 5 niveaux de profondeur, ce qui signifie que nous pouvons créer un réseau de 3125 nœuds au total. Chaque nœud doit être défini avec une adresse de 15 bits, qui décrit précisément la position du nœud dans l'arborescence.

Nous pouvons en fait définir les adresses des nœuds au format octal. Ainsi, l'adresse du maître ou de la base est 00, les adresses enfants de la base sont 01 à 05, les adresses enfants du nœud 01 sont 011 à 051 et ainsi de suite.

Notez que si le nœud 011 veut parler au nœud 02, la communication devra passer par le nœud 01 et le nœud de base 00, donc ces deux nœuds doivent être actifs tout le temps pour que la communication réussisse.

Contrôle de servomoteur sans fil Arduino à l'aide de la bibliothèque RF24Network

Avant d'expliquer l'exemple principal de ce tutoriel, pour mieux comprendre le fonctionnement de la bibliothèque, faisons un exemple plus simple de deux cartes Arduino communiquant entre elles. Voici le schéma de circuit pour cet exemple.

Vous pouvez obtenir les composants nécessaires pour ce didacticiel Arduino à partir des liens ci-dessous :

Module émetteur-récepteur NRF24L01………..
Servomoteur ……………………………………
Potentiomètre ………………………………..
Arduino Nano………………………………..

Ainsi, en utilisant le potentiomètre du premier Arduino, nous contrôlerons le servomoteur du deuxième Arduino. Jetons un coup d'œil aux codes sources maintenant.

Voici le code côté potentiomètre :

/*
  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)

Nous devons d'abord inclure les deux bibliothèques RF24 et RF24Network, ainsi que la bibliothèque SPI. Ensuite, nous devons créer l'objet RF24 et l'inclure dans l'objet RF24Network. Ici, nous devons définir les adresses des nœuds au format octal, soit 00 pour ce nœud, et 01 pour l'autre nœud côté servo.

Dans la section de configuration, nous devons initialiser le réseau en définissant le canal et l'adresse de ce nœud.

Dans la section de la boucle, nous devons constamment appeler la fonction update () à travers laquelle toutes les actions du réseau se produisent. Ensuite on lit la valeur du potentiomètre et on la convertit en une valeur de 0 à 180 qui convient à l'asservissement. Ensuite, nous créons un en-tête de réseau où nous attribuons l'adresse du nœud où vont les données. À la fin, en utilisant la fonction write(), nous envoyons les données à l'autre nœud. Donc, ici, le premier paramètre contient les informations sur les adresses, le deuxième paramètre indique quelles données seront envoyées et le troisième paramètre est la taille des données.

Voici le code côté 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)

De l'autre côté, au niveau du servomoteur, nous devons définir les bibliothèques et les objets de la même manière qu'expliqué précédemment. Ici, l'adresse de ce nœud au format octal est 01. Après avoir défini le servomoteur, dans la section boucle, en utilisant la boucle while() et la fonction available() nous vérifions constamment s'il y a des données entrantes. Si vrai, nous créons un en-tête de réseau à travers lequel les données seront acceptées et également une variable où les données seront stockées. Ensuite, en utilisant la fonction read(), nous lisons les données et les stockons dans la variable entrantData. À la fin, nous utilisons ces données pour déplacer le servomoteur en fonction du potentiomètre de l'autre nœud.

Réseau sans fil Arduino avec plusieurs modules NRF24L01

Après avoir compris cet exemple, nous pouvons passer à l'exemple principal de ce tutoriel et construire un réseau sans fil de 5 Arduinos communiquant entre eux. Voici un schéma fonctionnel de l'exemple.

Donc à partir de la base, à l'aide d'un potentiomètre on va contrôler le servomoteur au noeud 01, avec le deuxième potentiomètre on va contrôler les LED au noeud 022, à l'aide du bouton on va contrôler la LED au noeud 012, et la LED ici à la base sera contrôlée à l'aide du potentiomètre au nœud 02. En utilisant également le capteur infrarouge au nœud 012, nous contrôlerons la LED au nœud 01. Nous pouvons donc remarquer que cet exemple explique comment transmettre et recevoir des données en même temps, ainsi que la façon de communiquer avec les nœuds de différentes branches. Jetons un coup d'œil aux codes Arduino maintenant.

Connexe : Émetteur RC Arduino DIY

Code source en 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)

Ainsi, à la base ou au nœud maître, nous devons définir les bibliothèques et les objets comme expliqué précédemment, et également définir tous les autres nœuds auxquels le maître enverra des données. Dans la section boucle, nous commençons par vérifier constamment s'il y a des données entrantes. Si tel est le cas, nous lisons les données, les stockons dans la variable entrantData et les utilisons pour contrôler la luminosité de la LED. Ces données proviennent en fait du potentiomètre du nœud 02. Si nous jetons un coup d'œil à son code, nous pouvons remarquer que la configuration est à peu près la même. L'important est d'attribuer la bonne adresse à l'endroit où nous voulons envoyer des données. Dans ce cas, c'est le maître 00. Ainsi, après avoir lu la valeur du potentiomètre et l'avoir convertie en une valeur PWM appropriée de 0 à 255, nous envoyons ces données au maître. On peut remarquer ici que j'ai utilisé la fonction millis() pour envoyer les données à intervalles de 10 millisecondes.

Code source du nœud 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)

Ensuite, depuis le maître, nous envoyons les données du potentiomètre au nœud 01 pour contrôler le servomoteur.

Code source du nœud 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)

Le nœud 01 reçoit en fait des données de deux nœuds différents, l'un pour la servocommande et l'autre pour le contrôle de la LED qui provient du capteur infrarouge du nœud 012.

Code source du nœud 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)

Dans un tel cas, nous utilisons l'attribut header.from_node afin d'obtenir des informations sur le nœud d'où proviennent les données. Dans le cas où les données entrantes proviennent du maître, nous l'utilisons pour contrôler le servo, et dans le cas où les données entrantes proviennent du nœud 012, nous l'utilisons pour contrôler la LED.

Au nœud 012, nous avons à la fois la transmission et la réception. Le capteur infrarouge contrôle la LED mentionnée précédemment au nœud 01 et la LED ici est contrôlée à partir du bouton du maître.

Code source du nœud 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)

Enfin, les LED du nœud 022 sont contrôlées à l'aide des données provenant de l'autre potentiomètre du maître.

Donc, pour résumer, si tout est correctement connecté et que tous les nœuds sont actifs tout le temps, notre travail se résume à adresser précisément les nœuds et tout le travail lourd derrière est effectué par l'incroyable bibliothèque RF24Network.

Donc ce serait tout, j'espère que vous avez apprécié ce projet Arduino et appris quelque chose de nouveau. N'hésitez pas à poser des questions dans la section des commentaires ci-dessous.

Bras de robot DIY Arduino avec contrôle par smartphone Projet de station météo sans fil Arduino