Fabriquer une radiocommande arduino nRF24L01 (émetteur 2.4 GHz)

Que diriez-vous de fabriquer une radiocommande arduino, à base de nRF24L01+ ? C’est en tout cas ce que je vous propose de réaliser ici, faisant suite au tutoriel sur le nRF24L01 que je vous précédemment rédigé.

Mais avant d’aller plus loin, sachez que cet émetteur RC est la partie 1/2 d’un projet de petite voiture radiocommandée. Cela étant dit, même si vous ne vous intéressez pas aux monde des modèles réduits, sachez que vous pourrez apprendre ici plein de choses, notamment sur comment envoyer des données personnalisées par ondes radio. D’ailleurs, libre à vous d’adapter ce montage, pour vos applications futures et sans-fil !

Par contre, gardez bien à l’esprit que ce projet se veut éducatif avant tout. C’est pourquoi il sera simple, ludique, et didactique. Il est principalement à destination des débutants en électronique, qui souhaitent faire leurs premiers pas avec un émetteur/récepteur RF, branché sur un arduino. Ainsi, ils verront une application concrète du nRF24L01+, et une manière de faire les choses (envoi de données « structurées », ici). Bien évidemment, que vous soyez débutant ou pas, n’hésitez pas à poser vos questions et vos remarques en bas de page, si besoin est ! J’essayerai d’y répondre le plus précisément possible, dans les limites de mes compétences et du temps dont je dispose, bien sûr !

Vue d’ensemble projet « Radiocommande Arduino »

Pour commencer, voici à quoi va ressembler notre radiocommande arduino, à base de nRF24L01+ :

Comme vous pouvez le constater, on retrouve principalement :

• Deux batteries lithium ion, qui vont alimenter notre télécommande
• Un joystick type PS2 (en bas à droite), qui nous servira à envoyer des informations du type : avancer, reculer, tourner à droite, ou prendre à gauche
• Un Arduino Pro Mini, qui sera le cœur de notre montage (et je vous expliquerai pourquoi j’ai pris ce modèle d’arduino plutôt qu’un autre)
• Un module nRF24L01+, en charge de l’émission radio, et fonctionnant sur la bande des 2,4 GHz
• Ainsi que quelques composants divers (fusible de protection, LEDs d’avertissement, mini haut-parleur, …)

En somme, rien de bien compliqué, même pour les débutants en électronique ! Donc, à présent, voyons tout cela un peu plus en détail 😉

Liste des composants et matériels nécessaires

Avant d’aller plus loin, je vous ai listé ici tous les composants nécessaires, si vous souhaitez reproduire ce montage à l’identique. Au passage, pour ceux qui ne savent pas où trouver certains de ces composants, je vous rajouté des liens pour les trouver facilement sur le net. Bien sûr, libre à vous de les acheter où vous voulez !

Aperçu	Désignation		Qté	Lien
	Accu lithium ion 18650 (3,7 volts nominal)	x	2
	Support 18650 double à souder sur PCB, pour accus li-ion	x	1
	Diode 1N4007 (format DO-41)	x	1
	Fusible 1A (type auto, taille moyenne)	x	1
	Support pour fusible auto, à monter sur circuit imprimé PCB	x	1
	Interrupteur 2 positions, à souder sur PCB	x	1
	Régulateur de tension AMS1117-3V3 (format CMS)	x	1
	Condensateur 100 µF 16V	x	2
	Résistance 10k 1% 1/4W	x	2
	Résistance 22k 1% 1/4W	x	2
	Résistance 270 5% 1/4W	x	2
	Résistance 100 5% 1/4W	x	1
	LED orange, Ø 5mm	x	1
	LED rouge, Ø 5mm	x	1
	Arduino Pro Mini 3V3 (ATTENTION : bien prendre un modèle 3,3 volts !)	x	1
	Joystick type PS2 nu (non soudé sur PCB, et sans capuchon)	x	1
	Capuchon pour joystick type PS2, couleur noir	x	1
	Module NRF24L01+, avec antenne intégrée	x	1
	Haut-parleur 8 ohms 0,5W pour montage sur circuit imprimé	x	1

Nota : j’ai chois un format CMS pour le régulateur de tension AMS1117, par commodité (car j’en avais « plein » en stock). Qui plus est, j’ai trouvé intéressant de vous glisser ici un composant CMS, histoire de familiariser tous les débutants avec le soudage de ces petits composants, de plus en plus présents ! Surtout que celui-ci est facile à souder 😉

Hormis ces composants, vous aurez besoin d’un petit convertisseur USB/TTL pour programmer l’Arduino Pro Mini, car ce dernier n’est pourvu d’aucun port USB (et vous verrez pourquoi j’ai fait ce choix, après !). Voici au passage le convertisseur que j’ai utilisé de mon côté, mais d’autres peuvent faire également ou mieux l’affaire !

Aperçu	Désignation		Qté	Lien
	Convertisseur USB/TTL (CP2102), pour programmation via IDE Arduino (option USBASP)	x	1

Schéma fonctionnel

Histoire d’y voir un peu plus clair, voici le schéma fonctionnel de cette radiocommande arduino nRF24L01 :

En fait, l’arduino s’occupera quasiment de tout faire ! Car globalement, il permettra :

• La surveillance de la tension de chaque accu li-ion, afin d’alerter l’utilisateur de manière visuelle et sonore, en cas de batterie faible (pour éviter les décharges profondes, pouvant endommager les batteries au lithium ion)
• La lecture de la position du joystick (de ses 2 potentiomètres intégrés, plus précisément, l’un pour l’axe X et l’autre pour l’axe Y)
• La transformation (formatage) de ces valeurs, pour qu’elles correspondent à des « ordres » clairs et précis : haut, bas, gauche, droite, et de quelle intensité
• L’envoi de ces données au module nRF24, pour émission via ondes radio

Schéma électronique

À présent, voyons le schéma électronique de notre projet de radiocommande arduino, histoire de concrétiser tout cela !

Comme vous pourrez le constater, j’ai divisé ce schéma en plusieurs blocs, afin d’en faciliter la compréhension. Ainsi, vous verrez apparaître :

• Une partie alimentation : constituée des piles lithium ion, et du régulateur de tension 3,3 volts
• Une partie capteurs de niveau de tension : constituée de deux ponts diviseurs résistifs (afin de surveiller chaque accu individuellement, pour qu’il ne tombe pas en dessous de 3 volts)
• Une partie pilotage : tout simplement assurée par notre Arduino Pro Mini (modèle 3,3 V et non 5V, attention)
• Une partie émission radio : confiée au module nRF24L01+
• Une partie alarme : permettant d’indiquer visuellement et/ou de manière sonore, que les piles sont faibles, ou simplement trop déchargées
• Une partie commande : essentiellement constituée d’un joystick à 2 axes (X et Y), de type PS2

Pour l’heure, ne vous inquiétez pas si jamais certains de ces blocs ne vous semblent pas clairs. Car nous allons à présent les détailler un à un, sans plus attendre !

Explications de fonctionnement, partie matérielle

À présent, nous allons examiner chaque bloc du schéma électronique précédent en détail, afin que vous puissiez en comprendre chaque partie, et pourquoi j’ai fait tel ou tel choix de composant pour ce projet. Alors en avant !

L’Arduino Pro Mini 3V3

Vous allez certainement vous demander : mais pourquoi avoir pris un Arduino Pro Mini, alors qu’un simple Arduino Nano aurait fait l’affaire ? En fait, la raison est simple : c’est pour avoir un maximum d’autonomie, au niveau des batteries. Car les Arduino dotées de port USB consomment pas mal d’électricité à vide, même s’il n’y a pas de données échangées en USB. En fait, cela vient de leurs convertisseurs USB/série (CH340, CP2102, …), qui sont alimentés en permanence, et consomment « pas mal » de courant à vide. Bien sûr, pour les projets alimentés sur prise de courant ou prise USB, cela ne pose pas de soucis. Mais lorsqu’on fonctionne sur accu, mieux vaut viser l’économie d’énergie ! D’où le choix de l’Arduino Pro Mini, qui n’a pas de convertisseur USB intégré !

À noter que ce choix va complexifier un poil la programmation, si vous n’en n’avez pas l’habitude. Car il faudra utiliser un petit convertisseur USB/série « externe » (qui coûte quelques euros seulement, rassurez-vous), et faire quelques paramétrages particuliers dans l’IDE Arduino. Mais au final, croyez-moi, il n’y a rien de bien sorcier, et surtout, on gagne franchement en autonomie de batteries, en procédant ainsi !

Outre le fait d’avoir choisi un Arduino Pro Mini, j’ai également fait le choix de partir sur un modèle 3,3 volts, et non de 5V. En fait, il y a là aussi une explication simple : comme nous allons nous alimenter via deux accus lithium ion, on n’aura pas suffisamment de tension pour tenir longtemps, en fonctionnant sous 5V. En effet, chaque accu li-ion pourra descendre jusqu’à 3 volts (on évitera de les décharger plus que ça, afin d’éviter de réduire leurs durées de vie trop rapidement). Or, comme nous avons ici 2 accus lithium-ion, cela veut dire que la tension peut descendre à 2 x 3V, soit 6 volts. Et comme la plupart des régulateurs de tension 5V nécessitent 2 volts de plus en entrée (soit 7 volts) pour bien fonctionner, on ne peut pas « fabriquer » du 5V simplement, à partir d’une source sortant 6 volts. Du coup, je suis au final parti sur un Arduino fonctionnant exclusivement en 3,3 volts, pour profiter pleinement du potentiel des batteries lithium ion 😉

Maintenant que nous avons vu ensemble les raisons techniques de ce choix, voyons ce que notre Arduino devra faire :

• Surveiller les niveaux de tension de chaque accu, sur ses entrées analogiques A0 et A1
• Lire les tensions aux bornes du joystick (axe X, axe Y, et bouton poussoir Z), sur les entrées analogiques A2 et A3, et l’entrée digitale D5
• Permettre l’émission de signaux lumineux, via deux LEDS branchées sur les sorties digitales D2 et D3
• Permettre l’émission d’un signal sonore, via un mini haut-parleur PCB, alimenté sur la sortie digitale D6 (en PWM)
• Activer/contrôler le module radio NRF24L01+, via les sorties digitales D7 et D8
• Envoyer des données au module nRF24, via son port SPI (sorties D11, D12, et D13)

Remarque : l’Arduino Pro Mini comprend une rangée de broches, « sur son dessus », permettant sa programmation via PC. Par contre, cela nécessite l’emploi d’un convertisseur USB/TTL « intermédiaire », entre le PC et lui. Mais rassurez-vous : cela se trouve très facilement dans le commerce, et pour pas cher ! Côté programmation avec l’IDE Arduino, vous verrez d’ailleurs que cela ne change pas grand chose (seulement quelques paramètres à modifier). Mais j’avoue, cela peut être quelque peu déroutant au début 😉

L’alimentation (accus lithium-ion 18650)

L’alimentation de notre radiocommande arduino sera confiée à 2 accus lithium ion 18650 mis en série, faisant 3,7 volts chacun, au nominal (3V min / 4,2V max). Une diode anti-retour (D1) protégera notre montage des principaux risques d’inversion de sens de batterie. Et le fusible (F1), quant à lui, assurera une protection rapide et efficace contre tout court-circuit, ou surcharge en courant.

Un petit interrupteur à glissière, monté sur PCB, permettra de couper cette alimentation, lorsque le montage n’est plus utilisé (pour économiser l’énergie au maximum). Enfin, un régulateur linéaire délivrant 3,3 volt assurera une tension adaptée pour alimenter notre microcontrôleur (ATmega328), l’émetteur/récepteur radio (nRF24), … ainsi que tout le reste du montage, d’ailleurs !

Nota : sur le montage final, vous verrez que j’ai utilisé un régulateur 3,3 volts au format CMS (montage en surface). Ceci est dû au fait que j’en avais « pas mal » sous la main, et que cela sera peut être une bonne occasion pour vous, de vous initier à la soudure de composants montés en surface ! Car le boitier de ce régulateur ne comporte pas beaucoup de broches, et n’est pas si petit que ça, au final ! Ce sera donc un excellent exercice pour vous (de souder ce seul et unique composant CMS), si vous débutez en électronique 😉

Capteurs de niveau de tension de cellules (ponts diviseurs de tension)

Afin de pouvoir mesurer des tensions pouvant atteindre 8,4 volts (soit les 2 accus li-ion montés en série, chargés au maximum à 4,2V), il faut nécessairement passer par un dispositif d’abaissement de tension. Car notre Arduino Pro Mini fonctionne en 3,3 volts, et ne pourra pas lire de tensions supérieures à lui, sur ses entrées analogiques.

Pour ce faire, j’ai choisi de faire des ponts résistifs divisant la tension environ par 3 (avec une résistance en ligne de 22 k-ohm, et une résistance pulldown de 10 k-ohm). Appliqué à notre montage, voici ce que cela donne (si on prend l’entrée A0 du microcontrôleur, par exemple) :

V_A0 = V_mid * R2 / (R1 + R2)
d’où V_A0 = V_mid * 10000 / (10000+22000)
d’où V_A0 = 0,3125 * V_mid

De même pour l’équation de V_A1, donnant l’équation : V_A1 = 0,3125 * V_up.

À noter que, comme vous avez pu le constater sur le schéma électronique présenté un peu plus haut, les tensions :

• V_mid correspond à la tension du 1^er accu li-ion
• V_up correspond à la tension des 2 accus li-ion mis en série (on peut donc en déduire la tension du 2^nd accu, en soustrayant cette valeur à la tension du 1^er accu)

On peut facilement vérifier si nos équations sont bonnes, en prenant quelques valeurs (ici, pour le 1^er accu lithium-ion 18650, dont la tension peut aller de 0 à 4,2 volts, si chargé à fond) :

On voit bien ici que la tension maximale sur l’entrée analogique de l’Arduino sera de 1,3125 volts, donc bien en dessous des 3,3 volts d’alimentation. Maintenant, on procède de même, en prenant la deuxième entrée analogique (qui recevra la tension de 2 accus lithium-ion 18650 mis en série (soit 8,4 volts au maximum, si ceux-ci sont chargés à bloc !) :

Là encore, on remarque qu’on est bien en dessous des 3,3 volts qui alimentent notre Arduino Pro Mini. Ainsi, cela confirme que nous pourrons lire ces tensions de batterie sans soucis, et qu’on pourra facilement les interpréter, en entrant ces équations mathématiques en sens inverse dans notre programme arduino !

Remarque : ces valeurs sont purement théoriques. Car dans la réalité, une résistance de 22K ou de 10K ne fera pas exactement 22000 ohms, ou 10000 ohms. Mais une simple mesure à l’ohmmètre permettra de connaître leurs « vraies » valeurs, sans difficulté ! Il s’agira donc de renseigner ces valeurs réelles dans notre programme arduino, et le tour est joué 😉

Émetteur radio nRF24L01+ (version avec antenne intégrée au PCB)

L’émetteur que j’ai choisi pour ce projet est un module NRF24L01+, agissant sur la bande des 2,4 GHz (comme le WiFi). Si j’ai fait ce choix, c’est avant tout pour sa simplicité et fiabilité d’utilisation avec un Arduino. En effet, quelques lignes de codes suffisent pour envoyer tout un tas d’infos ! Alors que demander de mieux ?

Au niveau de ce projet, je suis parti sur un modèle avec « antenne intégrée au PCB », c’est-à-dire un sans antenne extérieure (car inutile ici de vouloir porter à plusieurs centaines de mètres !). Bien sûr, si vous souhaitez piloter un drone ou un avion, un émetteur amplifié tel que le NRF24L01+ PA LNA sera plus approprié. Par contre, gardez bien à l’esprit que plus vous émettrez puissamment, et moins l’autonomie de vos batteries sera grande. Donc tout est question de compromis, en fonction de ce que vous souhaitez piloter !

À noter que la présence d’un condensateur de 100 µF au plus proche de l’alimentation de ce module est requise, afin d’éviter toute variation importante de tension aux bornes de l’alim du module nRF24 (ce qui entrainerait d’importantes perturbations de signal). Donc ne l’oubliez pas, si jamais vous adaptez ce projet !

Nota : le module « NRF24L01+ PA LNA » a le même brochage que le module « NRFL01+ » utilisé ici. En effet, chaque broche correspond exactement d’un modèle sur l’autre. Par contre, le PCB que j’ai réalisé ici ne sera pas forcément adapté à une version avec antenne externe.

Alarmes visuelles et Alerte sonore

Afin d’être alerté en cas de batterie faible ou épuisée, j’ai rajouté 2 LEDS sur le circuit imprimé. Celles-ci permettront d’avoir une indication sur l’état des batteries, si elles commencent à être un peu trop déchargées. Techniquement, ces alertes visuelles sont liées à la tension même des accus. Ainsi :

• Si la tension d’un des accus descend en dessous de 3,3 volts, alors la LED orange s’allumera
• Et si la tension de l’un des accus descend en dessous de 3 volts, alors la LED rouge s’allumera (éteignant la led orange, par la même occasion)

Parallèlement, un long bip sonore vous alertera de manière auditive, en cas de batterie épuisée. Ainsi, même si vous n’avez pas les yeux sur votre radiocommande arduino, vous aurez quand même l’info !

Nota : par sécurité, j’ai paramétré que si jamais la tension d’un des accus venait à descendre en dessous de 3 volts, alors le signal d’émission radio serait automatiquement coupé, afin d’économiser au maximum les batteries. Ainsi, seule la LED rouge resterait allumée, afin de soutirer le moins de courant possible des accus. Par contre, coupez sans attendre votre radiocommande arduino dans ce cas là, pour éviter toute décharge profonde de vos batteries lithium ion ! Sinon leur durée de vie pourrait fortement être raccourcie…

Joystick de commande (type PS2)

Dernier organe composant notre schéma électronique, et non des moindre : le joystick de commande (type PS2), permettant de recueillir les infos de type avancer, reculer, tourner à gauche, ou prendre à droite. Physiquement, ce joystick est composé de 2 potentiomètres, reliés aux 2 axes de mouvement :

• 1 potentiomètre sur l’axe X (gauche/droite)
• 1 potentiomètre sur l’axe Y (haut/bas, ou dans notre cas, avancer/reculer)

Reliés à l’alimentation +3,3V, ces potentiomètres donneront une tension variant entre 0 et 3,3 volts. Et branchés sur les entrées analogiques de notre Arduino, cela se traduira par une valeur comprise entre 0 et 1023 (ces 1023 correspondant aux 3V3). Du coup, on saura que :

• Si le potentiomètre X vaut 0 (valeur minimale), alors l’ordre sera d’aller à droite
• Si le potentiomètre X vaut 1023 (valeur maximale), alors l’ordre sera d’aller à gauche
• Et entre ces extrêmes, on sera plus ou moins à gauche, ou à droite, avec une valeur médiane à 512 (où là, on sera au centre, donc ni à gauche, ni à droite !)

De même pour l’axe Y, où 0 correspondra à la marche avant en vitesse maximale, 1023 la marche arrière en vitesse maximale. Et entre les deux extrêmes, quelque chose de pondéré (avec une vitesse nulle en point médian, lorsque le potentiomètre de l’axe Y donnera une valeur avoisinant les 512).

Au niveau des branchements à l’Arduino, voici comment chaque axe sera raccordé :

À présent, il s’agit d’avoir une petite zone neutre, autour des points médians (lorsque les curseurs du joystick sont centrés, sur l’axe X ou Y). Sinon, les roues de votre voiture radiocommandée pourraient trembler de droite à gauche, et vice-versa. De même pour la marche avant ou arrière, qui pourrait sans cesse osciller. Pour éviter cela, il faut donc créer une « zone morte », où aucun ordre ne sera envoyé, avec une petite marge de positionnement. Là encore, je vais vous illustrer tout cela graphiquement, afin que vous puissiez bien comprendre ce dont je parle :

En fait, j’ai défini une zone (entre 492 et 532), où aucun ordre ne sera envoyé. Ainsi, on compensera les éventuelles erreur de lecture de l’ADC de l’Arduino, ou les éventuelles imprécisions des potentiomètres du joystick. Au final, on obtiendra donc quelque chose de vraiment stable, lorsque le joystick est relâché !

Dernière chose, que vous avez certainement dû remarquer en survolant le graphique ci-dessus : il s’agira d’extraire les commandes avancer, reculer, droite, et gauche de ces valeurs, et de les formater d’une certaine manière, afin de correspondre à des ordres précis. Car au final, voici ce que j’ai cherché à obtenir, avec cette radiocommande arduino :

• Si l’axe X est tout à gauche, alors la consigne « droite/gauche » vaudra -255
• Si l’axe X est tout à droite, alors la consigne « droite/gauche » vaudra +255
• Si l’axe Y est tout en haut, alors la consigne « haut/bas » vaudra +255
• Si l’axe Y est tout en bas, alors la consigne « haut/bas » vaudra -255

Ainsi, le signe « + » ou « – » nous indiquera le sens (avancer ou reculer pour l’axe Y, et droite ou gauche pour l’axe X). Et la valeur pouvant atteindre 255 nous indiquera avec quelle intensité il faudra exécuter cet ordre. Tout simplement 😉

Voilà, je crois que nous avons fait le tour de tout ce qui figurait sur le schéma électronique. À présent, passons à la partie logicielle !

Diagramme de fonctionnement, partie logicielle

Maintenant que nous avons vu en détail la partie matérielle, intéressons-nous à la partie logicielle ! Ce sera d’ailleurs le cœur même de notre montage, ce qui lui donnera vie !

Mais avant de vous montrer quoi que ce soit, au niveau du code de programmation, je vais tout d’abord vous présenter le logigramme de ce projet. Au passage, je vous invite à faire de même pour tous vos projets arduino, car un tel logigramme facilite fortement l’écriture du programme en suivant. Car cela montre étape par étape tout ce que l’arduino devra faire, et du coup, on peut écrire du code très rapidement ensuite. Voici donc le diagramme de notre radiocommande arduino :

En fait, tout ou presque se trouve dans une boucle sans fin (colonne de gauche), qui lit en permanence la valeur des entrées de notre arduino, et agit en conséquence. Au passage, tout ce programme est conditionné par une chose, comme visible dans les « losanges » ci-dessus, à savoir : la tension mesurée aux bornes de chaque accu lithium ion. Car, en effet :

• Si la tension d’un accu li-ion descend en dessous de 3 volts (pour rappel, nous en avons 2 sur ce montage), alors :
  • On allumera la LED rouge
  • On mettra en sommeil l’émetteur radio nRF24L01+ (pour économiser l’énergie des batteries au maximum)
  • On enverra un signal sonore pour indiquer que les accus sont trop déchargés
  • Et on arrêtera le programme
• Si la tension d’un accu lithium ion est compris entre 3 et 3,3 volts, alors :
  • On allumera la LED orange
  • Et on continuera le programme normalement, comme si de rien n’était
• Et si la tension des accus est « bonne » (supérieure à 3,3 volts), alors on exécute le programme principal, indéfiniment, jusqu’à ce que l’opérateur coupe l’alimentation, ou que les piles soient trop faibles (c’est à dire si leur tension descend en dessous de 3 volts).

Code de programmation Arduino

À présent, nous allons voir les lignes de code en elles-mêmes, régissant le fonctionnement global de cette radiocommande arduino. Comme expliqué juste avant, ces lignes ont été rédigées à partir du diagramme précédent, montrant étape par étape, tout ce que l’Arduino devra faire. Du coup, si vous ne l’avez pas encore consulté, je vous invite à faire un petit saut en arrière, pour bien saisir ce qui va suivre !

Voici le programme Arduino, de notre émetteur RC :

/*
   ______               _                  _///  _           _                   _
  /   _  \             (_)                |  __\| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier:      EmetteurRC1
  Description:  Radiocommande arduino NRF24L01+
  Auteur:       Jérôme, Passion-Électronique (https://passionelectronique.fr/)
  Création :    15.04.2021

  Librairie utilisée : https://github.com/nRF24/RF24
*/

//***************//
// Bibliothèques //
//***************//
#include <SPI.h>
#include <RF24.h>

//******************************************************//
// Définition des entrées/sorties de l'Arduino Pro Mini //
//******************************************************//
#define pinLedOrange      2     // [Sortie] Raccordé à la LED orange (batterie faible), s'allumant quand la sortie est mise à 1
#define pinLedRouge       3     // [Sortie] Raccordé à la LED rouge (batterie "vide"), s'allumant quand la sortie est mise à 1
#define pinBpJoystick     5     // [Entrée] Lorsqu'on appuie au centre du joystick, ce BP est activé (actif à l'état bas)
#define pinHautParleur    6     // [Sortie] Raccordé au HAUT PARLEUR monté sur PCB (émission sonore en PWM)
#define pinCE_RF24        7     // On associe la broche "CE" du NRF24L01 à la pin D7 de l'arduino
#define pinCSN_RF24       8     // On associe la broche "CSN" du NRF24L01 à la pin D8 de l'arduino

#define pinVbattMid       A0    // [Entrée] Mesure la tension entre les 2 accus li-ions mis en série (donne la tension du 1er accu, en fait)
#define pinVbattUp        A1    // [Entrée] Mesure la tension totale des 2 accus lihium ion, mis en série
#define pinAxeX_joystick  A2    // [Entrée] Mesure la tension du potentiomètre d'axe X du joystick
#define pinAxeY_joystick  A3    // [Entrée] Mesure la tension du potentiomètre d'axe Y du joystick

//*************************************************//
// Définition des paramètres généraux du programme //
//*************************************************//
#define tunnel  "REA01"             // Déclaration d'un "nom de tunnel" (5 caractères), pour pouvoir communiquer d'un NRF24 à l'autre

#define valeurResistanceR1 21900    // À remplacer par la valeur réellement mesurée de la résistance R1 à l'ohmmètre, pour plus de précision (22000 ohms par défaut)
#define valeurResistanceR2 9930     // À remplacer par la valeur réellement mesurée de la résistance R2 à l'ohmmètre, pour plus de précision (10000 ohms par défaut)
#define valeurResistanceR3 21800    // À remplacer par la valeur réellement mesurée de la résistance R3 à l'ohmmètre, pour plus de précision (22000 ohms par défaut)
#define valeurResistanceR4 9920     // À remplacer par la valeur réellement mesurée de la résistance R4 à l'ohmmètre, pour plus de précision (10000 ohms par défaut)

#define tensionAlimArduino          3.3     // Tension d'alimentation de l'Arduino Pro Mini 3V3
#define frequenceSonBatterieFaible  2000    // Fréquence du signal sonore qui sera émis, en cas de batterie faible
#define dureeSignalSonore           4000    // Durée de l'alarme sonore, exprimée en milli-secondes
#define frequenceBipsSonores        1000    // Fréquence des bips sonores, émis au démarrage au programme (autotest)
#define dureeBipsSonores            50      // Durée de ces bips sonores, exprimée en milli-secondes

//***************************//
// Instanciation des classes //
//***************************//
RF24 radio(pinCE_RF24, pinCSN_RF24);    // Instanciation du NRF24L01


//************************//
// Variables du programme //
//************************//
const byte adresse[6] = tunnel;         // Mise au format "byte array" du nom du tunnel

int etatBPjoystick;         // Variable 16 bits, indiquant l'état du BP du joystick (valeur : HIGH ou LOW, soit 1 ou 0)
int valVbattMid;            // Variable 16 bits, qui contiendra une lecture 10 bits (0..1023), représentant la tension du 1er accu lithium ion
int valVbattUp;             // Variable 16 bits, qui contiendra une lecture 10 bits (0..1023), représentant la tension totale des 2 accus li-ion
int valPotX;                // Variable 16 bits, qui contiendra une lecture 10 bits (0..1023), représentant la tension du point milieu du potentiomètre d'axe X
int valPotY;                // Variable 16 bits, qui contiendra une lecture 10 bits (0..1023), représentant la tension du point milieu du potentiomètre d'axe Y

float tensionBatt1;             // Variable de calcul, qui donnera la tension de l'accu li-ion n°1
float tensionBatt2;             // Variable de calcul, qui donnera la tension de l'accu li-ion n°2

//*************************************************************//
// Ensemble des données à envoyer, par ondes radio (structure) //
//*************************************************************//
struct DonneesAenvoyer {
  int valAvancerReculer;     // int = 2 octets (0..65535), utilisés de -255 à +255  (-255 signifie ici reculer à vitesse maximale, et +255, avancer à vitesse maximale)
  int valDroiteGauche;       // int = 2 octets (0..65535), utilisés de -255 à +255  (-255 signifie ici tourner à gauche pleinement, et +255, signifie tourner pleinement à droite)
};
DonneesAenvoyer donnees;


//*******//
// SETUP //
//*******//
void setup() {
  
  // Définition du "sens" des entrées/sorties de notre Arduino Pro Mini
  pinMode(pinLedOrange, OUTPUT);      // Sortie LED orange
  pinMode(pinLedRouge, OUTPUT);       // Sortie LED rouge
  pinMode(pinBpJoystick, INPUT);      // Entrée BP joystick
  pinMode(pinHautParleur, OUTPUT);    // Sortie HAUT-PARLEUR (pwm)
  
  // Activation de la résistance de pull-up interne à l'Arduino, sur l'entrée "BP joystick"
  digitalWrite(pinBpJoystick, HIGH);

  // Allumage/extinction des LEDS, et émission de 3 bips sur le HP (autotest démarrage)
  checkUpLedsEtHP();
  
  // Démarrage/paramétrages du module NRF24L01+ 
  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" d'émission, pour communiquer (car pas besoin d'une forte puissance ici, pour nos essais)
  radio.stopListening();              // Arrêt de l'écoute du nRF24 (signifiant qu'on va émettre, et non recevoir, ici)
}

//**************************//
// Boucle principale : LOOP //
//**************************//
void loop() {
  
  // Lecture des entrées numériques et analogiques
  etatBPjoystick = digitalRead(pinBpJoystick);
  valVbattMid = analogRead(pinVbattMid);
  valVbattUp = analogRead(pinVbattUp);
  valPotX = analogRead(pinAxeX_joystick);
  valPotY = analogRead(pinAxeY_joystick);

  // Détermination de la tension de chaque accu lithium ion (avec corrections, dû aux ponts diviseurs de tension)
  tensionBatt1 = (float)valVbattMid / 1023 * tensionAlimArduino * (valeurResistanceR1 + valeurResistanceR2) / valeurResistanceR2;
  tensionBatt2 = (float)(valVbattUp - valVbattMid) / 1023 * tensionAlimArduino * (valeurResistanceR3 + valeurResistanceR4) / valeurResistanceR4;

  // Détermination des actions à mener, suivant l'état des batteries
  if(min(tensionBatt1, tensionBatt2) < 3.0) {               // Si la tension d'un accu est inférieure à 3 volt, on allume la LED rouge, et on stoppe tout
    AllumerLedRouge();
    StopperProgramme();
  }
  else if(min(tensionBatt1, tensionBatt2) < 3.3) {          // Sinon, si la tension d'un accu est inférieure à 3.3 volt, on allume la LED orange, et on continue normalement
    AllumerLedOrange();
    EnvoyerDonneesRadio();
  }
  else {
    EnvoyerDonneesRadio();                                  // Sinon encore, on continue normalement
  }

  // Et on boucle à l'infini !
}

//******************************//
// Fonction : checkUpLedsEtHP() //
//******************************//
void checkUpLedsEtHP() {
  // Allumage puis extinction des LEDs orange et rouge
  digitalWrite(pinLedOrange, HIGH);
  digitalWrite(pinLedRouge, HIGH);
  delay(300);
  digitalWrite(pinLedOrange, LOW);
  digitalWrite(pinLedRouge, LOW);

  // Émission de 3 bips courts sur le HP
  for (int i = 0; i < 3; i++) {
    tone(pinHautParleur, frequenceBipsSonores, dureeBipsSonores);
    delay(dureeBipsSonores*2);
  }
}

//*******************************//
// Fonction : AllumerLedOrange() //
//*******************************//
void AllumerLedOrange() {
  digitalWrite(pinLedOrange, HIGH);
  digitalWrite(pinLedRouge, LOW);
}

//******************************//
// Fonction : AllumerLedRouge() //
//******************************//
void AllumerLedRouge() {
  digitalWrite(pinLedRouge, HIGH);
  digitalWrite(pinLedOrange, LOW);
}

//*******************************//
// Fonction : StopperProgramme() //
//*******************************//
void StopperProgramme() {
  radio.powerDown();                                                    // Mise en sommeil du NRF24L01+
  tone(pinHautParleur, frequenceSonBatterieFaible, dureeSignalSonore);  // Émission d'un signal sonore
  while(1) {}                                                           // Suspension de l'exécution du programme
}

//**********************************//
// Fonction : EnvoyerDonneesRadio() //
//**********************************//
void EnvoyerDonneesRadio() {
  
  // ************************************************************************************
  // Formatage des données, à partir des valeurs recueillies sur le potentiomètre d'axe X
  // ************************************************************************************
  if(valPotX > 532)         donnees.valDroiteGauche = map(valPotX, 532, 1023, 0, -255);     // Info : tourner à gauche
  else if(valPotX < 492)    donnees.valDroiteGauche = map(valPotX, 0, 492, 255, 0);         // Info : tourner à droite
  else                      donnees.valDroiteGauche = 0;

  // *****************
  // Idem pour l'axe Y
  // *****************
  if(valPotY > 532)         donnees.valAvancerReculer = map(valPotY, 532, 1023, 0, -255);   // Info : reculer
  else if(valPotY < 492)    donnees.valAvancerReculer = map(valPotY, 0, 492, 255, 0);       // Info : avancer
  else                      donnees.valAvancerReculer = 0;

  // **************************************************
  // Puis, on envoie toutes ces données par ondes radio
  // **************************************************
  radio.write(&donnees, sizeof(donnees));
}

Globalement, ce code de programmation arduino suit à peu de chose près le logigramme présenté précédemment. On retrouve ainsi :

• La partie initialisation (le début, incluant la fonction « Setup »)
• La boucle principale (la boucle « Loop », et les sous-fonctions afférentes), permettant de faire :
  • La lecture de toutes les entrées qui nous intéressent, sur notre Arduino Pro Mini
  • La détermination de la tension de chaque accu
  • Et le lancement de telle ou telle fonction, en fonction de la tension de chaque accu (c’est à dire : faire un choix entre émettre normalement, afficher une alarme « batteries faibles », ou carrément interrompre le programme, en cas de batteries « vides »)

Comme vous le verrez, j’ai rajouté un maximum de commentaires dans ce code, pour faciliter sa compréhension. Qui plus est, j’ai scindé le code en plusieurs sous-fonctions, afin d’apporter plus de clarté. Bien sûr, ce programme n’est certes pas optimisé, mais comporte un maximum d’éléments explicatifs, pour tous ceux qui veulent comprendre précisément comment fonctionne cette radiocommande arduino nRF24L01+.

Programmation de l’Arduino Pro Mini

Une petite parenthèse, sur la programmation de l’Arduino Pro Mini. Car celui-ci n’est pas doté de prise USB, permettant sa programmation. Mais rassurez-vous, car un simple petit appareil entre votre PC et cet Arduino vous permettra de le programmer (et ce petit objet ne coûte que quelques euros seulement, et vous servira « à vie » !).

Mais tout d’abord, il faut commencer par configurer son IDE arduino. Pour ce faire, aller dans le menu Outils > Type de carte > Arduino AVR Boards, et sélectionnez « Arduino Pro or Pro Mini », comme visible ci-dessous :

Ensuite, vous devrez sélectionner le bon modèle que vous prévoyez d’utiliser. Ici, j’utilise un Arduino Pro Mini fonctionnant en 3,3 volts, qui fonctionne avec un microcontrôleur Atmel 328P, cadencé à 8 MHz. Et ce sont ces dernière infos, qu’il faut également paramétrer dans notre IDE arduino. Pour cela, il suffit d’aller dans le menu Outils > Processeur, et sélectionner « ATmega 328P (3.3V 8 MHz) » (voir ci-dessous).

Enfin, il s’agira également de choisir le bon programmateur, en allant dans le menu Outils > Programmateur, et en sélectionnant « USBasp ».

Comme indiqué un peu plus haut, vous aurez besoin d’un petit « objet » pour connecter votre Arduino Pro Mini à votre ordinateur. Cet objet est tout simplement un convertisseur USB/série (ou USB/TTL, ou encore USB/UART). Il permet de faire le lien entre les broches RX et TX de votre Arduino, et le port USB de votre PC. D’ailleurs, au niveau câblage, voici ce que vous devrez réaliser (à noter que celui-ci est à adapter en fonction du type de programmateur physique que vous choisirez).

Bien évidemment, il faudra préalablement installer les pilotes de votre convertisseur USB/TTL, afin que votre ordi vous indique clairement quel sera le port USB nouvellement utilisable.

Pour le modèle que j’utilise ici (un convertisseur USB/TTL CP2102), vous pouvez vous référer à un autre article que j’avais déjà écrit, à l’intérieur duquel j’avais déjà détaillé toute la partie installation de cet élément (lien vers : paramétrage du convertisseur USB-série DSD Tech). À noter qu’il existe ici plusieurs façons de faire pour arriver au même résultat (pour programmer un Arduino Pro Mini, j’entends). Mais surtout, ne vous découragez pas si vous butez un peu sur cette partie. Car une fois que vous aurez tout correctement installé, et pris le coup, alors tout vous semblera être comme un jeu d’enfant ! Donc n’abandonnez pas, si jamais vous n’arrivez pas à tout comprendre ou reproduire du premier coup !

Au passage, n’oubliez pas de :
– bien sélectionner le port USB correspondant à votre convertisseur USB/TTL (à renseigner dans le menu « Outils > Port » de l’IDE Arduino)
– bien appuyer sur le bouton RESET de l’Arduino Pro Mini, environ « au milieu » du téléversement du programme (car la programmation ne pourra réellement commencer que lorsque le redémarrage de l’Arduino aura été détecté, si je puis dire)

Si la programmation s’est bien passée, vous devriez voir apparaître quelque chose comme ça, dans l’IDE Arduino (si vous avez comme moi coché l’option « Téléversement », dans le menu Fichier > Préférences, partie « Afficher les résultats détaillés pendant… ») :

Le croquis utilise 5032 octets (16%) de l'espace de stockage de programmes. Le maximum est de 30720 octets.
Les variables globales utilisent 79 octets (3%) de mémoire dynamique, ce qui laisse 1969 octets pour les variables locales. Le maximum est de 2048 octets.
C:\Users\JEROME\Documents\ArduinoData\packages\arduino\tools\avrdude\6.3.0-arduino17/bin/avrdude -CC:\Users\JEROME\Documents\ArduinoData\packages\arduino\tools\avrdude\6.3.0-arduino17/etc/avrdude.conf -v -patmega328p -carduino -PCOM7 -b57600 -D -Uflash:w:C:\Users\JEROME\AppData\Local\Temp\arduino_build_567933/EmetteurRC1.ino.hex:i 

avrdude: Version 6.3-20190619
         Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
         Copyright (c) 2007-2014 Joerg Wunsch

         System wide configuration file is "C:\Users\JEROME\Documents\ArduinoData\packages\arduino\tools\avrdude\6.3.0-arduino17/etc/avrdude.conf"

         Using Port                    : COM7
         Using Programmer              : arduino
         Overriding Baud Rate          : 57600
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0xbc
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 2 of 10: not in sync: resp=0xbc
         AVR Part                      : ATmega328P
         Chip Erase delay              : 9000 us
         PAGEL                         : PD7
         BS2                           : PC2
         RESET disposition             : dedicated
         RETRY pulse                   : SCK
         serial program mode           : yes
         parallel program mode         : yes
         Timeout                       : 200
         StabDelay                     : 100
         CmdexeDelay                   : 25
         SyncLoops                     : 32
         ByteDelay                     : 0
         PollIndex                     : 3
         PollValue                     : 0x53
         Memory Detail                 :

                                  Block Poll               Page                       Polled
           Memory Type Mode Delay Size  Indx Paged  Size   Size #Pages MinW  MaxW   ReadBack
           ----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
           eeprom        65    20     4    0 no       1024    4      0  3600  3600 0xff 0xff
           flash         65     6   128    0 yes     32768  128    256  4500  4500 0xff 0xff
           lfuse          0     0     0    0 no          1    0      0  4500  4500 0x00 0x00
           hfuse          0     0     0    0 no          1    0      0  4500  4500 0x00 0x00
           efuse          0     0     0    0 no          1    0      0  4500  4500 0x00 0x00
           lock           0     0     0    0 no          1    0      0  4500  4500 0x00 0x00
           calibration    0     0     0    0 no          1    0      0     0     0 0x00 0x00
           signature      0     0     0    0 no          3    0      0     0     0 0x00 0x00

         Programmer Type : Arduino
         Description     : Arduino
         Hardware Version: 2
         Firmware Version: 1.16
         Vtarget         : 0.0 V
         Varef           : 0.0 V
         Oscillator      : Off
         SCK period      : 0.1 us

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: reading input file "C:\Users\JEROME\AppData\Local\Temp\arduino_build_567933/EmetteurRC1.ino.hex"
avrdude: writing flash (5032 bytes):

Writing | ################################################## | 100% 1.38s

avrdude: 5032 bytes of flash written
avrdude: verifying flash memory against C:\Users\JEROME\AppData\Local\Temp\arduino_build_567933/EmetteurRC1.ino.hex:
avrdude: load data flash data from input file C:\Users\JEROME\AppData\Local\Temp\arduino_build_567933/EmetteurRC1.ino.hex:
avrdude: input file C:\Users\JEROME\AppData\Local\Temp\arduino_build_567933/EmetteurRC1.ino.hex contains 5032 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 1.03s

avrdude: verifying ...
avrdude: 5032 bytes of flash verified

avrdude done.  Thank you.

Nota : comme évoqué précédemment, il a fallu que j’appuie sur le bouton « reset » de mon Arduino Pro Mini, pour que la programmation se fasse (sinon, le téléversement tourne dans le vide, au bout d’un moment). D’ailleurs, on le voit bien ici, avec les lignes « avrdude: stk500_recv(): programmer is not responding ». Cela montre que l’Arduino n’était pas prêt à recevoir une nouvelle programmation, et que par conséquence, il était en attente d’un appui sur son bouton RESET pour se faire programmer. Une fois fait, le reste à suivi. Tout simplement 😉

Fabrication radiocommande arduino (avec fichier Gerber)

Voilà, nous arrivons à la fin de cet article, avec la partie réalisation du PCB ! Pour ma part, le schéma électronique a été réalisé avec le logiciel EasyEDA (gratuit). Celui-ci m’a d’ailleurs permis de créer un fichier de fabrication GERBER, que j’ai ensuite pu faire réaliser chez JCLPCB.

Pour ceux qui veulent reproduire cette radiocommande arduino à l’identique, voici un lien vers le fichier Gerber de ce projet. Ce fichier contient tous les éléments pour réaliser ce PCB : Fichier GERBER projet « Radiocommande Arduino NRF24L01 (émetteur RC1) »

Au niveau du circuit imprimé en lui-même, voici comment il se présente (nota : il s’agit là d’une version mise à jour, la v1.2) :

Concernant la soudure des composants, il n’y a rien de compliqué. Comme d’habitude, je vous recommande de souder les composants les plus petits d’abord, pour finir par les plus gros. À noter qu’un composant CMS s’est glissé dans ce montage, à souder en premier. Mais je vous rassure : il est super simple à souder, même avec un fer à souder « traditionnel ». Donc pas de stress 😉

Une fois les composants soudés, voici ce que j’ai pu obtenir, de mon côté (version initiale du montage, avec le convertisseur USB/TTL branché dessus, pour la programmation de l’Arduino Pro Mini) :

Attention : les accus lithium ion sont tous montés dans le même sens, c’est-à-dire leurs « + » en haut, et leurs « – » en bas, si je puis dire ! Faites très attention à leur sens de montage, et à ne surtout pas les brancher à l’envers par mégarde ! Par ailleurs, vérifiez bien tout vos branchements, polarités, et soudures avant de mettre quoi que ce soit sous tension. Toujours !

Essais et conclusion

Nous voici quasiment au terme de cet article, visant à créer une radiocommande arduino à base d’nRF24L01. Car il nous reste plus qu’à faire les essais de cet émetteur RC, et c’est fini !

Pour ce faire, j’ai créé un autre petit programme arduino, qui servira de récepteur de test. Pour ma part, je me suis servi d’un Arduino Uno, qui hébergera ce programme, et affichera sur le port série toutes les infos reçues, émises par notre radiocommande arduino.

Voici d’ailleurs ce bout de code :

/*
   ______               _                  _///  _           _                   _
  /   _  \             (_)                |  __\| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier:      RecepteurRC1
  Description:  Récepteur de test, pour radiocommande arduino NRF24L01+
  Auteur:       Jérôme, Passion-Électronique (https://passionelectronique.fr/)
  Création :    16.04.2021

  Librairie utilisée : https://github.com/nRF24/RF24
*/

//***************//
// Bibliothèques //
//***************//
#include <SPI.h>
#include <RF24.h>

//******************************************************//
// Définition des entrées/sorties de l'Arduino Pro Mini //
//******************************************************//
#define pinCE_RF24        7     // On associe la broche "CE" du NRF24L01 à la pin D7 de l'arduino
#define pinCSN_RF24       8     // On associe la broche "CSN" du NRF24L01 à la pin D8 de l'arduino

//*************************************************//
// Définition des paramètres généraux du programme //
//*************************************************//
#define tunnel  "REA01"             // Déclaration d'un "nom de tunnel" (5 caractères), pour pouvoir communiquer d'un NRF24 à l'autre

//***************************//
// Instanciation des classes //
//***************************//
RF24 radio(pinCE_RF24, pinCSN_RF24);    // Instanciation du NRF24L01


//************************//
// Variables du programme //
//************************//
const byte adresse[6] = tunnel;         // Mise au format "byte array" du nom du tunnel

//**************************************************************//
// Ensemble des données à recevoir, par ondes radio (structure) //
//**************************************************************//
struct DonneesArecevoir {
  int valAvancerReculer;     // int = 2 octets (0..65535), utilisés de -255 à +255  (-255 signifie ici reculer à vitesse maximale, et +255, avancer à vitesse maximale)
  int valDroiteGauche;       // int = 2 octets (0..65535), utilisés de -255 à +255  (-255 signifie ici tourner à gauche pleinement, et +255, signifie tourner pleinement à droite)
};
DonneesArecevoir donnees;


//*******//
// SETUP //
//*******//
void setup() {

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

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

//**************************//
// Boucle principale : LOOP //
//**************************//
void loop() {

  // On vérifie à chaque boucle si des données sont arrivées
  if (radio.available()) {
    radio.read(&donnees, sizeof(donnees));                        // Si des données viennent d'arriver, on les charge dans la structure nommée "donnees"
    Serial.print("[Données reçues] valAvancerReculer = ");        // … et on affiche tout ça sur le port série !
    Serial.print(donnees.valAvancerReculer);
    Serial.print(" | valDroiteGauche = ");
    Serial.println(donnees.valDroiteGauche);
  }

  // Et on boucle à l'infini !
}

Au niveau du montage, voici comment mon récepteur de test se présente (pour le câblage, j’ai repris celui que j’avais fait dans mon tutorial sur le nRF24) :

Au niveau des correspondances du module nRF24L01+ avec l’Arduino Uno, voici comment se présentent les choses :

• VCC (du NRF24L01+) : relié au +3,3V (de l’Arduino Uno)
• GND : relié au GND
• CE : relié à la broche D7
• CSN : relié à la broche D8
• SCK : relié à la broche D13
• MOSI : relié à la broche D11
• MISO : relié à la broche D12
• IRQ : non raccordé

Enfin, voici ce qui apparaît sur le moniteur série de l’IDE Arduino (données reçues sur l’Arduino Uno, monté en récepteur de test, donc) :

Voilà ! Tout fonctionne à merveille ! Maintenant, à vous de réaliser ce montage électronique à l’identique, si le coeur vous en dit, ou de l’adapter à vos besoins, si besoin est ! Dans tous les cas, cette radiocommande arduino pourra être le socle de bon nombre d’appareils télécommandés, comme de petites voitures radiocommandées ou autre. Alors faites vous plaisir !

Et comme je le rappelle toujours aussi : libre à vous de vous inspirer de tout ceci pour créer vos propres montages ! Car c’est aussi le but de tous les articles que je publie ici, sur ce site ! Alors laissez aller votre imagination, et concrétisez vos rêves 😉

Voici ce qui conclut cet article, sur comment fabriquer une radiocommande arduino NRF24L01. J’espère que vous aurez pu apprendre un maximum de choses ici, afin d’enrichir tous vos futurs projets ! Pour ma part, il ne me reste plus qu’à vous dire à très bientôt !

Jérôme.

À découvrir également : exemple de voiture radiocommandée arduino (modèle à 3 roues)

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 !

(*) Mis à jour le 11/12/2021