nRF24L01 - Comment ça marche, Interface Arduino, Circuits, Codes

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

• Module émetteur-récepteur NRF24L01………
• Carte Arduino ………………………………
• Breadboard et Jump Wires ………… 

Code Arduino et nRF24L01

Une fois que nous avons connecté les modules NRF24L01 aux cartes Arduino, nous sommes prêts à créer les codes pour l'émetteur et le récepteur.

Nous devons d'abord télécharger et installer la bibliothèque RF24, ce qui rend la programmation moins difficile. Nous pouvons également installer cette bibliothèque directement à partir du gestionnaire de bibliothèque Arduino IDE. Recherchez simplement "rf24" et trouvez et installez celui par "TMRh20, Avamander".

Voici les deux codes pour la communication sans fil et ci-dessous en est la description.

Code émetteur

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

Code du destinataire

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

Description du code

Nous devons donc inclure le SPI de base et les bibliothèques RF24 nouvellement installées et créer un objet RF24. Les deux arguments ici sont les broches CSN et CE.

RF24 radio(7, 8); // CE, CSNCode language: Arduino (arduino)

Ensuite, nous devons créer un tableau d'octets qui représentera l'adresse, ou le soi-disant tube par lequel les deux modules communiqueront.

const byte address[6] = "00001";Code language: Arduino (arduino)

Nous pouvons changer la valeur de cette adresse en n'importe quelle chaîne de 5 lettres et cela permet de choisir à quel récepteur nous parlerons, donc dans notre cas nous aurons la même adresse à la fois au récepteur et à l'émetteur.

Dans la section de configuration, nous devons initialiser l'objet radio et, à l'aide de la fonction radio.openWritingPipe(), nous définissons l'adresse du récepteur auquel nous enverrons des données, la chaîne de 5 lettres que nous avons précédemment définie.

radio.openWritingPipe(address);Code language: Arduino (arduino)

De l'autre côté, au niveau du récepteur, en utilisant la fonction radio.setReadingPipe(), nous définissons la même adresse et nous activons ainsi la communication entre les deux modules.

radio.openReadingPipe(0, address);Code language: Arduino (arduino)

Ensuite, en utilisant la fonction radio.setPALevel(), nous définissons le niveau de l'amplificateur de puissance. Dans notre cas, je le définirai au minimum car mes modules sont très proches les uns des autres.

radio.setPALevel(RF24_PA_MIN);Code language: Arduino (arduino)

Notez que si vous utilisez un niveau supérieur, il est recommandé d'utiliser des condensateurs de dérivation entre GND et 3,3 V des modules afin qu'ils aient une tension plus stable pendant le fonctionnement.

Ensuite, nous avons la fonction radio.stopListening() qui définit le module comme émetteur, et de l'autre côté, nous avons la fonction radio.startListening() qui définit le module comme récepteur.

// at the Transmitter
radio.stopListening();Code language: Arduino (arduino)

// at the Receiver
radio.startListening();Code language: Arduino (arduino)

Dans la section boucle, au niveau de l'émetteur, nous créons un tableau de caractères auquel nous attribuons le message "Hello World". En utilisant la fonction radio.write() nous enverrons ce message au récepteur. Le premier argument ici est la variable que nous voulons envoyer.

void loop() {
 const char text[] = "Hello World";
 radio.write(&text, sizeof(text));
 delay(1000);
}Code language: Arduino (arduino)

En utilisant le "&" avant le nom de la variable, nous définissons en fait une indication de la variable qui stocke les données que nous voulons envoyer et en utilisant le deuxième argument, nous définissons le nombre d'octets que nous voulons prendre de cette variable. Dans ce cas, la fonction sizeof() récupère tous les octets des chaînes "text". À la fin du programme, nous ajouterons 1 seconde de retard.

En utilisant la fonction radio.write() nous pouvons envoyer un maximum de 32 octets à la fois.

De l'autre côté, au niveau du récepteur, dans la section boucle utilisant la fonction radio.available() nous vérifions s'il y a des données à recevoir. Si c'est vrai, nous créons d'abord un tableau de 32 éléments, appelé "texte", dans lequel nous enregistrerons les données entrantes.

void loop() {
  if (radio.available()) {
    char text[32] = "";
    radio.read(&text, sizeof(text));
    Serial.println(text);
  }
}Code language: Arduino (arduino)

En utilisant la fonction radion.read(), nous lisons et stockons les données dans la variable « text ». À la fin, nous imprimons simplement du texte sur le moniteur série. Ainsi, une fois que nous avons téléchargé les deux programmes, nous pouvons exécuter le moniteur série sur le récepteur et nous remarquerons que le message "Hello World" est imprimé chaque seconde.

Dépannage

Il convient de noter que le bruit de l'alimentation est l'un des problèmes les plus courants rencontrés par les utilisateurs lorsqu'ils tentent d'établir une communication réussie avec les modules NRF24L01. Généralement, les circuits RF ou les signaux radiofréquence sont sensibles au bruit de l'alimentation. Par conséquent, c'est toujours une bonne idée d'inclure un condensateur de découplage sur la ligne d'alimentation. Le condensateur peut être n'importe quoi de 10uF à 100uF.

Un autre problème courant est que la broche 3,3 V des cartes Arduino ne peut pas toujours fournir suffisamment d'énergie au module NRF24L01. Donc, alimenter le module avec une source d'alimentation externe est également une bonne idée.

Communication sans fil bidirectionnelle avec deux NRF24L01 et Arduino

Voyons le deuxième exemple, une communication sans fil bidirectionnelle entre deux cartes Arduino. Voici les schémas du circuit :

Vous pouvez obtenir les composants nécessaires pour cet exemple à partir des liens ci-dessous :

• Module émetteur-récepteur NRF24L01…………
• Carte Arduino……………………………….
• Module manette ……………………………….
• Servomoteur …………………………………………….
• Bouton poussoir ……………………………………..
• DEL…………………………………………………………

Code source nRF24L01

Voici les deux codes et leur description ci-dessous.

Code émetteur

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

Code du destinataire

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

Ce qui est différent ici de l'exemple précédent, c'est que nous devons créer deux canaux ou adresses pour la communication bidirectionnelle.

const byte addresses[][6] = {"00001", "00002"};Code language: Arduino (arduino)

Dans la section de configuration, nous devons définir les deux canaux et noter que l'adresse d'écriture sur le premier Arduino doit être l'adresse de lecture sur le deuxième Arduino, et vice versa, l'adresse de lecture sur le premier Arduino doit être l'adresse d'écriture sur le deuxième 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)

Dans la section boucle en utilisant la fonction radio.stopListening(), nous définissons le premier Arduino comme émetteur, lisons et mappons la valeur de Joystick de 0 à 180, et en utilisant la fonction radio.write() envoyons les données au récepteur.

radio.stopListening();
int potValue = analogRead(A0);
int angleValue = map(potValue, 0, 1023, 0, 180);
radio.write(&angleValue, sizeof(angleValue));Code language: Arduino (arduino)

De l'autre côté, en utilisant la fonction radio.startListening(), nous définissons le deuxième Arduino comme récepteur et nous vérifions s'il y a des données disponibles. Tant qu'il y a des données disponibles, nous les lirons, les enregistrerons dans la variable "angleV", puis utiliserons cette valeur pour faire tourner le servomoteur.

radio.startListening();
  if ( radio.available()) {
    while (radio.available()) {
      int angleV = 0;
      radio.read(&angleV, sizeof(angleV));
      myServo.write(angleV);
    }Code language: Arduino (arduino)

Ensuite, au niveau de l'émetteur, nous définissons le premier Arduino comme récepteur et avec une boucle "while" vide, nous attendons que le deuxième Arduino envoie les données, et ce sont les données pour l'état du bouton-poussoir, qu'il soit enfoncé ou non. Si le bouton est enfoncé, la LED s'allume. Ainsi, ces processus se répètent constamment et les deux cartes Arduino envoient et reçoivent constamment des données.

Exemple 3 - Envoi de plusieurs variables dans un seul package

Examinons un autre exemple de code utilisant les modules NRF24L01. Tout reste le même que dans les exemples précédents, sauf pour la façon dont nous structurons et envoyons la date.

Code émetteur

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

Ainsi, nous pouvons créer une structure qui est en fait une collection de différents types de variables.

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

Nous devons garder à l'esprit que la taille maximale de ces données de structure peut être de 32 octets. Ici, nous pouvons voir que j'ai inclus trois variables de type octet, une variable entière (4 octets), une variable flottante (4 octets) et une chaîne contenant quatre caractères (4 octets). C'est un total de 15 octets.

Code du destinataire

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

Côté récepteur, nous devons définir les mêmes données de structure afin de pouvoir recevoir les données entrantes. Pour tester si la communication sans fil fonctionne correctement, j'ai imprimé chaque variable sur le moniteur série.

Conclusion

Le module NRF24L01 est une excellente option lorsque vous avez besoin d'une communication sans fil pour votre projet Arduino. J'ai déjà utilisé ce module dans plusieurs de mes projets Arduino.

Ici, je vais lister tous mes projets dans lesquels j'ai utilisé ces modules.

• Contrôle sans fil Arduino Robot Car utilisant les modules émetteurs-récepteurs Bluetooth HC-05, NRF24L01 et HC-12
• Projet de station météo sans fil Arduino
• Émetteur RC Arduino DIY
• Robot hexapode Fourmi Arduino
• Aéroglisseur RC basé sur Arduino DIY
• Robot Arduino Mecanum Roues
• Récepteur RC Arduino DIY pour modèles RC et projets Arduino
• Avion Arduino RC | 100 % bricolage

Chacun de ces projets/tutoriels contient une explication détaillée de l'utilisation du module NRF24L01, y compris des schémas de circuit, une implémentation de code améliorée pour une meilleure communication, etc.

Mon projet préféré est cet émetteur RC Arduino conçu sur mesure. Il s'agit en fait d'un contrôleur RC à 14 canaux qui peut être utilisé pour contrôler à peu près n'importe quel projet Arduino.

C'est tout pour ce tutoriel, j'espère que vous l'avez apprécié et appris quelque chose de nouveau. Comme toujours, n'hésitez pas à poser des questions dans la section des commentaires ci-dessous.