Construire un récepteur RC Arduino fiable pour modèles et projets

Dans ce tutoriel, nous allons apprendre à réaliser un récepteur RC basé sur Arduino. Depuis la construction de mon émetteur RC Arduino DIY dans une vidéo précédente, j'ai reçu de nombreuses demandes pour créer un récepteur dédié, le voici donc.

Vous pouvez regarder la vidéo suivante ou lire le tutoriel écrit ci-dessous.

Ces deux appareils peuvent désormais communiquer facilement et nous pouvons les utiliser pour contrôler de nombreux projets sans fil. J'expliquerai le fonctionnement à travers plusieurs exemples. Dans le premier, nous utiliserons ce récepteur RC Arduino pour contrôler une voiture simple composée de deux moteurs DC. Dans le second, je montrerai comment contrôler des moteurs brushless et des servos, composants courants dans de nombreux modèles RC commerciaux (avions, bateaux, voitures). Si nous savons les contrôler, nous pouvons facilement modifier et piloter de nombreux modèles RC avec notre propre émetteur Arduino personnalisé.

Construire un récepteur RC Arduino fiable pour modèles et projets

En troisième exemple, je montrerai comment j'ai modifié et utilisé ce système RC Arduino pour contrôler une voiture RC commerciale.

Schéma du circuit du récepteur RC Arduino

Commençons par examiner le schéma du circuit. La communication radio repose sur les modules transcepteurs NRF24L01.

L'émetteur envoie en permanence les données de ses contrôleurs (joysticks, boutons, potentiomètres, interrupteurs) et nous recevons ces données avec le récepteur. Pour plus de détails sur le fonctionnement de cet émetteur Arduino, consultez mon autre tutoriel détaillé.

Notons que ce récepteur RC ne fonctionne pas uniquement avec cet émetteur particulier. Il peut fonctionner avec toute autre configuration similaire composée d'une carte Arduino et d'un module NRF24L01.

Le cœur de ce récepteur RC est une carte Arduino Pro Mini. Pour l'alimentation, nous pouvons utiliser soit la broche VCC (5V), soit la broche RAW (6 à 12V). Il existe deux versions de l'Arduino Pro Mini : celle utilisée ici fonctionne en 5V, l'autre en 3.3V. Le module NRF24L01 fonctionne en 3.3V, nous avons donc besoin d'un régulateur de tension. J'utilise ici le régulateur AMS1117 qui fournit 3.3V à partir d'une entrée de 5V à 12V.

Vous pouvez obtenir les composants nécessaires pour ce récepteur RC Arduino via les liens ci-dessous :

Module transcepteur NRF24L01
NRF24L01 + PA + LNA
Régulateur de tension AMS1117 3.3V
Connecteurs mâles + femelles Amazon / Banggood / AliExpress
Arduino Pro Mini
Arduino Pro Mini comme celui utilisé

Pour la communication avec l'Arduino, le module NRF24L01 utilise le protocole SPI, plus deux broches numériques supplémentaires. Il nous reste ainsi 9 broches numériques utilisables comme canaux de sortie, dont les broches RX et TX. Notez que ces broches doivent être déconnectées lors du téléversement du sketch, c'est pourquoi j'ai prévu des connecteurs séparés pour les connecter ou les déconnecter. Nous pouvons également utiliser les entrées analogiques comme sorties numériques, offrant ainsi de nombreux canaux disponibles malgré la petite taille de la carte.

Conception du PCB

Pour garder le circuit compact, j'ai conçu un PCB personnalisé avec le logiciel gratuit EasyEDA. J'ai disposé les 8 canaux à côté d'un rail 5V et d'un rail Ground, permettant de connecter directement servos et ESC. Le canal 9 est positionné près de la broche VCC de l'Arduino, utile pour alimenter l'Arduino via le BEC (Battery Eliminator Circuit) d'un ESC qui fournit 5V. Bien sûr, n'importe quel autre canal pourrait servir à cet usage, la broche VCC étant connectée au rail 5V.

Les canaux 7 et 8 sont interrompus par des connecteurs : pour les utiliser, il suffit de relier les deux broches. L'en-tête de programmation se trouve en haut à droite et le condensateur de 100µF sert à la fois au régulateur et au module NRF24L01. En bas à gauche du PCB, j'ai placé les broches analogiques.

Notez que certaines cartes Arduino Pro Mini peuvent avoir un agencement de broches différent, j'ai donc inclus une seconde version du PCB pour choisir celle correspondant à votre carte.

Voici le lien vers les fichiers du projet PCB. Une fois la conception terminée, j'ai généré les fichiers Gerber nécessaires à la fabrication.

Fichiers Gerber :

J'ai commandé le PCB chez JLCPCB, qui sponsorise également cette vidéo.

Il suffit de glisser-déposer le fichier Gerber, de le vérifier dans le visualiseur, de sélectionner les propriétés souhaitées et de commander à un prix raisonnable. Pour une première commande chez JLCPCB, vous pouvez obtenir jusqu'à 5 PCB pour seulement 2$.

Assemblage du PCB

Après quelques jours, les PCB sont arrivés. La qualité est excellente, tout correspond exactement au design.

Passons à l'assemblage. Commencez par souder les connecteurs de la carte Arduino. Une plaque d'essai (breadboard) permet de maintenir les connecteurs en place pendant le soudage. Selon votre carte, les broches peuvent varier légèrement, faites attention lors du soudage.

Certaines broches Ground doivent rester libres car des pistes passent dessous sur le PCB. Une fois l'Arduino soudé, j'ai coupé l'excédent des broches.

Ensuite, j'ai mis en place tous les autres connecteurs. Il faut des connecteurs mâles et femelles, mais le choix vous appartient. Cependant, il est judicieux d'utiliser des connecteurs mâles pour les canaux numériques car les servos et ESC ont des connecteurs femelles, facilitant la connexion.

Le régulateur de tension est un composant CMS, j'ai utilisé de la pâte adhésive bleue pour le maintenir en place pendant le soudage. Enfin, après avoir soudé les deux condensateurs, on peut fixer le module NRF24L01 sur les connecteurs appropriés.

Selon l'application et la portée souhaitée, on peut utiliser soit le module standard avec antenne intégrée, soit celui avec antenne externe permettant une communication jusqu'à 700 mètres en espace ouvert. Notre récepteur RC Arduino est maintenant prêt à l'emploi.

Pour programmer le récepteur ou connecter l'Arduino Pro Mini à l'ordinateur, on utilise une interface USB vers UART série connectée à l'en-tête de programmation.

Dans le menu Outils de l'IDE Arduino, sélectionnez la carte Arduino Pro ou Pro Mini, la version du processeur appropriée, le port et la méthode de programmation « USBasp ».

Nous pouvons maintenant téléverser le code sur l'Arduino.

Exemple 1 – Voiture RC Arduino

Passons au premier exemple.

Il s'agit d'une voiture simple avec deux moteurs DC 12V, déjà présentée dans mes vidéos précédentes.

Voir aussi : Pilote de moteur L298N – Interface Arduino, Fonctionnement, Codes, Schémas

Cette fois, nous utiliserons notre nouveau récepteur RC Arduino pour la contrôler. Pour piloter les moteurs DC, nous utilisons le pilote L298N et pour l'alimentation, 3 batteries Li-ion fournissant environ 12V.

Composants nécessaires pour cet exemple :

Pilote L298N
Moteur DC 12V couple élevé
Moteur DC avec roue en plastique
Plaque d'essai et fils de liaison

Les connexions sont simples : le 12V des batteries va sur la broche 12V du récepteur, et les 6 broches de contrôle du pilote vont sur 6 canaux. Pour contrôler la vitesse des moteurs, il faut envoyer un signal PWM sur les broches Enable A et Enable B du pilote. Sur notre récepteur, les canaux 2, 3, 6 et 9 peuvent sortir du PWM, j'ai donc connecté les broches Enable aux canaux 2 et 6.

Examinons maintenant le code Arduino.

/* Récepteur RC Arduino - Exemple Voiture par Dejan, www.HowToMechatronics.com Bibliothèque: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define enA 9 // Broche Arduino D9 - CH6 sur PCB - sortie PWM
#define in1 8 // D8 - CH5
#define in2 7 // D7 - CH4
#define in3 6 // D6 - CH3
#define in4 4 // D4 - CH1
#define enB 5 // D5 - CH2 - sortie PWM
RF24 radio(3, 2); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
// Taille max de cette structure : 32 octets
struct Data_Package {
  byte j1PotX;
  byte j1PotY;
  byte j1Button;
  byte j2PotX;
  byte j2PotY;
  byte j2Button;
  byte pot1;
  byte pot2;
  byte tSwitch1;
  byte tSwitch2;
  byte button1;
  byte button2;
  byte button3;
  byte button4;
};
Data_Package data;
int steering, throttle;
int motorSpeedA = 0;
int motorSpeedB = 0;
void setup() {
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  //Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.startListening();
  resetData();
}
void loop() {
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) {
    resetData();
  }
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package));
    lastReceiveTime = millis();
  }
  throttle = data.j1PotY;
  steering = data.j1PotX;
  if (throttle < 110) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    motorSpeedA = map(throttle, 110, 0, 0, 255);
    motorSpeedB = map(throttle, 110, 0, 0, 255);
  } else if (throttle > 140) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    motorSpeedA = map(throttle, 140, 255, 0, 255);
    motorSpeedB = map(throttle, 140, 255, 0, 255);
  } else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  if (steering < 110) {
    int xMapped = map(steering, 110, 0, 0, 255);
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    if (motorSpeedA < 0) motorSpeedA = 0;
    if (motorSpeedB > 255) motorSpeedB = 255;
  }
  if (steering > 140) {
    int xMapped = map(steering, 140, 255, 0, 255);
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    if (motorSpeedA > 255) motorSpeedA = 255;
    if (motorSpeedB < 0) motorSpeedB = 0;
  }
  if (motorSpeedA < 70) motorSpeedA = 0;
  if (motorSpeedB < 70) motorSpeedB = 0;
  analogWrite(enA, motorSpeedA);
  analogWrite(enB, motorSpeedB);
}
void resetData() {
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}

Description : On inclut d'abord les bibliothèques SPI et RF24, on définit les broches, l'objet radio et la structure de données pour stocker les données entrantes de l'émetteur. Dans setup(), on définit les sorties et on initialise la communication radio. Pour plus de détails, consultez mon tutoriel détaillé sur le NRF24L01.

Dans loop(), on vérifie constamment la réception de données. Si on en reçoit, on les lit. Un coup d'œil au code de l'émetteur montre qu'il envoie un paquet unique contenant les valeurs de tous ses contrôleurs.

Une fois les données lues, on les utilise comme on veut. Ici, l'axe Y du Joystick 1 contrôle l'accélérateur et l'axe X le braquage. Les valeurs des joysticks vont de 0 à 255. Si on baisse le joystick, on configure le pilote pour reculer et on utilise la valeur d'accélérateur pour la vitesse. Même principe pour avancer, tourner gauche/droite. La fonction resetData() en bas du code remet toutes les valeurs par défaut en cas de perte de communication, arrêtant la voiture.

Exemple 2 – Contrôle servos et moteurs brushless avec le récepteur RC Arduino

Passons au second exemple : contrôler des servos et moteurs brushless avec ce récepteur RC Arduino.

Pour contrôler un moteur brushless, il faut un ESC (Electronic Speed Controller). L'Arduino communique avec l'ESC via une seule broche, en envoyant un signal PWM spécifique. L'ESC fournit aussi 5V via son BEC, permettant d'alimenter le récepteur.

Voir aussi : Tutoriel contrôle moteur brushless Arduino | ESC | BLDC

Les servomoteurs ont le même type de connexion que les ESC et peuvent être branchés sur n'importe quel canal disponible.

Composants nécessaires :

Moteur brushless
ESC 30A
Batterie Li-Po
Servomoteur MG996R

Les signaux d'entrée pour contrôler servos et ESC sont presque identiques : signal PWM 50Hz généré facilement avec la bibliothèque Servo d'Arduino.

Note : Avec des servos MG996R, j'ai rencontré un problème : ils peuvent tirer un courant plus fort et provoquer des pics de tension sur le rail 5V, pouvant griller l'Arduino Pro Mini (limite 5.5V sur broche 5V). Une solution possible serait d'ajouter des condensateurs de découplage plus gros sur les servos, mais je n'ai pas testé. Soyez conscients de ce risque.

Dans mon exemple, j'ai utilisé deux autres MG996R qui n'ont pas causé de problème, ainsi que 4 petits servos S90 sans souci.

Voir aussi : Comment fonctionne un servomoteur et comment le contrôler avec Arduino

/* Récepteur RC DIY - Contrôle servos et moteurs brushless par Dejan, www.HowToMechatronics.com Bibliothèque: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Servo.h>
RF24 radio(3, 2);
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
Servo esc;
Servo servo1;
Servo servo2;
int escValue, servo1Value, servo2Value;
struct Data_Package {
  byte j1PotX;
  byte j1PotY;
  byte j1Button;
  byte j2PotX;
  byte j2PotY;
  byte j2Button;
  byte pot1;
  byte pot2;
  byte tSwitch1;
  byte tSwitch2;
  byte button1;
  byte button2;
  byte button3;
  byte button4;
};
Data_Package data;
void setup() {
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.startListening();
  resetData();
  esc.attach(10); // Broche D10 - CH9 sur PCB
  servo1.attach(4); // D4 - CH1
  servo2.attach(5); // D5 - CH2
}
void loop() {
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) {
    resetData();
  }
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package));
    lastReceiveTime = millis();
  }
  servo1Value = map(data.j2PotX, 0, 255, 0, 180);
  servo2Value = map(data.j2PotY, 0, 255, 0, 180);
  servo1.write(servo1Value);
  servo2.write(servo2Value);
  escValue = map(data.j1PotY, 127, 255, 1000, 2000);
  esc.writeMicroseconds(escValue);
}
void resetData() {
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}

Après réception des données, on convertit les valeurs 0-255 en 0-180° pour les servos (fonction write()). Pour l'ESC, on convertit 127-255 (milieu à haut du joystick 1) en 1000-2000µs via writeMicroseconds(), contrôlant ainsi la vitesse du moteur brushless de min à max.

Voir aussi : Avion RC Arduino | 100% DIY

C'est ainsi qu'on peut contrôler avions, voitures, bateaux RC, utilisant ce type de moteurs et servos.

Exemple 3 – Contrôle d'un modèle de voiture RC

Cette voiture RC avait sa propre radiocommande : contrôle numérique (tout ou rien) pour direction et vitesse max. Je l'ai démontée pour y intégrer notre récepteur Arduino.

À l'intérieur, deux moteurs DC 5V simples, même pour la direction (moteur à rotation continue). On sait déjà contrôler des moteurs DC, il suffit d'ajouter un pilote moteur double. Le L298N de l'exemple 1 fonctionne, mais il est trop gros. J'ai choisi le pilote MX1508, double pilote DC avec pont en H et contrôle PWM, 4 entrées de contrôle, 4 sorties moteurs, 2 broches d'alimentation.

J'ai dessoudé les moteurs de la carte d'origine et les ai soudés au pilote. Alimentation par batterie Ni-Cd 4.8V sous la voiture. Connexion au VCC de l'Arduino et 4 broches de contrôle du pilote sur 4 canaux numériques. Pour le moteur arrière (B), j'ai utilisé les canaux PWM 2 et 3.

Composants nécessaires :

Voiture RC MGRC
Pilote moteur DC MX1508
Plaque d'essai et fils de liaison

Le code est très similaire au premier exemple.

/* Récepteur RC Arduino - Contrôle modèle RC par Dejan, www.HowToMechatronics.com Bibliothèque: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define in3 5 // D5 - CH2 - sortie PWM
#define in4 6 // D6 - CH3 - sortie PWM
#define in1 7 // D7 - CH4
#define in2 8 // D8 - CH5
RF24 radio(3, 2);
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
struct Data_Package {
  byte j1PotX;
  byte j1PotY;
  byte j1Button;
  byte j2PotX;
  byte j2PotY;
  byte j2Button;
  byte pot1;
  byte pot2;
  byte tSwitch1;
  byte tSwitch2;
  byte button1;
  byte button2;
  byte button3;
  byte button4;
};
Data_Package data;
int steering, throttle;
int motorSpeedA = 0;
int motorSpeedB = 0;
void setup() {
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.startListening();
  resetData();
}
void loop() {
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) {
    resetData();
  }
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package));
    lastReceiveTime = millis();
  }
  steering = data.j2PotX;
  throttle = data.j1PotY;
  if (throttle < 110) {
    motorSpeedB = map(throttle, 110, 0, 0, 255);
    analogWrite(in3, motorSpeedB);
    digitalWrite(in4, LOW);
  } else if (throttle > 140) {
    motorSpeedB = map(throttle, 140, 255, 0, 255);
    digitalWrite(in3, LOW);
    analogWrite(in4, motorSpeedB);
  } else {
    digitalWrite(in3, HIGH);
    digitalWrite(in4, HIGH);
  }
  if (steering < 110) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
  }
  if (steering > 140) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
  } else {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, HIGH);
  }
}
void resetData() {
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}

On utilise les données des joysticks pour l'accélérateur et la direction. Pour reculer : signal PWM sur Input3, Input4 LOW. Pour avancer : l'inverse. Au centre : freinage (les deux HIGH). Même principe pour le moteur de direction, sans PWM car pas de contrôle de vitesse nécessaire.

Après téléversement, j'ai remonté la voiture : petit pilote dans le châssis, pièces fixées, récepteur reconnecté et placé sous la carrosserie.

Non seulement nous avons modifié cette voiture RC pour la contrôler avec notre émetteur DIY, mais nous l'avons améliorée en ajoutant le contrôle PWM de la vitesse. Si votre modèle RC utilise des servos et moteurs brushless, suivez la méthode de l'exemple 2.

J'espère que ce tutoriel vous a plu et apporté de nouvelles connaissances. N'hésitez pas à poser vos questions en commentaires et consultez ma collection de projets Arduino.