Tuto NRF24L01 : Code Arduino, Librairie, Fonctionnement, …

Envie de faire communiquer des Arduino entre eux ? Ou de commander un drone fait-maison ? Alors rien de tel qu’un émetteur/récepteur NRF24L01 pour y arriver ! Car avec lui, vous pourrez transmettre des informations par radio, sur la bande des 2,4 GHz, le plus simplement du monde ! C’est d’ailleurs ce que nous allons voir ici, dans ce tuto 😉

Mais avant tout, nous allons tout d’abord passer en revue toutes les caractéristiques du NRF24L01 (version + et PA LNA), afin de pouvoir vous en servir correctement dans vos futures applications. Par ailleurs, ce tutorial vous montrera comment vous servir de la librairie « nRF24 », disponible dans le gestionnaire de bibliothèque de l’IDE Arduino.

Bonjour, et bienvenue sur le site Passion Electronique !📜 Recevoir la Newsletter !

Nous verrons ensuite comment réaliser des émissions et réceptions de données de différentes manières, allant du simple « Hello World » en passant par l’échange de données croisées entre arduino (en quasi « full duplex »), pour arriver à la construction d’un « réseau arborescent », avec la librairie « NRF24 Network ». En bref, que des applications pratiques vraiment sympas, pour apprendre facilement comment se servir d’un NRF24L01 !

Nota : n’étant pas expert en la matière, il se peut qu’il y ait quelques imprécisions ou erreurs, qui se soient glissées. Si tel est le cas, n’hésitez pas à m’en faire part en bas, en zone commentaire, afin que je puisse les corriger, au besoin. N’hésitez pas également à y poser vos questions, si jamais vous avez des interrogations sur telle ou telle partie de ce tutorial ! J’y répondrais dans la mesure du possible, en fonction de mes connaissances, et dès que j’aurais le temps ! Enfin, gardez toujours à l’esprit que ce tuto s’adresse avant tout aux débutants en électronique, voulant intégrer une communication radio sans fil à leur projet, avec des NRF24L01+.

Sommaire Masquer 1. Explication rapide, concernant le NRF24 2. Caractéristiques du NRF24L01 (avec ou sans antenne) 3. Comment raccorder le NRF24L01 à l’Arduino (alimentation, bus SPI, chip select, …) 4. Librairie nRF24 (gestionnaire de bibliothèques IDE Arduino) 5. Tuto NRF24L01 : unidirectionnel (exemple « Hello World ») 6. Tuto NRF24L01 : bidirectionnel (notion de « pipe ») 7. Tutorial NRF24L01 : montage en réseau / arborescence, avec nœuds (tree mode et nodes mesh networking) 8. [Ajout] Câblage d’un NRF24 PA LNA sur Arduino Mega 9. [Ajout] Problèmes fréquents, avec les modules nRF24L01 PA LNA 10. Conclusion

Aperçu	Description	Lien achat
	Module NRF24L01 (avec antenne intégrée)
	Adaptateur d'alim (pour NRF24L01+ et version +PA+LNA)
	Module NRF24L01 + PA + LNA (avec antenne externe)

Explication rapide, concernant le NRF24

La puce nRF24 est un circuit intégré de chez Nordic Semiconductor (voir la page documentaire du nRF24L01, avec le datasheet). En fait, il s’agit ni plus ni moins que d’un module d’émission / réception radio, opérant sur la bande des 2,4 GHz (comme le WiFi, ou le Bluetooth). Mais ce qui fait toute sa beauté, c’est qu’il se pilote le plus simplement du monde. En effet, un simple petit Arduino permet d’en prendre le contrôle, via le port SPI.

Sachez que le nRF24 est décliné en 2 versions courantes, actuellement :

• Le nRF24L01+, avec son antenne intégrée au PCB (reconnaissable avec ses pistes de cuivre en zigzag)
• Le nRF24L01+ PA LNA, avec son antenne externe (raccordable avec un connecteur à visser, type SMA)

Comme vous vous en doutez : la version avec antenne intégrée sera moins performante (ou aura moins de portée, si vous préférez) que la version avec antenne externe. Bien entendu, suivant les applications que vous envisagerez d’en faire, un modèle sera plus avantageux que l’autre. Histoire de vous donner quelques repères, voici les portées approximatives, que l’on peut atteindre avec ces modules NRF24L01, dans la pratique :

Aperçu	Modèle	Portée en milieu « clos »	Portée « en plein air »
	NRF24L01+	~ 25 m	~ 50 m
	NRF24L01+ PA LNA	~ 50 m	~ 400 m

À noter qu’en théorie, sous certaines conditions (terrain dégagé, sans perturbateurs à proximité, …), on pourrait communiquer jusqu’à 800 mètres, voir 1,1 kilomètres. Mais en pratique, les conditions idéales ne sont pas toujours réunies. C’est pourquoi je vous ai mis, dans le tableau ci-dessus, des valeurs plus « sécures », afin d’avoir quelque chose de réaliste. Cela étant dit, il faut savoir que ces distances sont également fonction du débit de communication. Ainsi, si vous envoyez vos données à 2 méga bits par seconde (2 Mbps), vous irez moins loin qu’à vitesse réduite, de 250 kilo bits par seconde (250 kbps), par exemple.

Sachez toutefois que le constructeur communique sur les valeurs suivantes, dans des conditions optimales :

Modèle	Distance max à 250 kbps	Distance max à 1 Mbps	Distance max à 2 Mbps
NRF24L01+ PA LNA	1100 m	750 m	520 m

Très important : ces modules nRF24 ont tendance à faire « chuter » la tension d’alimentation des Arduino, lorsque branchés directement dessus. Il faudra donc toujours rajouter un condensateur, entre les fils VCC et GND des NRF24L01, afin de stabiliser leur tension d’alimentation. Sinon, vous risquez fort vous retrouver avec des bugs de communication inexpliqués, ou des fonctionnements erratiques, dus à cela. C’est pourquoi on trouve couramment sur internet des petites cartes « intermédiaires » pour NRF24, permettant de mieux « gérer » leur alimentation.

Caractéristiques du NRF24L01 (avec ou sans antenne)

Ici, nous allons voir une à une les principales caractéristiques du NRF24L01+ (avec antenne intégrée) et du NRF24L01+ PA LNA (avec antenne externe). Nous verrons : la fréquence d’utilisation (canaux), la vitesse de pilotage via arduino (dataRate), le niveau d’émission, les tensions d’alimentation et de communication, … et j’en passe. Comme vous l’aurez compris, il y aura pas mal de choses à voir ici !

Nota : aussi « chiant » que tout cela puisse paraître, il est presque indispensable de bien comprendre toute cette partie, pour savoir comment vraiment utiliser un NRF24 correctement. Mon conseil : lisez-le au moins une fois pour retenir les principales notions, et revenez-y au une autre fois, ultérieurement, lorsque vous aurez besoin de vraiment renforcer certaines de ces connaissances théoriques. Ainsi, tout cela vous semblera moins pénible 😉

Fréquence de transmission (2,4 GHz et plus)

Le NRF24L01 est prévu pour fonctionner dans la plage de 2,4 GHz à 2,525 GHz, par « pas » de 1 MHz. Chaque pas de 1 MHz est ce qu’on appelle ici un canal. Du coup, on dispose ici de 126 canaux, permettant de communiquer sur la fréquence de notre choix, entre 2,4 à 2,525 MHz.

N° du canal	Fréquence de transmission
Canal 0	2,4 GHz
Canal 1	2,401 GHz
Canal 2	2,402 GHz
…	…
Canal 124	2,524 GHz
Canal 125	2,525 GHz

À noter qu’il y a d’autres appareils qui peuvent émettre ou recevoir sur ces fréquences. Je pense notamment au Bluetooth et au WiFi, qui eux aussi fonctionnent dans la bande des 2,4 GHz. Du coup, il s’agira d’ajuster la fréquence de communication de vos nRF24, en fonction des appareils environnants, si besoin est.

Concernant le WiFi, il couvre usuellement les fréquences allant de 2,412 GHz à 2,484 GHz. Ceci nous laisse donc de la « place », entre 2,485 et 2,525 GHz pour communiquer sans risque d’interférences avec lui.

Concernant le Bluetooth, il en va de même. En effet, les fréquences comprises entre 2400 MHz et 2483,5 MHz peuvent être utilisées, nous laissant donc « le champ libre » entre 2484 MHz et 2525 MHz.

Le saviez-vous ? Même si vous êtes sur une fréquence « libre », il ne vaut mieux pas coller son émetteur récepteur NRF24L01 à proximité de sa box internet WiFi, ou de toute autre clé ou appareil Bluetooth ! Sinon, gare aux interférences et aux fonctionnements aléatoires !

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 de 2 Mbps (vitesse la plus rapide, qui « porte » le moins loin)

Ces valeurs sont exprimées en kbps (kilo bits par seconde), ou Mbps (méga bits par seconde).

Et comme indiqué précédemment, vouloir émettre à grande vitesse a un inconvénient majeur : 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, et ne pas chercher à aller trop vite !

Niveau du signal

Autre paramètre ajustable avec les puces nRF24L01 : le niveau de signal. En fait, vous aurez le choix entre plusieurs puissances d’émission possibles, allant de très faible, à particulièrement fort. Et le fait d’avoir une antenne intégrée ou une antenne externe fera toute la différence, si vous cherchez à porter loin.

À noter également que certains nRF24 sont dotés d’amplificateur, noté « PA ». Ainsi, si vous voyez marqué « NRF24L01 PA LNA » sur votre module radio, alors vous saurez qu’il s’agit là d’un modèle avec amplificateur de puissance de signal (PA signifiant « Power Amplification »). Accompagné de la mention LNA, signifiant « Low Noise Amplifier », vous aurez là un des meilleurs émetteurs récepteurs qui soit, car hyper puissant, tout en étant le moins sensible possible aux perturbations environnantes.

Concernant notre NRF24L01, voici des valeurs de rapport de puissance que j’ai pu trouver :

Niveau de signal	nRF24L01+	nRF24L01+ PA	nRF24L01+ PA LNA
MINIMAL (min)	-18 dBm	-12 dBm	-6 dBm
BAS (low)	-12 dBm	-4 dBm	0 dBm
HAUT (high)	-6 dBm	1 dBm	3 dBm
MAXIMAL (max)	0 dBm	4 dBm	7 dBm

Pour rappel, le « dBm » est en quelque sorte un comparateur de puissance, faisant le rapport entre une puissance mesurée et 1 milliwatt. Ainsi :

• 0 dBm correspond à une puissance de 1 milliwatt (soit 1 mW, ou encore, 0,001 W)
• Une augmentation de 3 dB correspond à un doublement de la puissance (soit 2 mW)
• Une diminution de 3 dB correspond à une division de la puissance par deux (soit 0,5 mW)

Bien entendu, si vous souhaitez monter en puissance, faites très attention à ce que votre alimentation soit suffisamment puissante, et bien stabilisée. Sinon, vous risquez de voir apparaître des bugs ou problèmes de communication, comme c’est le cas lorsqu’on essaye d’alimenter ses montages directement sur le 3,3 volts des Arduino.

Enfin, dites vous que côté consommation, le niveau de puissance va forcément influer sur le courant consommé. En effet :

• Un NRF24L01+ consomme environ 14 mA en émission
• Un NRF24L01+ PA LNA peut facilement monter à 140 mA, en transmission

Bien sûr, ce ne sont ici que quelques chiffres indicatifs, qui en réalité seront à pondérer, en pratique (car également fonctions de la quantité de données échangées et de la vitesse d’échange, en plus de l’amplification de puissance).

Mémoire du NRF24L01+ : limite à 32 octets par message

Petite parenthèse au sujet de la mémoire intégrée au nRF24L01 : cette puce n’intègre que 32 octets de mémoire, en émission comme en réception, et par canaux (sachant qu’un nRF24 peut gérer jusqu’à 6 canaux de communication simultanément). C’est pourquoi vous verrez souvent des variables limitées à 32 caractères dans les codes de programmes arduino.

Cela peut sembler limité, voire très faible, mais la plupart du temps, c’est « largement » suffisant. Car en gérant bien les choses, on peut aisément envoyer des infos de commande, mesure, ou télémétrie, sans problème ! Qui plus est, rien n’empêche d’envoyer plusieurs messages à la suite, pour compléter l’envoi de données 😉

Tunnels de communication (« Pipe ») : sens de communication, et adressage

Comme évoqué précédemment, les nRF24 sont limités à 6 canaux de communication simultanés. Ceux-ci s’appellent des « pipe », en anglais (pour ma part, je les appelle des « tunnel » de communication).

Basiquement, un nRF24 ne peut communiquer qu’avec 6 autres nRF24 au maximum (mais nous verrons comment dépasser cette limite en fin d’article, en créant un réseau de NRF24L01). Mais attention, car sur ces 6 pipes, un seul est utilisable en émission/réception (les autres ne pouvant qu’écouter, et non émettre).

Par ailleurs, il faut savoir que chaque pipe aura une adresse qui lui est propre, codée sur 5 octets (40 bits). Mais que seuls 2 pipes sur 6 sont encodés sur 5 octets. Car les 4 autres pipes n’auront qu’une « adresse » à un octet, qui seront en fait complétés avec quatre premiers octets pris sur le second pipe. Vous n’avez rien compris ? Ne vous inquiétez pas, car tout se résume avec le tableau suivant :

N° du pipe	Nom du pipe	Peut émettre ?	Peut recevoir ?	Taille de l’adresse
1	PIPE0	X	X	5 octets (40 bits)
2	PIPE1	X	5 octets (40 bits)
3	PIPE2	X	1 octet*
4	PIPE3	X	1 octet*
5	PIPE4	X	1 octet*
6	PIPE5	X	1 octet*

(*) les 4 octets manquants sont pris sur le PIPE1 (car les pipes 1 à 5 partagent leurs 32 premiers bits, pour arriver à 40 bits)

Un exemple pour illustrer l’adressage des pipes 2 à 5 :

• Si PIPE1 = F1F2F3F401 (5 octets)
• Si PIPE2 = 02 (1 octet)
• Et si PIPE3 = 54 (1 octet)
• Alors :
  • l’adresse de PIPE2 sera F1F2F3F402 (les 4 premiers octets de PIPE1, complétés avec « 02 »)
  • l’adresse de PIPE3 sera F1F2F3F454 (les 4 premiers octets de PIPE1, complétés avec « 54 »)

Tout cela vous semble compliqué ? Hum… effectivement, ça l’est un peu ! Mais pour faire simple, dites vous simplement que vous avez la liberté de choisir l’adresse qui vous plait entre 0000 et FFFF pour les PIPE0 et PIPE1, et que pour les autres, ce sera en fonction de PIPE1. Tout simplement 😉

Le saviez-vous ? Chaque tunnel peut prendre le nom qu’il veut (ou presque !), dans la limite de 5 caractères alphanumérique (d’un octet chacun). Par exemple, vous pourriez très bien choisir les noms d’adresses suivants pour vos pipes : « 00001 », « TOTO1 », « 1Node », « ABCDE », « ZYXWV », ou encore 0xAABBCCDDEELL (en notation hexadécimale, avec le « LL » derrière, signifiant simplement qu’il s’agit d’un « très » grand nombre, dans un programme Arduino). Mais dans tous les cas, pour rappel, les PIPE2 à 5 devront avoir la même « racine » que le PIPE1 (comme vu juste avant).

Aperçu	Description	Lien achat
	Module NRF24L01 (avec antenne intégrée)
	Adaptateur d'alim (pour NRF24L01+ et version +PA+LNA)
	Module NRF24L01 + PA + LNA (avec antenne externe)

Comment raccorder le NRF24L01 à l’Arduino (alimentation, bus SPI, chip select, …)

Maintenant que nous avons vu la partie « théorique », passons à la pratique ! Ici, nous verrons en détail le brochage des modules NRF24L01+ (dans sa version « compacte », et sa version PA LNA), son alimentation (très importante, sinon vous risquez fort d’avoir des fonctionnements erratiques), et son branchement à l’arduino (que ce soit un Uno, un Nano, ou un Mega).

Brochage (NRF24L01+ pinout)

Qu’il s’agisse du « nRF24L01+ » ou du « nRF24L+01 PA LNA », ils sont tous deux équipés d’un connecteur à 8 broches. Celui-ci comprend deux choses : l’alimentation du module en lui-même, et les broches de communication, pour dialoguer avec lui.

Voici comment cela se présente pour le NRF24L01+ (version avec antenne intégrée au PCB) :

Et pour le modèle NRF24L01+ PA LNA (version avec antenne externe, raccordable sur le connecteur doré) :

Comme vous le voyez, ces deux brochages sont strictement identiques. Par contre, leur « puissance » d’alimentation sera à adapter, en fonction du niveau d’émission, et de la capacité de votre arduino à fournir de l’énergie à ce module.

Broche	Signification	Rôle
VCC	–	Alimentation du module (1,9 et 3,6 V)
GND	–	Alimentation du module (0 V)
SCK	Serial ClocK	Horloge communication SPI
MISO	Master In Slave Out	Voie de communication nRF24 -> arduino
MOSI	Master Out Slave In	Voie de communication arduino -> nRF24
CE	Chip Enable	Active le mode RX ou TX (émission / réception)
CSN	Chip Select Not	Active le module nRF24, lorsque mis à la masse (port SPI)
IRQ	Interrupt ReQuest	Permet d’interagir avec un microcontrôleur, si besoin

Alimentation électrique du module NRF24L01

Au niveau des tensions d’alimentation, chaque nRF24L01 s’alimente avec une tension comprise entre 1,9 et 3,6 V. C’est pourquoi, couramment, on l’alimente simplement avec du 3,3 V.

Mais attention, si jamais vous tirez ces 3,3 volts d’un arduino. Car les « pics » de courant des modules nRF24 risqueront fort de faire chuter cette tension, notamment au moment des émissions de données. C’est pourquoi il faudra à minima rajouter un condensateur de 10 µF, aux bornes d’alimentation du module nRF24, pour lisser sa tension.

Bien évidemment, si jamais votre puce nRF24 est configurée pour émettre à pleine puissance, alors il vaudrait mieux puiser cette énergie autre part que sur l’alim de votre arduino. L’idéal est d’ailleurs d’utiliser ces petites cartes vendues dans le commerce, permettant l’alimentation intermédiaires des NRF24L01+. Ainsi, ils pourront fonctionner sur du 3,3 volts bien stable, pour émettre correctement.

Au final, il faut donc :

• Ajouter un condensateur électrolytique, pour le lissage de la tension (10 à 100 µF, par exemple) -> idéal si la puissance d’émission est minimale
• Ou ajouter une « plaquette d’alimentation intermédiaire », spécialement conçue pour gérer l’alimentation des modules nRF24 -> indispensable si la puissance d’émission est moyenne ou élevée

Visuellement, voici les montages que vous pouvez réaliser, reflétant ces deux options d’alimentation :

Le saviez-vous ? Même si un NRF24L01+ ne peut s’alimenter qu’avec 3,6 volts tout au plus, vous pourrez toutefois fonctionner en 0V/+5V sur toutes ses autres broches. En fait, seule son alimentation doit respecter ce seuil de tension. Du coup, cela rend parfaitement compatible les modules nRF24 avec nos traditionnels Arduino Uno, Arduino Nano, ou Arduino Mega, au niveau des broches de communication.

Broches de communication à l’Arduino (SCK, MISO, MOSI, CE, CSN, et IRQ)

Au niveau du raccordement du NRF24L01+ à l’Arduino, rien de plus simple ! Car il suffit simplement de relier les broches une à une, directement. À noter toutefois que la pin IRQ est peu souvent utilisée, donc presque jamais câblée, dans les applications simples. En fait, elle n’est utilisée que si vous souhaitez vous servir d’interruption matérielle, au niveau de votre microcontrôleur, par exemple.

Bien évidemment, chaque Arduino a des ports et pins qui lui sont propres. C’est pourquoi, selon le modèle que vous utiliserez (Uno, Nano, Mega, …), les raccordements ne se feront pas sur les mêmes pins d’entrées/sorties. Mais pour faire simple, voici un tableau récapitulatif, vous montrant où brancher chaque broche du nRF24, sur votre carte microcontrôleur :

Arduino	Vcc	Gnd	SCK	MISO	MOSI	CE	CSN	IRQ
Uno/Nano	+ 3,3 V	GND	13	12	11	7	8	n.c.
Mega	+ 3,3 V	GND	52	50	51	7	8	n.c.

Nota : n.c. = non connecté

Concernant les broches CE et CSN, il y a bien d’autres endroit où vous pourriez les brancher. Je pense notamment aux broches D9 et D10, par exemple. Mais avant de faire quel que changement que ce soit, réfléchissez bien à l’usage que vous ferez des autres pins. Par exemple, si vous utilisez un servomoteur piloté via ondes radios avec un nRF24L01+, sachez que la librairie « servo.h » qui permet de les piloter ne permet pas de les brancher sur n’importe quelles broches. Et justement, ceux-ci ne peuvent être « attachés » qu’aux bornes 9 et 10 d’un arduino uno, ou arduino nano. Comme quoi, il faut toujours lister tous ses besoins, avant d’attribuer telle ou telle pin d’entrée ou sortie à tel ou tel périphérique !

Image	Description	Lien
	Caméra WiFi extérieur, pour vidéosurveillance(modèle double, avec partie fixe + mobile 360°)	Voir le prix

Librairie nRF24 (gestionnaire de bibliothèques IDE Arduino)

Dans cette section, je vais vous parler d’une librairie déjà toute prête, et disponible dans le « Gestionnaire de Bibliothèques » de l’IDE Arduino. Il s’agit de la librairie NRF24 (voir lien github nRF24 library). Celle-ci contient tout ce dont nous avons besoin pour contrôler les échanges entre nos arduino et nos modules NRF24L01+, et ce, en toute simplicité. Nous verrons ici comment initialiser ce dernier, et les principaux paramétrages possibles. Alors, en avant !

La librairie utilisée, pour piloter le NRF24L01+

Avant tout, il sera nécessaire d’installer la librairie nRF24, disponible dans le gestionnaire de bibliothèque, de votre IDE Arduino. Pour cela, il vous suffit d’ouvrir cette fenêtre (depuis Arduino IDE -> Menu Outils -> Gérer les bibliothèques), et de taper NRF24 dans la zone de recherche.

Ensuite, il ne vous restera plus qu’à sélectionner le package ayant comme sous-titre « by TMRh20 », et de cliquer sur « Installer » (attention à ne pas vous tromper avec tous les autres noms de package, comme le nRF24 Ethernet, ou le nRF24 Network, qui sont seulement complémentaires, et prévu pour d’autres usages). Voici d’ailleurs ce que vous devriez avoir à l’écran, avec le « bon » package visible au milieu :

Au niveau de la documentation de cette librairie NRF24, vous trouverez tout plein d’infos intéressantes ici :

• Documentation de la librairie nRF24 (lien général)
• Détail des fonctions de la library NRF24 (pour voir toutes les propriétés utilisables, avec cette bibliothèque)

À présent, voyons comment instancier cette librairie, dans nos programmes arduino.

Instanciation librairie nRF24 dans Arduino IDE

Pour instancier cette librairie nRF24, rien de plus simple ! Car il suffit d’inclure 2 libraires à tous nos projets de communication radio, à savoir :

• La librairie SPI, nécessaire pour les échanges Arduino <-> nRF24
• Et la librairie NRF24, en elle-même

Cela se fait avec les 2 lignes de code suivantes :

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

Ensuite, il faut procéder à l’instanciation de la librairie NRF24 en elle-même, en précisant où sont raccordées les pins CE et CSN sur l’arduino (les autres étant « immuables », si je puis dire). Pour ma part, j’ai relié :

• la broche CE à la broche D7 de mon arduino nano
• et la broche CSN à la broche D8 de mon arduino nano

Au niveau du code de programmation, voici comment cela se déroule :

#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 RF24 radio(pinCE, pinCSN); // Instanciation du NRF24L01

Enfin, dans la fonction « setup() » de notre programme arduino, il ne reste plus qu’à faire appel à la fonction « begin », pour initialiser notre module NRF24L01+, comme visible ci-dessous :

void setup() { radio.begin(); // Initialisation du module NRF24 … // Suite du programme }

Nous voilà fin prêt pour piloter notre émetteur récepteur radio ! Mais avant d’envoyer ou recevoir la moindre donnée, nous devons préalablement paramétrer certaines choses. Et c’est ce que nous allons voir, dès à présent !

Sélection du canal de communication (setChannel)

Comme vu dans les caractéristiques du NRF24L01 plus haut, vous pouvez choisir une fréquence de communication allant de 2400 MHz à 2525 MHz, par pas de 1 MHz. Ceci, afin de prendre une fréquence libre, avec le moins de perturbations possibles.

Pour ce faire, il suffit de faire appel à la fonction « setChannel » dans votre programme arduino, pour définir cette fréquence. À noter que cette dernière sera basée sur 2400 MHz, à laquelle viendra s’ajouter un nombre situé entre 0 et 125. Ainsi :

• le channel 0 correspond à la fréquence de 2400 + 0, soit 2400 MHz
• le channel 1 correspond à la fréquence de 2400 + 1, soit 2401 MHz
• …
• le channel 124 correspond à la fréquence de 2400 + 124, soit 2524 MHz
• le channel 125 correspond à la fréquence de 2400 + 125, soit 2525 MHz

Côté code arduino, ceci tient en une seule ligne (que vous pourrez mettre dans la partie « setup » de votre programme arduino) :

radio.setChannel(x); // en remplaçant « x » par une valeur comprise entre 0 et 125

Choix du niveau de transmission du signal radio (setPALevel)

Autre point important, qui influera directement sur la portée de votre émetteur radio : son niveau de signal radio (autrement dit : la puissance d’émission). Ici, vous aurez le choix entre 4 niveaux « d’intensité » de signal, à savoir :

• RF24_PA_MIN : pour un niveau d’émission minimal (idéal si vous n’avez pas besoin de communiquer à longue distance, ou si vous alimentez votre module nRF24L01 depuis l’alimentation 3,3 V de votre arduino)
• RF24_PA_LOW : niveau d’émission bas
• RF24_PA_HIGH : niveau d’émission moyen/haut
• RF24_PA_MAX : pour émettre à grande distance (jusqu’à 1,1 km de distance, dans des conditions optimales). C’est le mode idéal si vous avez besoin de communiquer avec votre drone, avion, fusée, voiture, ou autre engin radiocommandé, avec le maximum de portée radio. Mais attention, car dans ce cas, il faudra ajouter le fameux module d’alimentation intermédiaire, entre votre arduino, et votre module NRF24L01+.

Au niveau du code, il suffit d’utiliser la fonction « setPALevel » pour définir la puissance d’émission, en spécifiant le niveau souhaité :

radio.setPALevel(xxx); // en remplaçant « xxx » par RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH, ou RF24_PA_MAX

Indication du débit d’émission réception (setDataRate)

Au niveau des vitesses de transmission de données, vous aurez le choix entre 3 cadences d’émission/réception:

• 250 kbps (kilo bits par seconde) : c’est le débit de transmission le plus faible, mais qui permet d’aller le plus loin possible, en terme de portée de signal radio
• 1 Mbps (méga bits par seconde)
• 2 Mbps (méga bits par seconde) : c’est le débit le plus rapide, mais qui limitera la portée du signal radio (à cause des interférences, notamment)

En résumé : plus vous essayerez « d’aller vite » et moins vous irez loin, en termes de portée du signal. Et inversement : plus vous transmettrez lentement, et plus vous pourrez émettre à « longue » distance.

Dans le code arduino, ce choix de vitesse s’écrira de la manière suivante :

radio.setDataRate(xxx); // en remplaçant « xxx » par RF24_250KBPS, RF24_1MBPS, ou encore, RF24_2MBPS

Ouverture d’un tunnel pour de l’émission radio (setWritingPipe)

Lorsqu’on veut émettre d’un NRF24L01 à l’autre, il faut établir un canal de communication. Ce canal s’appelle un « pipe », en anglais (perso, je l’appelle aussi « tunnel » de communication).

Pour envoyer des données d’un nRF24 à un autre, il faut donc tout d’abord donner un nom à ce tunnel (sur 5 caractères), et définir son sens. À noter, au passage, qu’un NRF24L01+ ne peut avoir qu’un seul canal d’émission au maximum (contrairement à la réception, qui elle, comme nous allons le voir après, peut se faire au travers de 5 voire 6 tunnels).

Pour ma part, voici comment je retranscris tout ça, dans l’entête du code de programmation arduino :

#define tunnel1 "PIPE1" // On définit un "nom de tunnel" (5 caractères), pour pouvoir communiquer d'un NRF24 à l'autre #define tunnel2 "PIPE2" #define tunnel3 "PIPE3" #define tunnel4 "PIPE4" #define tunnel5 "PIPE5" #define tunnel6 "PIPE6" const byte adresses[][6] = {tunnel1, tunnel2, tunnel3, tunnel4, tunnel5, tunnel6}; // Tableau contenant les adresses de tunnel, au format "byte array"

Et un peu plus loin, dans la fonction setup ou loop, on ouvre le ou les canaux qui nous intéressent :

radio.openWritingPipe(adresses[0]); // Ouverture du "tunnel1" en ÉCRITURE (émission radio)

Ainsi, dans cet exemple, le tunnel n°1 sera défini comme un canal permettant au nRF24 d’émettre des données, par ondes radios.

Nota : chaque nRF24 possède 6 pipes (6 tunnels de communication). Le 1er est le seul à pouvoir émettre OU recevoir. Les autres, quant à eux, ne pourront QUE recevoir des données. C’est pourquoi, on peut avoir jusqu’à 1 canal d’émission + 5 canaux de réception, ou tout simplement, 6 canaux de réception. Bien sûr, on n’est absolument pas obligé d’utiliser tous les canaux, ni de respecter le moins « ordre » (à l’exception du PIPE0, qui, encore une fois, est le seul pouvant permettre d’émettre des données).

Ouverture d’un tunnel pour la réception de données (setReadingPipe)

À l’image de la fonction précédente, la fonction setReadingPipe permet de spécifier un tunnel de communication, mais dans le sens « réception », cette fois-ci. Étant donné que le module NRF24L01 dispose de 6 pipes (ou tunnels de communication), vous pourrez recevoir des infos provenant de 6 autres nRF24, si le cœur vous en dit ! Ou plus exactement 5, si jamais vous souhaitez garder un canal pour émettre.

Au niveau du code, voici comment on pourrait initialiser tout cela, si on souhaitait recevoir des informations de 5 autres nRF24 :

#define tunnel1 "PIPE1" // Pour l’envoi de données #define tunnel2 "PIPE2" // Pour la réception de données provenant d’un autre nRF24 #define tunnel3 "PIPE3" // Pour la réception de données provenant d’un autre nRF24 #define tunnel4 "PIPE4" // Pour la réception de données provenant d’un autre nRF24 #define tunnel5 "PIPE5" // Pour la réception de données provenant d’un autre nRF24 #define tunnel6 "PIPE6" // Pour la réception de données provenant d’un autre nRF24

Et plus loin, dans votre programme, l’appel de cette fonction pourra se faire comme ceci (pour la partie « écoute », donc) :

radio.openReadingPipe(1, adresses[1]); // Ouverture du "tunnel2" en LECTURE (réception radio) radio.openReadingPipe(2, adresses[2]); // Ouverture du "tunnel3" en LECTURE (réception radio) radio.openReadingPipe(3, adresses[3]); // Ouverture du "tunnel4" en LECTURE (réception radio) radio.openReadingPipe(4, adresses[4]); // Ouverture du "tunnel5" en LECTURE (réception radio) radio.openReadingPipe(5, adresses[5]); // Ouverture du "tunnel6" en LECTURE (réception radio)

Bien sûr, vous pouvez vous servir des pipes comme vous le souhaitez, dans la mesure où vous respectez notamment ces deux choses là :

• Le 1er pipe est le seul à pouvoir émettre OU recevoir. Du coup, si vous souhaitez uniquement recevoir des données, et rien n’émettre, vous pourriez fort bien utiliser le premier pipe en réception (en utilisant le code suivant : radio.openReadingPipe(0, adresses[0]);)
• Les 3ème à 6ème pipes ont une « adresse partagée » avec le 2ème pipe. C’est pourquoi ceux-ci devront avoir la même « racine » dans leur « nom » que le 2ème pipe (ici, la racine est correspond aux 4 premières lettres du 2ème pipe, à savoir les lettres « PIPE » ; en bref, seul la 5ème lettre change, pour ces derniers pipes)

Si vous avez besoin de plus d’explications sur les « pipes », n’hésitez pas à revenir sur la partie théorique, présentée un peu plus haut, dans cet article.

Définition du sens de communication, entre l’arduino et le NRF24L01+ (startListening et stopListening)

Avant d’effectuer la moindre lecture (read) ou écriture (write), il faudra toujours vous assurer d’être dans le bon « mode de fonctionnement ». Pour ce faire, il faudra tout simplement :

• Utiliser la fonction « startListening » si vous souhaitez pouvoir ensuite écouter via un pipe (avec la fonction « read »)
• Utiliser la fonction « stopListening » si vous souhaitez pouvoir plutôt émettre via un pipe (avec la fonction « write »)

Dans votre programme arduino, vous pourrez donc utiliser les fonctions suivantes, au besoin :

radio.startListening(); // permet de pouvoir utiliser la fonction « read » par la suite // ou radio.stopListening(); // permet de pouvoir utiliser la fonction « write » ensuite

Émission et réception de données radio (read / write)

Dernières fonctions, et non des moindres : read et write. Celles-ci permettent respectivement de pouvoir lire ce qu’on a reçu, ou d’envoyer un message, par onde radio.

Mais avant tout, souvenez-vous d’une chose, abordée plus haut : le buffer (tampon de mémoire) du nRF24 est limité à 32 octets. C’est-à-dire que tout message ne devra jamais excéder cette taille. Par contre, vous n’êtes pas limité à l’envoi d’une seule donnée à la fois, car vous pouvez utiliser des groupes de données (de type « struct »), du moment où ceux-ci « pèsent » moins de 32 octets.

Exemple de code pour lire un message reçu (variable simple) :

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" }

Exemple de code pour envoyer un message (variable simple) :

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"

Bien sûr, comme je vous disais, on n’est pas limité à une variable ou une chaîne de caractère. Car on peut utiliser « n’importque quoi », tant que ça fait moins de 32 octets en mémoire. On peut donc transmettre des ensembles de valeurs (struct), contenant des byte, boolean, int, char, … où je ne sais quoi d’autre, tant que ça ne dépasse pas 32 octets !

Besoin d’un exemple pour illustrer tout ça ? Alors voici un bout de programme, permettant de définir un groupe de données, de type « struct » :

struct DonneesAenvoyer { int joystickGauchePotX; // int = 2 octets (0..65535) int joystickGauchePotY; int joystickDroitePotX; int joystickDroitePotY; boolean boostBtn; // boolean = 1 octet (0..255) byte offsetGauche; // byte = 1 octet (0..255) byte offsetDroite; }; DonneesAenvoyer donnees;

À noter que cette structure fait bien moins de 32 octets de mémoire, car étant la somme de 4 int + 1 boolean + 2 byte, soit (4×2 + 1 + 2×1) octets, soit 11 octets. On peut donc envoyer ces données sans soucis, car nous sommes en dessous de la taille limite du tampon de notre NRF24L01+.

Et pour envoyer ou recevoir ces données, avec ce type de structure, le codage est tout aussi simple. Car il suffit d’écrire :

• radio.read(&donnees, sizeof(donnees)); pour charger la totalité des données reçues en une seule fois
• radio.write(&donnees, sizeof(donnees)); pour envoyer toutes les données de la « struct », à la fois

À noter que chacune de ces données peut être lue ou chargée individuellement, en codant comme ceci :

• exemple d’enregistrement d’une nouvelle valeur dans la structure => donnees.joystickGauchePotX = analogRead (A0);
• exemple de lecture d’une donnée particulière, contenue dans la structure => byte leftOffset = donnees.offsetGauche;

Nota : si jamais tout cela vous semble quelque peu compliqué, n’hésitez pas à y revenir plus tard, après avoir vu des exemples concrets. Ainsi, toute cette partie théorique vous semblera plus facile à assimiler. Dans tous les cas, ne vous faites pas des nœuds dans le cerveau, ça ne sert à rien de vouloir faire entrer les choses en force 😉

Aperçu	Description	Lien achat
	Module NRF24L01 (avec antenne intégrée)
	Adaptateur d'alim (pour NRF24L01+ et version +PA+LNA)
	Module NRF24L01 + PA + LNA (avec antenne externe)

Tuto NRF24L01 : unidirectionnel (exemple « Hello World »)

Premier exemple : réaliser l’envoi d’un message « Hello World » d’un arduino à l’autre. En résumé :

• le 1er arduino enverra un message toutes les secondes, contenant la chaîne de caractères « Hello World !! »
• le 2ème arduino sera à l’écoute de données radio, et si il en reçoit, il les affichera sur le moniteur série de l’IDE Arduino

Pour ce faire, voici le montage à réaliser :

Et ce que ça donne en photo, une fois câblé sur une breadboard (notez bien que le 2ème arduino, faisant office de récepteur, devra être relié au PC, pour voir les données reçues, via le moniteur série) :

Côté programme Arduino, vous trouverez ci-après les 2 programmes animant cet exemple (un pour l’émetteur, et un autre pour le récepteur). Il faudra garder le câble de programmation branché sur « l’arduino récepteur », pour les infos reçues sur l’interface série (via le moniteur série de votre IDE Arduino).

Code de programmation émetteur Hello World :

/* ______ _ _/// _ _ _ / _ \ (_) | __\| | | | (_) | [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___ | ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \ | | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/ \__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___| | | \_| Fichier: HelloWorldNRF24L01-Emetteur Description: Emission d'un "Hello World" via un NRF24L01 Auteur: Passion-Électronique Librairie utilisée : https://github.com/nRF24/RF24 Créé le 19.03.2021 */ #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 ! }

Code de programmation récepteur Hello World :

/* ______ _ _/// _ _ _ / _ \ (_) | __\| | | | (_) | [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___ | ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \ | | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/ \__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___| | | \_| Fichier: HelloWorldNRF24L01-Recepteur Description: Réception d'un message "Hello World" depuis un autre arduino nano, via un NRF24L01 Auteur: Passion-Électronique Librairie utilisée : https://github.com/nRF24/RF24 Créé le 19.03.2021 */ #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 ! } }

Une fois lancé, vous devriez obtenir quelque chose comme ça :

Si jamais rien ne s’affiche, vérifiez bien tout votre câblage, et vérifiez bien que vous n’ayez pas oublié de mettre le condensateur de « soutien d’alimentation », aux NRF24L01.

Du reste, comme vous avez pu le constater, il n’y a rien de plus simple ici. Car en synthèse, on ne fait qu’ouvrir une voie de communication radio (appelée pipe ou tunnel), et on y fait transiter des infos, d’un arduino vers l’autre, via les NRF24L01+. À présent, nous allons corser un peu les choses, en voyant comment échanger des informations radio de manière bidirectionnelle, afin que chaque Arduino puisse envoyer des données à l’autre. C’est parti !

Aperçu	Description	Lien achat
	Module NRF24L01 (avec antenne intégrée)
	Adaptateur d'alim (pour NRF24L01+ et version +PA+LNA)
	Module NRF24L01 + PA + LNA (avec antenne externe)

Tuto NRF24L01 : bidirectionnel (notion de « pipe »)

Maintenant que nous avons vu comment envoyer des messages dans un sens, on va le faire… dans les 2 sens !

Ici, je vous propose de réaliser un montage totalement symétrique. En fait, il s’agira simplement de faire varier l’angle d’un servomoteur branché sur un arduino, en fonction de la valeur du potentiomètre branché sur l’autre arduino. Et vice-versa, pour obtenir un fonctionnement croisé.

C’est pas clair ? Voici une petite vidéo du montage « en action », illustrant tout ceci :

Au niveau du montage électronique en lui-même, voici ce que vous aurez à réaliser, si vous souhaitez reproduire ce que j’ai fait :

Au niveau du code arduino, voici le programme de l’émetteur :

/* ______ _ _/// _ _ _ / _ \ (_) | __\| | | | (_) | [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___ | ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \ | | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/ \__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___| | | \_| Fichier: CommunicationBidirectionnelleNRF24L01-Arduino1 Description: Pilotage d'un servomoteur à distance, depuis un autre Arduino, via un NRF24L01 Auteur: Passion-Électronique Librairie utilisée : https://github.com/nRF24/RF24 Créé le 20.03.2021 */ #include <SPI.h> #include <RF24.h> #include <Servo.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 pinSERVO 9 // On associe la broche "SIGNAL" du SERVO à la sortie digitale D9 de l'arduino #define pinPOT A0 // On associe le point milieu du potentiomètre à l'entrée analogique A0 de l'arduino #define tunnel1 "PIPE1" // On définit un premier "nom de tunnel" (5 caractères), pour pouvoir envoyer des données à l'autre NRF24 #define tunnel2 "PIPE2" // On définit un second "nom de tunnel" (5 caractères), pour pouvoir recevoir des données de l'autre NRF24 RF24 radio(pinCE, pinCSN); // Instanciation du NRF24L01 Servo servomoteur; // Instanciation d'un objet pour contrôler le servomoteur const byte adresses[][6] = {tunnel1, tunnel2}; // Tableau des adresses de tunnel, au format "byte array" int valeurPotLocal; // Variable contenant la valeur du potentiomètre int valeurAngleServoLocal; // Variable contenant la valeur de l'angle du servomoteur int valeurAngleServoDistant; // Variable contenant la valeur de l'angle du servomoteur void setup() { pinMode(pinPOT, INPUT); // Déclaration de la pin "pinPOT" en entrée servomoteur.attach(pinSERVO); // Liaison de la pin "pinSERVO" au servomoteur branché sur l'arduino radio.begin(); // Initialisation du module NRF24 radio.openWritingPipe(adresses[0]); // Ouverture du "tunnel1" en ÉCRITURE radio.openReadingPipe(1, adresses[1]); // Ouverture du "tunnel2" en LECTURE radio.setPALevel(RF24_PA_MIN); // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais) servomoteur.write(90); // Rotation du servomoteur pour le mettre en position médiane delay(2000); // puis démarrage du programme } void loop() { // ******** ENVOI ******** radio.stopListening(); // On commence par arrêter le mode écoute, pour pouvoir émettre les données valeurPotLocal = analogRead(pinPOT); // On lit la valeur du potentiomètre (résultat retourné entre 0 et 1023) valeurAngleServoDistant = map(valeurPotLocal, 0, 1023, 0, 180); // On converti la valeur [0..1023] en [0..180] (pour correspondre à l'angle d'un servo) valeurAngleServoDistant = 2*(int)(valeurAngleServoDistant/2); // Léger arrondi, pour limiter les "tremblements" du servomoteur radio.write(&valeurAngleServoDistant, sizeof(valeurAngleServoDistant)); // … et on envoi cette valeur à l'autre arduino, via le NRF24 delay(5); // avec une petite pause, avant de passer à la suite // ******** RÉCEPTION ******** radio.startListening(); // On commence par arrêter le mode envoi, pour pouvoir réceptionner des données if(radio.available()) { // On regarde si une donnée a été reçue while (radio.available()) { // Si une donné est en attente de lecture, on va la lire radio.read(&valeurAngleServoLocal, sizeof(valeurAngleServoLocal)); // Lecture des données reçues, une par une servomoteur.write(valeurAngleServoLocal); // … et ajustement de l'angle du servomoteur à chaque fois } delay(20); // avec une petite pause, avant de reboucler } delay(5); }

Et le code de programmation du récepteur :

/* ______ _ _/// _ _ _ / _ \ (_) | __\| | | | (_) | [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___ | ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \ | | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/ \__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___| | | \_| Fichier: CommunicationBidirectionnelleNRF24L01-Arduino2 Description: Pilotage d'un servomoteur à distance, depuis un autre Arduino, via un NRF24L01 Auteur: Passion-Électronique Librairie utilisée : https://github.com/nRF24/RF24 Créé le 20.03.2021 */ #include <SPI.h> #include <RF24.h> #include <Servo.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 pinSERVO 9 // On associe la broche "SIGNAL" du SERVO à la sortie digitale D9 de l'arduino #define pinPOT A0 // On associe le point milieu du potentiomètre à l'entrée analogique A0 de l'arduino #define tunnel1 "PIPE2" // On définit un premier "nom de tunnel" (5 caractères), pour pouvoir envoyer des données à l'autre NRF24 #define tunnel2 "PIPE1" // On définit un second "nom de tunnel" (5 caractères), pour pouvoir recevoir des données de l'autre NRF24 /* ----- NOTEZ L'INVERSION de PIPE1 et PIPE2, entre celui-ci et l'autre montage ! (car chaque tunnel véhicule les infos que dans un seul sens) */ RF24 radio(pinCE, pinCSN); // Instanciation du NRF24L01 Servo servomoteur; // Instanciation d'un objet pour contrôler le servomoteur const byte adresses[][6] = {tunnel1, tunnel2}; // Tableau des adresses de tunnel, au format "byte array" int valeurPotLocal; // Variable contenant la valeur du potentiomètre int valeurAngleServoLocal; // Variable contenant la valeur de l'angle du servomoteur int valeurAngleServoDistant; // Variable contenant la valeur de l'angle du servomoteur void setup() { pinMode(pinPOT, INPUT); // Déclaration de la pin "pinPOT" en entrée servomoteur.attach(pinSERVO); // Liaison de la pin "pinSERVO" au servomoteur branché sur l'arduino radio.begin(); // Initialisation du module NRF24 radio.openWritingPipe(adresses[0]); // Ouverture du "tunnel1" en ÉCRITURE radio.openReadingPipe(1, adresses[1]); // Ouverture du "tunnel2" en LECTURE radio.setPALevel(RF24_PA_MIN); // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais) servomoteur.write(90); // Rotation du servomoteur pour le mettre en position médiane delay(2000); // puis démarrage du programme } void loop() { // ******** ENVOI ******** radio.stopListening(); // On commence par arrêter le mode écoute, pour pouvoir émettre les données valeurPotLocal = analogRead(pinPOT); // On lit la valeur du potentiomètre (résultat retourné entre 0 et 1023) valeurAngleServoDistant = map(valeurPotLocal, 0, 1023, 0, 180); // On converti la valeur [0..1023] en [0..180] (pour correspondre à l'angle d'un servo) valeurAngleServoDistant = 2*(int)(valeurAngleServoDistant/2); // Léger arrondi, pour limiter les "tremblements" du servomoteur radio.write(&valeurAngleServoDistant, sizeof(valeurAngleServoDistant)); // … et on envoi cette valeur à l'autre arduino, via le NRF24 delay(5); // avec une petite pause, avant de passer à la suite // ******** RÉCEPTION ******** radio.startListening(); // On commence par arrêter le mode envoi, pour pouvoir réceptionner des données if(radio.available()) { // On regarde si une donnée a été reçue while (radio.available()) { // Si une donné est en attente de lecture, on va la lire radio.read(&valeurAngleServoLocal, sizeof(valeurAngleServoLocal)); // Lecture des données reçues, une par une servomoteur.write(valeurAngleServoLocal); // … et ajustement de l'angle du servomoteur à chaque fois } delay(20); // avec une petite pause, avant de reboucler } delay(5); }

Comme vous avez dû le constater, les deux programmes sont quasiment des copies conformes. À ceci près, toutefois, que les adresses de tunnel de communication sont inversés, d’un programme à l’autre (ce qui est normal, car, à travers un tunnel, les informations ne circulent que dans un sens).

Et maintenant que vous savez faire échanger des données de manière bidirectionnelle, d’un NRF24L01 à l’autre, il nous reste plus qu’une dernière étape à voir : la communication d’une multitude de nRF24 entre eux !

Image	Description	Lien
	Caméra WiFi extérieur, pour vidéosurveillance(modèle double, avec partie fixe + mobile 360°)	Voir le prix

Tutorial NRF24L01 : montage en réseau / arborescence, avec nœuds (tree mode et nodes mesh networking)

Dernière partie : la communication entre plusieurs nRF24 ! Ici, vous verrez comment faire communiquer jusqu’à près de 781 modules NRF24L01 ensemble. Avouez que ça ouvre de très nombreuses perspectives, non ? Mais avant de vous montrer comment coder tout ça sous Arduino, il faut que je vous explique 2 ou 3 choses.

Pour commencer, il faut savoir que nous allons ici créer un réseau (comme le réseau WiFi, si vous voulez, mais en plus simple). Chaque module nRF24 aura sa propre adresse, mais attention, pas n’importe laquelle (il y aura moins de liberté que dans les exemples précédents). En fait, chaque module radio sera virtuellement raccordé à l’autre en arborescence (« tree », en anglais), comme visible ci-dessous :

La règle à savoir, concernant l’adressage de chaque module, est que :

• il n’y a qu’un module nRF24 « maître » (l’adresse 0)
• chaque nRF24 ne peut avoir que 5 modules nRF24 « enfant », sous lui
• on est limité à 5 niveaux d’arborescence (en sachant que le 1er niveau ne contient que le module maître, avec l’adresse zéro)

Ainsi, le nombre maximal de modules NRF24L01+ que l’on peut mettre en réseau sera égal à : 1 + 5 + (5×5) + (5x5x5) + (5x5x5x5), soit 781 adresses au maximum.

Remarque importante : chaque module a une adresse chiffrée, écrite au format octal (donc ni en binaire, ni en décimal, ni en hexadécimal, … mais seulement des chiffres allant de 0 à 7). Au niveau du programme arduino, un nombre octal s’écrit avec un « 0 » devant. Du coup, lorsque vous voyez « 00 », cela veut dire le chiffre 0 en format octal. De même, si vous voyez par exemple « 0130 », cela veut dire qu’il s’agit du nombre 130 écrit au format octal. Ne croyez donc pas que j’ai rajouté des « 0 » pour m’amuser dans les programmes qui suivent ! Et de votre côté, ne les oubliez pas !

À noter que nous allons utiliser ici une librairie supplémentaire, à celle de base (la nRF24). Il s’agit en fait de la librairie nRF24 Network, permettant de créer des réseaux de modules NRF24L01 ! Elle est donc à utiliser en plus de la librairie nRF24 que nous avons utilisé jusqu’à présent (voir plus haut). Pour l’installer, il suffit également d’aller dans le « Gestionnaire de bibliothèques » de votre Arduino IDE, mais au lieu de taper « NRF24 », il va falloir taper « NRF24Network », cette fois-ci. Et comme la dernière fois, il faudra choisir celle qui est sous-titrée « by TMRh20 ».

Maintenant que nous avons vu toute la partie théorique, passons à la pratique ! Pour ce faire, je vais reprendre exactement le même montage, réalisé juste avant (communication bidirectionnelle de servomoteur), pour faire simple. Si vous n’avez pas lu cette partie, vous aurez besoin de la lire avant de passer à la suite (sinon vous risquez ne pas tout comprendre !). Bien entendu, même si je réalise un montage avec seulement 2 modules NRF24L01+ communiquant entre eux, libre à vous d’en mettre autant que vous voulez (mais dans la limite des 781 modules, bien évidemment !).

À présent, voici le code de l’arduino ayant l’adresse « 00 » (donc « 0 », écrit au format octal) :

/* ______ _ _/// _ _ _ / _ \ (_) | __\| | | | (_) | [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___ | ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \ | | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/ \__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___| | | \_| Fichier: NetworkNRF24L01-Arduino1 Description: Construction d'un réseau communicant, via des NRF24L01 connectés à des Arduino Auteur: Passion-Électronique Librairie utilisée : https://github.com/nRF24/RF24 Créé le 21.03.2021 */ #include <SPI.h> #include <RF24.h> #include <RF24Network.h> #include <Servo.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 pinSERVO 9 // On associe la broche "SIGNAL" du SERVO à la sortie digitale D9 de l'arduino #define pinPOT A0 // On associe le point milieu du potentiomètre à l'entrée analogique A0 de l'arduino RF24 radio(pinCE, pinCSN); // Instanciation du NRF24L01 RF24Network network(radio); // Nota : "Network" utilise la librairie "radio" Servo servomoteur; // Instanciation d'un objet pour contrôler le servomoteur // Réseau const uint16_t noeud0 = 00; // Valeur "0" écrite au format "octal" (d'où l'autre "0" devant) const uint16_t noeud1 = 01; // Valeur "1" écrite au format "octal" (d'où l'autre "0" devant) const uint16_t noeud11 = 011; // Valeur "11" écrite au format "octal" (d'où l'autre "0" devant) const uint16_t noeud12 = 012; // Valeur "12" écrite au format "octal" (d'où l'autre "0" devant) uint16_t numeroDeCeNoeud = noeud0; uint16_t noeudCible = noeud1; // Ici, le noeud sera donc le "noeud0", et le noeud cible, le "noeud1" unsigned long valeurPotLocal; // Variable contenant la valeur du potentiomètre unsigned long valeurAngleServoLocal; // Variable contenant la valeur de l'angle du servomoteur unsigned long valeurAngleServoDistant; // Variable contenant la valeur de l'angle du servomoteur unsigned long donnees; // Variable contenant les données void setup() { SPI.begin(); pinMode(pinPOT, INPUT); // Déclaration de la pin "pinPOT" en entrée servomoteur.attach(pinSERVO); // Liaison de la pin "pinSERVO" au servomoteur branché sur l'arduino radio.begin(); // Initialisation du module NRF24 radio.setPALevel(RF24_PA_MIN); // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais) radio.setDataRate(RF24_250KBPS); // Vitesse : RF24_250KBPS, RF24_1MBPS, RF24_2MBPS network.begin(64, numeroDeCeNoeud); // Canal 64 choisi arbitrairement (valeurs possibles : entre 0..125) servomoteur.write(90); // Rotation du servomoteur pour le mettre en position médiane delay(2000); // puis démarrage du programme } void loop() { network.update(); // ******** RÉCEPTION ******** while (network.available()) { // Si une donné est en attente de lecture, on va la lire RF24NetworkHeader nHeader(numeroDeCeNoeud); network.read(nHeader, &valeurAngleServoLocal, sizeof(valeurAngleServoLocal)); // Lecture des données reçues, une par une servomoteur.write(valeurAngleServoLocal); // … et ajustement de l'angle du servomoteur en fonction } delay(5); // ******** ENVOI ******** valeurPotLocal = analogRead(pinPOT); // On lit la valeur du potentiomètre (résultat retourné entre 0 et 1023) valeurAngleServoDistant = map(valeurPotLocal, 0, 1023, 0, 180); // On converti la valeur [0..1023] en [0..180] (pour correspondre à l'angle d'un servo) valeurAngleServoDistant = 2*(int)(valeurAngleServoDistant/2); // Léger arrondi, pour limiter les "tremblements" du servomoteur RF24NetworkHeader nHeader(noeudCible); network.write(nHeader, &valeurAngleServoDistant, sizeof(valeurAngleServoDistant)); // On envoi à l'autre carte la valeur de l'angle souhaité, pour son servomoteur delay(5); // avec une petite pause }

Et le code de l’arduino ayant l’adresse « 01 » (donc « 1 », écrit au format octal ») :

/* ______ _ _/// _ _ _ / _ \ (_) | __\| | | | (_) | [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___ | ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \ | | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/ \__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___| | | \_| Fichier: NetworkNRF24L01-Arduino2 Description: Construction d'un réseau communicant, via des NRF24L01 connectés à des Arduino Auteur: Passion-Électronique Librairie utilisée : https://github.com/nRF24/RF24 Créé le 21.03.2021 */ #include <SPI.h> #include <RF24.h> #include <RF24Network.h> #include <Servo.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 pinSERVO 9 // On associe la broche "SIGNAL" du SERVO à la sortie digitale D9 de l'arduino #define pinPOT A0 // On associe le point milieu du potentiomètre à l'entrée analogique A0 de l'arduino RF24 radio(pinCE, pinCSN); // Instanciation du NRF24L01 RF24Network network(radio); // Nota : "Network" utilise la librairie "radio" Servo servomoteur; // Instanciation d'un objet pour contrôler le servomoteur // Réseau const uint16_t noeud0 = 00; // Valeur "0" écrit au format "octal" (d'où l'autre "0" devant) const uint16_t noeud1 = 01; // Valeur "1" écrit au format "octal" (d'où l'autre "0" devant) const uint16_t noeud11 = 011; // Valeur "11" écrit au format "octal" (d'où l'autre "0" devant) const uint16_t noeud12 = 012; // Valeur "12" écrit au format "octal" (d'où l'autre "0" devant) uint16_t numeroDeCeNoeud = noeud1; uint16_t noeudCible = noeud0; // Ici, le noeud sera donc le "noeud1", et le noeud cible, le "noeud0" (l'exact opposé de l'autre programme, en fait) unsigned long valeurPotLocal; // Variable contenant la valeur du potentiomètre unsigned long valeurAngleServoLocal; // Variable contenant la valeur de l'angle du servomoteur unsigned long valeurAngleServoDistant; // Variable contenant la valeur de l'angle du servomoteur unsigned long donnees; // Variable contenant les données void setup() { SPI.begin(); pinMode(pinPOT, INPUT); // Déclaration de la pin "pinPOT" en entrée servomoteur.attach(pinSERVO); // Liaison de la pin "pinSERVO" au servomoteur branché sur l'arduino radio.begin(); // Initialisation du module NRF24 radio.setPALevel(RF24_PA_MIN); // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais) radio.setDataRate(RF24_250KBPS); // Vitesse : RF24_250KBPS, RF24_1MBPS, RF24_2MBPS network.begin(64, numeroDeCeNoeud); // Canal 64 choisi arbitrairement (valeurs possibles : entre 0..125) servomoteur.write(90); // Rotation du servomoteur pour le mettre en position médiane delay(2000); // puis démarrage du programme } void loop() { network.update(); // ******** RÉCEPTION ******** while (network.available()) { // Si une donné est en attente de lecture, on va la lire RF24NetworkHeader nHeader(numeroDeCeNoeud); network.read(nHeader, &valeurAngleServoLocal, sizeof(valeurAngleServoLocal)); // Lecture des données reçues, une par une servomoteur.write(valeurAngleServoLocal); // … et ajustement de l'angle du servomoteur en fonction } delay(5); // ******** ENVOI ******** valeurPotLocal = analogRead(pinPOT); // On lit la valeur du potentiomètre (résultat retourné entre 0 et 1023) valeurAngleServoDistant = map(valeurPotLocal, 0, 1023, 0, 180); // On converti la valeur [0..1023] en [0..180] (pour correspondre à l'angle d'un servo) valeurAngleServoDistant = 2*(int)(valeurAngleServoDistant/2); // Léger arrondi, pour limiter les "tremblements" du servomoteur RF24NetworkHeader nHeader(noeudCible); network.write(nHeader, &valeurAngleServoDistant, sizeof(valeurAngleServoDistant)); // On envoi à l'autre carte la valeur de l'angle souhaité, pour son servomoteur delay(5); // avec une petite pause }

Nota : je vous ai rajouté des nœuds inutilisés dans le code (noeud11 et noeud12). Ils sont juste là pour vous montrer comment simplement rajouter d’autres nRF24 à l’arborescence. Bien sûr, libre à vous d’adapter tout cela, en fonction de vos besoins !

Aperçu	Description	Lien achat
	Module NRF24L01 (avec antenne intégrée)
	Adaptateur d'alim (pour NRF24L01+ et version +PA+LNA)
	Module NRF24L01 + PA + LNA (avec antenne externe)

[Ajout] Câblage d’un NRF24 PA LNA sur Arduino Mega

Comme j’ai eu pas mal de questions au sujet du NRF24 PA LNA (celui avec antenne externe), notamment au sujet de son raccordement sur l’arduino mega, j’ai décidé de vous ajouter cette partie.

Ici, vous trouverez un exemple de câblage, vous montrant comment raccorder un NRF24 PA LNA à votre Arduino Méga. Vous allez voir, il n’y a rien de bien sorcier !

Remarque importante : notez bien la présence d’une alimentation externe EN PLUS de l’éventuelle connexion USB. Celle-ci est quasi indispensable, du fait que le modèle nRF24 PA LNA est bien plus gourmand en énergie que son homologue sans antenne externe, non amplifié. Du coup, n’oubliez jamais de rajouter cette source d’énergie supplémentaire, afin que l’ensemble puisse bien fonctionner. Sinon, vous risquez fort d’avoir des soucis de communication !

Pour ma part, j’ai réalisé le câblage ci-dessus en double exemplaire, pour tester le programme « Hello World » présenté un peu plus haut. En pratique, je vous confirme que sans alim supplémentaire au niveau de l’arduino, il peut apparaître des bugs, ou dysfonctionnements. Donc, ne l’oubliez pas !

Exemple de montage émetteur/récepteur avec 2 x Arduino Mega, et 2 x NRF24 PA LNA :

Composants utilisés ici :

• 2 x cartes Arduino Méga 2560
• 2 x modules radio NRF24 PA LNA
• 2 x modules d’alimentation pour NRF24
• 2 x blocs d’alimentation externe 7,5V / 1A (DC 5,5/2,5)

Nota : j’insiste bien sur le fait qu’un Arduino seul, qu’il s’agisse d’un Uno, Mega, ou autre, aura beaucoup de mal à fournir toute l’énergie nécessaire, pour que le nRF24 PA LNA puisse fonctionner correctement. D’où la nécessité d’ajouter une alim externe, lorsqu’on fait ses essais.

[Ajout] Problèmes fréquents, avec les modules nRF24L01 PA LNA

Suite à vos nombreux retours, je vais vous recenser ici bon nombre de problèmes fréquents qu’on peut rencontrer, en branchant un module nRF24L01 PA LNA sur un Arduino. Cela vous permettra peut-être d’expliquer pourquoi vous n’arrivez pas forcément à faire marcher votre module radio NRF sur votre arduino ! Ainsi, vous arriverez peut-être à vous en dépatouiller, avec ce qui suit 😉

Mauvaise soudure d’usine

Ne riez pas, c’est plus fréquent qu’on croit ! Pour preuve, ça m’est arrivé il y a deux jours seulement, avec des modules NRF24 PA LNA, entièrement neufs. Du coup, au moindre signe de fonctionnement anormal, il ne faut surtout pas hésiter à examiner toutes les soudures des composants « préassemblés » que vous avez acheté, avant de jeter l’éponge !

Et comme une image est souvent bien plus parlante que les mots, voici l’exemple type d’une soudure mal faite, et qui engendrait, de mon côté, des bugs intermittents de communication :

Ici, une mauvaise soudure sur la broche GND du module d’alimentation de mon PA LNA m’a causé des fonctionnements erratiques. Sur un autre module, j’avais dû ressouder une autre broche, car la soudure n’était pas bien faite, et m’a causé une certaine instabilité de transmission.

Mon conseil : dès que vous constatez des comportements bizarres ou anormaux, n’hésitez pas à jeter un coup d’œil au niveau des soudures ! Et ne faites pas aveuglément confiance aux fabricants, sur la base du simple fait que les produits que vous achetez sont neufs, et donc, théoriquement « sans défaut » !

Alimentation pas suffisamment puissante

Autre souci, et certainement celui qui vous causera le plus de soucis, si vous n’en tenez pas compte : la nécessité de fournir suffisamment de puissance aux modules PA LNA (avec antenne externe), comparé aux modules « sans antenne » externe (ou plutôt intégrée au PCB, devrais-je dire). Car les modèles NRF24 PA LNA sont bien plus énergivores, et nécessitent donc une alimentation plus puissante.

Or, les régulateurs de tension sur les plaquettes Arduino ont des limites qui peuvent facilement être franchies, une fois un module nRF24 branché dessus. Du coup, une alimentation « de soutien » pour votre arduino est quasi indispensable, si vous souhaitez que tout fonctionne bien. Sinon : gare aux comportements bizarres, et fonctionnements erratiques !

Pour vous illustrer cela, voici un exemple de « ce qu’il faut faire », et « ne pas faire » (pour éviter toute surprise) :

Et croyez-moi, une alimentation « complémentaire » peut faire toute la différence. Car l’absence d’alimentation de soutien explique la plupart du temps les problèmes que vous rencontrez, avec ce type de module, particulièrement « énergivore », pour un « simple » arduino.

Rappel : comme évoqué plus haut dans ce tuto, un condensateur électrolytique à proximité des broches VCC et GND des modules NRF24 permet de leur assurer une bien meilleure stabilité, notamment à « haut débit ». D’ailleurs, ceci cumulé à l’ajout d’une alimentation externe de soutien, vous permettra très certainement d’atteindre les meilleures performances qui soient, en terme d’émission réception radio.

Fils dupont mal branchés, ou qui ne serrent pas suffisamment

Plus généralement, faites bien attention aussi aux fils dupont, qui, suivant leur qualité de fabrication ou fréquence d’utilisation, peuvent quelquefois être source de « faux-contact ».

C’est en tout cas ce que j’ai pu remarquer de mon côté, avec le temps. Et croyez-moi là encore : il n’y a rien de plus agaçant que de chercher une panne « pendant des heures » du côté logiciel, pour s’apercevoir au final, que le problème venait d’un fil dupont à moitié déconnecté, ou pas assez « serré » !

Du coup, si vous avez un fonctionnement anormal, n’hésitez pas à vérifier vos raccordements filaires 😉

Interférences électromagnétiques

Plus rare, mais autant vous en faire part : les interférences électromagnétiques peuvent également perturber les émissions réceptions d’ondes radio. C’est pourquoi, dans certains cas, il pourrait être intéressant d’effectuer un blindage tout autour du PCB du NRF24 PA LNA, à relier à la masse (GND), pour évacuer tout parasitage à ce niveau.

Bien sûr, il faudra alors penser à bien s’assurer qu’aucun composant électronique ne touche le blindage, afin d’éviter tout risque de court-circuit.

Nota : pour voir à quoi ce blindage pourrait ressembler, je vous mets en lien 2 photos ci-après, partagées par celui qui a conçu la librairie arduino utilisée dans ce tuto : lien 1 et lien 2. Ainsi, cela vous montre comment blinder un module NRF24 PA LNA, lorsque c’est nécessaire !

Aperçu	Description	Lien achat
	Module NRF24L01 (avec antenne intégrée)
	Adaptateur d'alim (pour NRF24L01+ et version +PA+LNA)
	Module NRF24L01 + PA + LNA (avec antenne externe)

Conclusion

Nous voici au terme de ce long article, vous donnant les bases du NRF24L01 et plusieurs exemples d’utilisation avec code arduino. J’espère que vous aurez pu apprendre ou découvrir plein de choses intéressantes ici, pour rendre vos futurs projets 100% communicant !

Pour ma part, je vais plancher sur la création d’une télécommande basée sur ce nRF24, pour piloter une voiture radiocommandée ! Il ne me reste plus qu’à trouver du temps pour faire tout cela, et vous le mettre en forme dans un nouvel article ! Je vous dis donc à très bientôt 😉

Jérôme.

À lire aussi : tutoriel sur le convertisseur analogique numérique ADS1115 !

Ce contenu vous plaît ? Alors abonnez-vous à la Newsletter pour ne rien louper !📜 Recevoir la Newsletter !

JEROME

Passionné par tout ce qui touche à l'électronique, sans toutefois en être expert, j'ai à coeur de vous partager ici, peu à peu, tout ce que j'ai appris, découvert, réalisé, et testé jusqu'à présent ! En espérant que tout cela puisse vous servir, ainsi qu'au plus grand nombre, chers amis francophones !

(*) Mis à jour le 29/08/2025