Le module radio nRF24L01 est un module radio permettant d’émettre et de recevoir des données sur la bande des 2,4GHz de chez Nordic Semiconductor. Il utilise la même gamme de fréquences que le Wifi et le Bluetooth mais il ne leur est pas compatible. Ainsi donc plus vous avez de Wifi et de Bluetooth  autour de vous, plus vous aurez d'interférences.

•        Fréquence de transmission

      Le nRF24L01 fonctionne dans la plage de 2,4 GHz à 2,525 GHz, par « pas » de 1 MHz. Chaque pas de 1 MHz est un canal.

•       Vitesse de transmission des données par radio

       Le nRF24 permet la transmission de données à vitesse plus ou moins rapide, selon ses besoins, et la portée que l’on souhaite atteindre. Par défaut, nous avons le choix entre trois valeurs possibles :

        - Vitesse de 250 kbps (vitesse la plus lente, qui « porte » le plus loin);

        -   Vitesse de 1 Mbps (vitesse moyenne);

        -Vitesse de 2 Mbps (vitesse la plus rapide, qui « porte » le moins loin);

Vouloir émettre à grande vitesse a un inconvénient majeur qui est, une plus faible portée de signal, et un plus grand risque d’erreurs, dues aux interférences. Il faut donc toujours adapter la vitesse de transmission de données à son besoin.

•      Mémoire du nRF24L01

       La mémoire du nRF24 est limitée à 32 octets par message, en émission comme en réception.

•      Tunnels de communication

           Tout d’abord les nRF24 sont limités à 6 canaux de communication simultanés. Mais  sur ces canaux, un seul est utilisable en émission/réception (les autres ne pouvant qu’écouter, et non émettre).

Il faut savoir que chaque tunnel à une adresse qui lui est propre. Pour que deux modules communiquent, un tunnel doit être ouvert entre eux. Cela signifie donc que l’expéditeur doit avoir un canal ouvert en écriture et que le destinataire doit avoir le même canal en lecture. Un canal unique peut être ouvert pour la lecture ou l’écriture mais pas pour la lecture et l’écriture en même temps.

•        Carte Arduino (02)
•        nRF24L01 (02)

•        Fils de connexion (14)

1. Instanciation de la bibliothèque

Pour la programmation Arduino plusieurs choix s’offre à nous. Plusieurs bibliothèques ont été éditées pour ce module.

Nous allons de ce pas utilisé la bibliothèque nRF24 dans Arduino IDE.

Pour instancier cette librairie il suffit d’inclure 02 librairies à tous vos projets, à savoir :

      La librairie SPI ; 

    La librairie NRF24;

De la manière suivante :

#include <SPI.h>

#include <RF24.h>

Définir ensuite le brochage des pins CE et CSN de la manière suivante :
#define pinCE  7
#define pinCSN  8
RF24 radio (pinCE, pinCSN);


Enfin initialiser le module dans le void setup comme suit :
void setup () {
radio.begin ();
}
   2. Sélection du canal de communication
Pour choisir le canal de communication il suffit de faire appel à la fonction setChannel () comme suit :
radio.setChannel(x); // en remplaçant « x » par une valeur comprise entre 0 et 125
0 correspond à la fréquence de 2,4GHz et 125 correspond à la fréquence de 2,525GHz.

   3.  Choix du niveau de transmission 
Le niveau de signal radio du module influencera directement sur sa portée. Vous avez ici le choix entre 04 niveaux d'émission 
du signal:
RF24_PA_MIN : pour un niveau d’émission minimal ;
RF24_PA_LOW : niveau d’émission bas ;
RF24_PA_HIGH : niveau d’émission moyen/haut ;
RF24_PA_MAX : niveau d’émission élevé ;
Le code concernant le choix du niveau de transmission doitêtre édité de la manière suivante :
radio.setPALevel (xxx);          // en remplaçant « xxx » par RF24_PA_MIN, RF24_PA_LOW
RF24_PA_HIGH, ou RF24_PA_MAX

   4.  Ouverture d’un tunnel pour l’émission


Pour envoyer des données d’un nRF à un autre il faut d’abord définir un canal d’émission et lui donner un nom sur 05 
caractères comme suit :
const byte adresse[6] = PIPE1;    // adresse de tunnel, au format "byte array"
L’ouverture du canal voulu pour l’émission du message se fait comme-ci :
radio.openWritingPipe(adresse);      // Ouverture du "tunnel1" en écriture (émission radio)
   5.  Ouverture d’un tunnel pour la réception
De la même manière que pour l’émission, il faut définir un canal pour la réception et lui donner un nom sur 05 caractères 
comme suit : 
const byte adresse[6] = PIPE2;    // adresse de tunnel, au format "byte array"
L’ouverture du canal voulu pour la réception du message se fait comme-ci :

radio.openReadingPipe(0,adresse);      // Ouverture du "tunnel1" en lecture (réception radio)

  

   6.  Définition du sens de communication
Si vous souhaitez recevoir un message à travers un canal, il va falloir utiliser la fonction « startListening ». Par contre si vous 
souhaitez émettre un message à partir du canal vous devrez utiliser la fonction « stopListening ».
Vos lignes de code devront se présenter comme suit :
radio.startListening(); // ouverture de canal pour la réception
//ou
radio.stopListening();  // ouverture de canal pourl’émission

  7. Emission et réception de données
Nous allons de ce part aborder la réception et l’émission des données. Les fonctions « read » et « write »permettent 
respectivement de lire un message reçu, ou d’envoyer un message. 
N’oubliez pas que la mémoire du nRF est limitée à 32 octets, ainsi donc les messages ne devront pas dépasser cette taille. 
Par contre vous n’êtes pas limité à l’envoi d’une seule donnée à la fois.
Voici le code pour lire un message reçu :
char message[32];
radio.startListening();

if (radio.available()) {       //On vérifie si un message est en attente de lecture
  radio.read(&message, sizeof(message));     // Si oui, on le charge dans la variable "message"
}
char message[32];
message = "Mon message à envoyer !";     //Dans la limite de 32 octets (32 caractères, ici)
radio.stopListening();
radio.write(&message, sizeof(message));             // Envoi du contenu stocké dans la variable "message"
 
  8.   Code pour l’émission du message « Hello Word !!! »

#include <SPI.h>#include <RF24.h>
#define pinCE   7             // On associe la broche "CE" du NRF24L01 à la sortie digitale D7 de l'arduino
#define pinCSN  8             // On associe la broche "CSN" du NRF24L01 à la sortie digitale D8 de l'arduino
#define tunnel  "PIPE1"       // On définit un "nom de tunnel" (5 caractères), pour pouvoir communiquer d'un NRF24 à
 l'autre
 
RF24 radio(pinCE, pinCSN);    // Instanciation du NRF24L01
 
const byte adresse[6] = tunnel;               // Mise au format "byte array" du nom du tunnel
const char message[] = "Hello World !!!";     // Message à transmettre à l'autre NRF24 (32 caractères maxi, avec cette 
//librairie)
void setup() {
  radio.begin();                      // Initialisation du module NRF24
  radio.openWritingPipe(adresse);     // Ouverture du tunnel en ÉCRITURE, avec le "nom" qu'on lui a donné
  radio.setPALevel(RF24_PA_MIN);      // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte
// puissance, pour nos essais)
  radio.stopListening();              // Arrêt de l'écoute du NRF24 (signifiant qu'on va émettre, et non recevoir, ici)
}
void loop() {
  radio.write(&message, sizeof(message));     // Envoi de notre message
delay(1000);                                // … toutes les secondes !
}

9. Code pour la réception du message

#include <SPI.h>
#include <RF24.h>

#define pinCE   7             // On associe la broche "CE" du NRF24L01 à la sortie digitale D7 de l'arduino
#define pinCSN  8             // On associe la broche "CSN" du NRF24L01 à la sortie digitale D8 de l'arduino
#define tunnel  "PIPE1"       // On définit le "nom de tunnel" (5 caractères) à travers lequel on va recevoir les données 
//de l'émetteur
RF24 radio(pinCE, pinCSN);    // Instanciation du NRF24L01

const byte adresse[6] = tunnel;       // Mise au format "byte array" du nom du tunnel
char message[32];                     // Avec cette librairie, on est "limité" à 32 caractères par message

void setup() {
  // Initialisation du port série (pour afficher les infos reçues, sur le "Moniteur Série" de l'IDE Arduino)
  Serial.begin(9600);
  Serial.println("Récepteur NRF24L01");
  Serial.println("");

  // Partie NRF24
  radio.begin();                      // Initialisation du module NRF24
  radio.openReadingPipe(0, adresse);  // Ouverture du tunnel en LECTURE, avec le "nom" qu'on lui a donné
  radio.setPALevel(RF24_PA_MIN);      // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte
 puissance, pour nos essais)
  radio.startListening();             // Démarrage de l'écoute du NRF24 (signifiant qu'on va recevoir, et non émettre quoi que
 //ce soit, ici)
}

void loop() {
  // On vérifie à chaque boucle si un message est arrivé
  if (radio.available()) {
    radio.read(&message, sizeof(message));                        // Si un message vient d'arriver, on le charge dans la variable 
//"message"
    Serial.print("Message reçu : "); Serial.println(message);     // … et on l'affiche sur le port série !
  }
}

Un peu plutôt vous avez appris comment établir la communication entre deux modules de façon unidirectionnelle. Ici vous allez apprendre la communication entre plusieurs modules de façon multidirectionnelle. Il faut que vous sachiez qu’ici il faut créer un réseau comme le réseau wifi dans lequel chaque module aura son adresse. Les modules sont reliés entre eux de manière ordonnée, suivant une arborescence comme suit :

Les points suivants vous seront indispensables pour la suite.

-      Il y a un seul module nRF maître, c’est celui avec l’adresse 0 ;

-      Chaque module peut avoir jusqu’à cinq (05) modules enfants sous lui ;

-      On est limité à cinq (05) niveaux d’arborescences ainsi l’on peut avoir au maximum 781 adresses ;

-      Chaque adresse est écrite au format octal ;

-      Un nombre octal est écrit avec un « 0 » devant, (00 veut dire 0 en format octal) ; 

-      L’adresse de la base est 00 ;

-      Les adresses enfants de la base sont 01 à 05 ;

-      Les adresses enfants de 01 sont 011 à 051 ;

-      La communication entre les nœuds 011 et 02 devra passer respectivement par 01 et 00 ;

   1.  Instanciation de la bibliothèque

En plus des deux premières bibliothèques citées plus haut il faut inclure la bibliothèque RF24Network de la manière suivante :

#include <RF24Network.h>

Ensuite il faudra créer l’objet RF24 et l’inclure dans l’objet RF24Network de la manière suivante :
RF24 radio(7,8);
RF24Network network(radio);
Et pour finir définir l’adresse du module parent et aussi de
tous ses modules enfants de la manière suivante par exemple :
const uint16_t node00 = 00;
const uint16_t node01 = 01;


  2. Sélection du canal de communication

La sélection se fait entre 0 et 125 et même temps quel’adresse du module parent de la façon suivante :        
network.begin(90,node00);

Tout d’abord dans le void loop il faut appeler la fonction update
à travers laquelle toutes les actions sont faites.

network.update();
Envoi d'un message
Il faut créer l’objet RF24NetworkHeader qui prend en paramètre l’adresse du module destinataire. L’envoi du message se fait
ensuite par la fonction write comme suit par
exemple : 
RF24NetworkHeader header(node01);
  const char text[] = "Hello";
  network.write(header, &text, sizeof(text));


        Réception d’un message
        Pour recevoir un message il faut recréer l’objet RF24NetworkHeader dans le code d’envoi sans le passage 
d’une adresse en paramètre. La réception se fait ensuite par la fonction read après avoir vérifié la présence du 
message envoyé dans la mémoire du module par la fonction available comme suit par exemple :
while(network.available()){
    RF24NetworkHeader headern; 
 char text1[32] = "";
    network.read(headern, &text1, sizeof(text1));


      Réception de messages venant de plusieurs NRF
Il faut créer l’objet
RF24NetworkHeader dans le code de réception sans le passage d’une adresse en
paramètre. La réception se fait par la fonction read après avoir vérifié la présence du message envoyé dans la
mémoire du module par la fonction available
toujours de la manière suivante :

NB : char et text1 sont respectivement le type et le nom de la variable choisie ici.
Ensuite vérifier à chaque fois la provenance du message avec l’instruction suivante :
If(headern.from_node==address){
Instruction


NB : address est l’adresse  du module émettant le message en format décimal.

Les matériels et le câblage sont pareils que dans le chapitre précédent.

Ici nous allons mettre en réseau deux modules qui seront à la
fois émetteur et récepteur. Le nœud 00 enverra le message 
« Hello » au nœud 01 qui l’affichera dans le moniteur série. A la
réception le nœud 01 enverra à son tour un message « Word » au nœud
01 qui l’affichera aussi dans le moniteur série.

1.    Code côté nœud 00

# include <RF24.h>

# include <RF24Network.h>

# include <SPI.h>

RF24 radio(7,8);

RF24Network network(radio);

const uint16_t node00 = 00;

const uint16_t node01 = 01;

void setup() {

  SPI.begin();

  radio.begin();

  Serial.begin(9600);

  radio.setPALevel(RF24_PA_MIN);        

  radio.setDataRate(RF24_250KBPS);

  network.begin(90, node00);

}

void loop() {

  network.update();

  RF24NetworkHeader header(node01);

  const char text[] = "Hello";

  network.write(header, &text, sizeof(text));

  Serial.println("Sent");

  delay(5);

  while(network.available()){

    RF24NetworkHeader headern;

    char text1[32] = "";

    network.read(headern, &text1, sizeof(text1));

    Serial.println(text1);

  }

}

2.    Code côté nœud 01

          Code côté nœud 00

# include <RF24.h>

# include <RF24Network.h>

# include <SPI.h>

RF24 radio(7,8);

RF24Network network(radio);

const uint16_t node00 = 00;

const uint16_t node01 = 01;

void setup() {

  SPI.begin();

  radio.begin();

  Serial.begin(9600);

  radio.setPALevel(RF24_PA_MIN);        

  radio.setDataRate(RF24_250KBPS);

  network.begin(90, node01);

}

void loop() {

  network.update();

  while(network.available()){

    RF24NetworkHeader header;

    char text[32] = "";

    network.read(header, &text, sizeof(text));

    Serial.println(text);

  }

  delay(5);

  network.update();

  RF24NetworkHeader headern(node00);

  const char text1[] = "World";

  network.write(headern, &text1, sizeof(text1));

  Serial.println("Sent");

  delay(5);

}