Récepteur DIY Arduino RC pour modèles RC et projets Arduino
Dans ce tutoriel, nous allons apprendre à fabriquer un récepteur RC basé sur Arduino. Depuis que j'ai construit mon émetteur DIY Arduino RC dans l'une de mes vidéos précédentes, j'ai reçu beaucoup de demandes de votre part, pour créer un récepteur dédié, alors le voici.
Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous.
Maintenant, ces deux appareils peuvent facilement communiquer et nous pouvons les utiliser pour contrôler de nombreuses choses sans fil. Je vais vous expliquer comment tout fonctionne à travers quelques exemples. Dans le premier exemple, nous utiliserons ce récepteur Arduino RC pour contrôler une voiture simple composée de deux moteurs à courant continu. Dans le deuxième exemple, je vais vous montrer comment contrôler les moteurs et les servos sans balais, qui sont des composants courants que l'on trouve dans de nombreux avions, bateaux, voitures RC commerciaux, etc. Si nous savons comment les contrôler, nous pouvons facilement modifier et contrôler de nombreux modèles RC avec notre propre émetteur Arduino personnalisé.
Comme troisième exemple, je vais vous montrer comment j'ai modifié et utilisé ce système RC basé sur Arduino pour contrôler une voiture RC commerciale.
Pour commencer, regardons le schéma de circuit de ce système. La communication radio est basée sur les modules émetteurs-récepteurs NRF24L01.
L'émetteur envoie constamment des données de ses contrôleurs, des manettes, des boutons, des potentiomètres et des interrupteurs à bascule, et nous recevons ces données avec le récepteur. Pour plus de détails sur le fonctionnement de cet émetteur Arduino, vous pouvez consulter mon autre tutoriel détaillé.
Nous pouvons également noter ici que ce récepteur RC ne fonctionne pas nécessairement avec cet émetteur particulier que j'ai construit. Il peut fonctionner avec n'importe quelle autre configuration similaire composée d'une carte Arduino et d'un module NRF24L01.
Néanmoins, le cerveau de ce récepteur RC est une carte Arduino Pro Mini. Pour l'alimentation, nous pouvons soit utiliser la broche VCC à laquelle nous pouvons connecter 5V, soit la broche RAW à laquelle nous pouvons connecter de 6 à 12V. Notez qu'il existe deux versions de l'Arduino Pro Mini, comme celle que j'utilise ici qui fonctionne à 5V et l'autre fonctionne à 3,3V. D'autre part, le module NRF24L01 fonctionne à 3,3 V, nous avons donc besoin d'un régulateur de tension. Cette fois, j'utilise le régulateur de tension AMS1117, qui délivre 3,3 V à partir d'entrées pouvant aller de 5 V à 12 V.
Vous pouvez obtenir les composants nécessaires pour ce récepteur Arduino RC à partir des liens ci-dessous :
Pour la communication avec l'Arduino, le module NRF24L01 utilise le protocole SPI, plus deux broches numériques supplémentaires. Cela signifie qu'il nous reste 9 broches numériques qui peuvent être utilisées comme canaux de sortie, dont deux sont les broches RX et TX. Il convient de noter que ces broches doivent être déconnectées de tout pendant que nous téléchargeons un croquis sur la carte Arduino, j'ai donc rendu possible la connexion ou la déconnexion via des en-têtes de broches séparés. En fait, nous pouvons également utiliser les entrées analogiques comme sorties numériques, donc bien que cette carte Arduino soit assez petite, nous avons beaucoup de sorties ou de canaux disponibles.
Néanmoins, afin de garder ce circuit compact, j'ai créé un circuit imprimé personnalisé à l'aide du logiciel de conception de circuits en ligne gratuit EasyEDA. Ici, j'ai disposé les 8 canaux juste à côté d'un rail 5V et d'un rail Ground, et nous pouvons donc y connecter directement des servos et des ECS. Le numéro de canal 9 est situé à une position séparée, près de la broche VCC de l'Arduino, nous pouvons donc utiliser, par exemple, un ESC pour alimenter l'Arduino avec sa fonction Battery Eliminator Circuit qui fournit 5V. Bien sûr, nous pourrions utiliser n'importe quel autre canal à cette fin, car la broche VCC est également connectée à ces rails 5V.
En ce qui concerne les canaux numéro 7 et 8, nous pouvons voir ici comment ils sont interrompus avec ces en-têtes de broches. Si nous voulons les utiliser, il suffit de connecter les deux broches ensemble. L'en-tête de programmation est situé dans le coin supérieur droit et le condensateur de 100 uF sert à la fois au régulateur de tension et au module NRF24L01. Dans le coin inférieur gauche du PCB, j'ai placé les broches analogiques.
Ici, nous pouvons noter une dernière chose, et c'est que certaines cartes Arduino Pro Mini peuvent avoir une disposition différente des broches, donc j'ai inclus une version supplémentaire du PCB afin que vous puissiez choisir celle qui correspond à votre carte Arduino Pro Mini.
Voici un lien vers les fichiers de projet de ce PCB. Donc une fois la conception terminée, j'ai généré le fichier Gerber nécessaire à la fabrication du PCB.
Fichiers Gerber :
Ensuite, j'ai commandé le PCB à JLCPCB qui est également le sponsor de cette vidéo.
Ici, nous pouvons simplement faire glisser et déposer le fichier Gerber et une fois téléchargé, nous pouvons revoir notre PCB dans la visionneuse Gerber. Si tout va bien, nous pouvons continuer et sélectionner les propriétés que nous voulons pour notre PCB. Et voilà, maintenant nous pouvons simplement commander notre PCB à un prix raisonnable. Notez que s'il s'agit de votre première commande chez JLCPCB, vous pouvez obtenir jusqu'à 5 PCB pour seulement 2 $.
Après plusieurs jours, les PCB sont arrivés. La qualité des PCB est excellente et tout est exactement comme dans la conception.
Nous pouvons maintenant passer à autre chose et assembler le PCB. Tout d'abord, nous devons souder les en-têtes de broches de la carte Arduino. Un moyen pratique de le faire est d'utiliser une planche à pain pour y coller les en-têtes de broches et ainsi la carte restera fermement en place pendant la soudure. Comme je l'ai dit plus tôt, selon votre carte, les broches peuvent varier un peu, alors gardez cela à l'esprit lorsque vous les soudez.
De plus, il y a des broches de terre que nous devons laisser libres car il y a des traces sur le PCB en dessous. Une fois que j'ai soudé la carte Arduino, j'ai coupé la longueur excédentaire des broches.
Ensuite, j'ai placé tous les autres en-têtes de broches en place. Nous avons besoin d'en-têtes de broches mâles et femelles, ou c'est à vous de choisir les en-têtes de broches que vous choisirez d'utiliser. Cependant, c'est une bonne idée d'utiliser des en-têtes de broches mâles pour les canaux numériques car les servomoteurs et les connexions ESC sont femelles, afin que nous puissions les connecter facilement.
Le régulateur de tension est un composant de montage en surface, j'ai donc utilisé de l'adhésif Blue-Tack pour le maintenir en place pendant la soudure. Enfin, une fois que nous avons soudé les deux condensateurs en place, nous pouvons attacher le module NRF24L01 aux en-têtes de broches appropriés.
Selon l'application ou la portée dont nous avons besoin, nous pouvons utiliser soit le module normal avec l'antenne embarquée, soit celui auquel nous pouvons attacher une antenne plus grande et réaliser une communication sans fil jusqu'à 700 mètres en espace ouvert . Voilà, notre récepteur Arduino RC est maintenant prêt et nous pouvons l'utiliser pour tout ce que nous voulons.
Pour programmer le récepteur ou connecter l'Arduino Pro Mini à l'ordinateur, nous pouvons utiliser une interface USB vers UART série qui peut être connectée à l'en-tête de programmation.
Dans le menu des outils Arduino IDE, nous devons sélectionner la carte Arduino Pro ou Pro Mini, sélectionner la version appropriée du processeur, sélectionner le port et sélectionner la méthode de programmation sur "USBasp".
Et maintenant, nous sommes en mesure de télécharger des codes sur l'Arduino.
Ok, maintenant nous pouvons passer à autre chose et jeter un œil au premier exemple.
C'est une voiture simple composée de deux moteurs 12V DC et dans certaines de mes vidéos précédentes, je vous ai déjà montré comment cela fonctionne et comment le construire.
Voir aussi : L298N Motor Driver – ; Interface Arduino, comment ça marche, codes, schémas
Cette fois, nous utiliserons notre nouveau récepteur Arduino RC pour le contrôler. Pour piloter les moteurs à courant continu, nous utilisons le pilote de moteur L298N et pour l'alimentation, nous utilisons 3 batteries Li-ion qui fournissent environ 12V.
Vous pouvez obtenir les composants nécessaires pour cet exemple à partir des liens ci-dessous :
Ainsi, les connexions sont vraiment simples, le 12V provenant des batteries va à la broche 12V de notre récepteur, et les six broches de contrôle du pilote vont aux 6 canaux. Nous devons noter ici que pour pouvoir contrôler la vitesse des moteurs, nous devons fournir un signal PWM aux broches Enable A et Enable B du pilote. Dans notre récepteur, les canaux numéros 2, 3, 6 et 9 peuvent émettre des signaux PWM, j'ai donc connecté les broches Enable du pilote aux canaux numéros 2 et 6 dans ce cas.
Jetons un coup d'œil au code Arduino maintenant.
Description : Nous devons donc d'abord inclure le SPI et la bibliothèque RF24, définir quelques broches, l'objet radio et la structure de données où nous stockerons les données entrantes de l'émetteur. Dans la section de configuration, nous devons définir les sorties des broches et commencer la communication radio. Pour plus de détails sur la façon dont cela fonctionne et ce que font chacune de ces lignes, vous pouvez consulter mon tutoriel détaillé NRF24L01.
Dans la section boucle, nous vérifions constamment si nous recevons des données et si c'est le cas, nous lisons ces données entrantes. Si nous examinons rapidement le code de l'émetteur, nous pouvons voir quel type de données il envoie au récepteur. Il lit les données de tous ses contrôleurs, les manettes, les potentiomètres et les boutons, et il envoie ces données en un seul paquet au récepteur.
Ainsi, une fois que nous avons lu ces données, nous pouvons en faire ce que nous voulons. Dans ce cas, nous utiliserons la valeur de l'axe Y du joystick 1 pour contrôler la manette des gaz et la valeur de l'axe X pour contrôler la direction. J'ai mis ces données dans des variables d'accélérateur et de direction distinctes. Les valeurs que nous obtenons des joysticks vont de 0 à 255. Ainsi, si nous abaissons le joystick, nous réglerons les broches de commande du conducteur de manière appropriée pour que la voiture recule et utiliserons la valeur de l'accélérateur pour contrôler la vitesse de déplacement. Le même principe s'applique pour la marche avant, à gauche et à droite. Encore une fois, j'ai déjà un tutoriel détaillé sur le fonctionnement de cette voiture afin que vous puissiez le vérifier pour une meilleure compréhension. Au bas du code, nous pouvons noter la fonction personnalisée resetData(), qui réinitialise toutes les valeurs à leurs valeurs initiales par défaut, donc en cas de perte de la communication radio, la voiture se déplacera.
Très bien, nous pouvons maintenant passer au deuxième exemple, contrôler les servos et les moteurs sans balais à l'aide de ce récepteur Arduino RC.
Pour contrôler les moteurs sans balais, nous avons besoin d'un ESC, ou contrôleur de vitesse électronique. L'Arduino communique avec l'ESC avec une seule broche. Pour contrôler l'ESC, l'Arduino envoie un signal PWM spécifique à l'ESC et avec lui l'ESC contrôle la vitesse du moteur. L'ESC avec cette même connexion fournit 5 V grâce à sa fonction de circuit d'élimination de la batterie, de sorte que nous pouvons également alimenter notre récepteur avec.
Voir aussi : Tutoriel de contrôle de moteur sans balais Arduino | ESC | BLDC
Quant aux servomoteurs, ils ont le même type de connexions que l'ESC et nous pouvons simplement les connecter à l'un des canaux disponibles.
Vous pouvez obtenir les composants nécessaires pour cet exemple à partir des liens ci-dessous :
Les signaux d'entrée pour contrôler les servos et les moteurs sans balais à l'aide d'ESC sont presque les mêmes. Ils utilisent un signal PWM spécifique de 50 Hz qui peut être facilement généré à l'aide de la bibliothèque Arduino Servo.
Remarque : Lorsque vous utilisez des servos MG996R avec cette configuration, ils peuvent causer un problème dans le circuit et brûler l'Arduino Pro Mini. Cela pourrait tirer un courant plus élevé et provoquer des pointes de tension sur le rail 5V. L'Arduino Pro Mini devrait gérer jusqu'à 5,5 V sur la broche 5 V, mais lorsque ces pics se produisent, cela pourrait brûler l'Arduino. J'ai eu ce problème lors du test du circuit, et quelqu'un dans la section des commentaires a également signalé la même chose. Une solution à cela pourrait être de placer des condensateurs de découplage plus gros sur les servos, mais je ne suis pas tout à fait sûr et je ne l'ai pas testé. Veuillez donc être conscient de ce problème.
D'un autre côté, dans l'exemple, j'ai utilisé deux autres servos MG996R qui n'ont pas brûlé l'Arduino, je suppose parce qu'ils ne provoquaient pas des pics aussi élevés. J'ai également utilisé cet exemple avec 4 servos S90 plus petits et cela n'a posé aucun problème.
Voir aussi : Comment fonctionne le servomoteur & Comment contrôler les servos avec Arduino
Ainsi, après avoir reçu les données de l'émetteur, nous convertissons les valeurs de 0 à 255 en valeurs de 0 à 180 pour contrôler les servos à l'aide de la fonction write(). De la même manière, nous convertissons les données de contrôle de l'ESC en valeurs de 1000 à 2000. Dans cet exemple, nous contrôlons cet ESC du point médian du joystick numéro 1, à la position haute, donc nous convertissons les valeurs du milieu , 127 à 255 en valeurs de 1000 à 2000. En utilisant la fonction Servo Library writeMicroseconds() nous envoyons le signal PWM à l'ESC et ainsi nous pouvons contrôler la vitesse du moteur brushless du minimum au maximum.
Voir aussi : Avion RC Arduino | 100 % DIY
C'est ainsi que nous pouvons contrôler les avions RC, les voitures, les bateaux, etc., car ils utilisent généralement ce type de moteurs, servos et moteurs sans balais.
La voiture RC est livrée avec son propre contrôleur qui peut contrôler les roues avant pour se déplacer à gauche et à droite, ainsi que déplacer la voiture vers l'avant et vers l'arrière.
Cependant, comme il s'agit d'une voiture RC bon marché, les commandes sont numériques, ou activées ou désactivées, à la position maximale à gauche et à droite et à la vitesse maximale. Indépendamment de cela, j'ai démonté la voiture pour voir ce qu'il y a à l'intérieur et comment je peux implémenter le récepteur Arduino RC pour le contrôler.
Une fois que j'ai découvert les composants électroniques, j'ai remarqué que les deux moteurs sont en fait de simples moteurs à courant continu qui fonctionnent à 5V. Même le moteur avant qui contrôle les mouvements limités de la direction est un simple moteur à courant continu à rotation continue.
Donc, apparemment, nous savons déjà comment contrôler les moteurs à courant continu, donc remplacer cette carte de circuit imprimé par notre récepteur DIY Arduino sera assez facile. En plus de notre récepteur, nous avons juste besoin d'un pilote de moteur capable de piloter deux moteurs en même temps. Il existe de nombreuses options à cet effet, même celle que nous avons utilisée dans le premier exemple, le pilote L298N.
Cependant, celui-ci est trop gros pour cette application, j'ai donc choisi le pilote de moteur MX1508. Il s'agit d'un simple pilote de moteur CC double doté d'un pont en H et d'un contrôle PWM. Il dispose de 4 broches d'entrée de commande, 4 broches pour les moteurs et 2 broches pour l'alimentation.
J'ai dessoudé les connexions des moteurs du circuit imprimé de la voiture RC et les ai soudées au conducteur. À l'arrière, j'ai soudé les broches d'alimentation et il ne reste plus qu'à connecter ce pilote au récepteur. L'alimentation de cette voiture RC provient d'une batterie Ni-Cd de 4,8 V située au bas de la voiture.
Ainsi, à l'aide de câbles de saut, j'ai connecté ces broches à la broche VCC de l'Arduino, et j'ai également connecté les 4 broches d'entrée de commande du pilote à 4 canaux numériques. Comme je l'ai dit, ce pilote prend en charge le contrôle PWM, donc pour le moteur B, ou le moteur arrière, j'ai utilisé les canaux PWM numéro 2 et 3.
Vous pouvez obtenir les composants nécessaires pour cet exemple à partir des liens ci-dessous :
Le code de cette voiture RC est très similaire au premier exemple.
Nous utilisons les données provenant des manettes pour contrôler l'accélérateur et la direction de la voiture RC. Pour revenir en arrière, nous utilisons la fonction analogWrite () pour envoyer le signal PWM au pilote à la broche Input3, tandis que nous maintenons la broche input4 LOW. Pour aller de l'avant, nous le faisons dans le sens inverse. Si le joystick reste au milieu, nous donnons l'ordre au conducteur de freiner ou d'arrêter les moteurs. Le même principe est utilisé pour le moteur de direction, bien qu'ici nous n'ayons pas besoin d'utiliser la fonction analogWrite() car nous n'avons pas besoin de contrôler la vitesse de ce moteur.
Après avoir téléchargé ce croquis sur l'Arduino, j'ai dû remonter la voiture RC. J'ai placé le petit pilote dans le boîtier intérieur et fixé le reste des pièces avec les vis. J'ai reconnecté le récepteur avec le conducteur et l'ai placé sous le boîtier extérieur de la voiture qui avait suffisamment de place pour tenir dans le récepteur.
Ainsi, non seulement nous avons modifié cette voiture RC pour qu'elle soit contrôlée avec notre émetteur RC DIY, mais nous l'avons également améliorée en ajoutant un contrôle PWM afin que nous puissions également contrôler la vitesse de la voiture. Dans le cas où le modèle RC que vous souhaitez modifier a des servos et des moteurs sans balais au lieu de moteurs à courant continu, vous pouvez suivre la méthode expliquée dans le deuxième exemple.
J'espère que vous avez apprécié ce tutoriel et appris quelque chose de nouveau. N'hésitez pas à poser des questions dans la section des commentaires ci-dessous et n'oubliez pas de consulter ma collection de projets Arduino.
Schéma du circuit du récepteur Arduino RC
Conception de circuits imprimés
Assemblage PCB
Exemple 1 – Voiture RC Arduino
/*
Arduino RC Receiver - Car Example
by Dejan, www.HowToMechatronics.com
Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define enA 9 // Arduino pin D9 - CH6 on PCB board - PWM output
#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 - PWM output
RF24 radio(3, 2); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
// Max size of this struct is 32 bytes
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; //Create a variable with the above structure
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(); // Set the module as receiver
resetData();
}
void loop() {
// Check whether we keep receving data, or we have a connection between the two modules
currentTime = millis();
if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone jas a throttle up, if we lose connection it can keep flying away if we dont reset the function
}
// Check whether there is data to be received
if (radio.available()) {
radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
lastReceiveTime = millis(); // At this moment we have received the data
}
// Parse the data from the Joystic 1 to the throttle and steering variables
throttle = data.j1PotY;
steering = data.j1PotX;
// Throttle used for forward and backward control
// Joystick values: 0 to 255; down = 0; middle = 127; up = 255
if (throttle < 110) {
// Set Motor A backward
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
// Set Motor B backward
digitalWrite(in3, HIGH);
digitalWrite(in4, LOW);
// Convert the declining throttle readings for going backward from 110 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
motorSpeedA = map(throttle, 110, 0, 0, 255);
motorSpeedB = map(throttle, 110, 0, 0, 255);
}
else if (throttle > 140) {
// Set Motor A forward
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
// Set Motor B forward
digitalWrite(in3, LOW);
digitalWrite(in4, HIGH);
// Convert the increasing throttle readings for going forward from 140 to 255 into 0 to 255 value for the PWM signal for increasing the motor speed
motorSpeedA = map(throttle, 140, 255, 0, 255);
motorSpeedB = map(throttle, 140, 255, 0, 255);
}
// If joystick stays in middle the motors are not moving
else {
motorSpeedA = 0;
motorSpeedB = 0;
}
// Steering used for left and right control
if (steering < 110) {
// Convert the declining steering readings from 140 to 255 into increasing 0 to 255 value
int xMapped = map(steering, 110, 0, 0, 255);
// Move to left - decrease left motor speed, increase right motor speed
motorSpeedA = motorSpeedA - xMapped;
motorSpeedB = motorSpeedB + xMapped;
// Confine the range from 0 to 255
if (motorSpeedA < 0) {
motorSpeedA = 0;
}
if (motorSpeedB > 255) {
motorSpeedB = 255;
}
}
if (steering > 140) {
// Convert the increasing steering readings from 110 to 0 into 0 to 255 value
int xMapped = map(steering, 140, 255, 0, 255);
// Move right - decrease right motor speed, increase left motor speed
motorSpeedA = motorSpeedA + xMapped;
motorSpeedB = motorSpeedB - xMapped;
// Confine the range from 0 to 255
if (motorSpeedA > 255) {
motorSpeedA = 255;
}
if (motorSpeedB < 0) {
motorSpeedB = 0;
}
}
// Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
if (motorSpeedA < 70) {
motorSpeedA = 0;
}
if (motorSpeedB < 70) {
motorSpeedB = 0;
}
analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
analogWrite(enB, motorSpeedB); // Send PWM signal to motor B
}
void resetData() {
// Reset the values when there is no radio connection - Set initial default values
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;
}Code language: Arduino (arduino)Exemple 2 – Contrôle des servos récepteurs Arduino RC et des moteurs brushless
/*
DIY RC Receiver - Servos and Brushless motors control
by Dejan, www.HowToMechatronics.com
Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Servo.h>
RF24 radio(3, 2); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
Servo esc; // create servo object to control the ESC
Servo servo1;
Servo servo2;
int escValue, servo1Value, servo2Value;
// Max size of this struct is 32 bytes - NRF24L01 buffer limit
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; //Create a variable with the above structure
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(); // Set the module as receiver
resetData();
esc.attach(10); // Arduino digital pin D10 - CH9 on PCB board
servo1.attach(4); // D4 - CH1
servo2.attach(5); // D5 - CH2
}
void loop() {
// Check whether we keep receving data, or we have a connection between the two modules
currentTime = millis();
if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone jas a throttle up, if we lose connection it can keep flying away if we dont reset the function
}
// Check whether there is data to be received
if (radio.available()) {
radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
lastReceiveTime = millis(); // At this moment we have received the data
}
// Controlling servos
servo1Value = map(data.j2PotX, 0, 255, 0, 180); // Map the receiving value form 0 to 255 to 0 to 180(degrees), values used for controlling servos
servo2Value = map(data.j2PotY, 0, 255, 0, 180);
servo1.write(servo1Value);
servo2.write(servo2Value);
// Controlling brushless motor with ESC
escValue = map(data.j1PotY, 127, 255, 1000, 2000); // Map the receiving value form 127 to 255 to 1000 to 2000, values used for controlling ESCs
esc.writeMicroseconds(escValue); // Send the PWM control singal to the ESC
}
void resetData() {
// Reset the values when there is no radio connection - Set initial default values
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;
}Code language: Arduino (arduino)Exemple 3 – Contrôle de modèle de voiture RC
/*
Arduino RC Receiver - RC Model control
by Dejan , www.HowToMechatronics.com
Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define in3 5 // D5 - CH2 - PWM output
#define in4 6 // D6 - CH3 - PWM output
#define in1 7 // D7 - CH4
#define in2 8 // D8 - CH5
RF24 radio(3, 2); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
// Max size of this struct is 32 bytes
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; //Create a variable with the above structure
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(); // Set the module as receiver
resetData();
}
void loop() {
// Check whether we keep receving data, or we have a connection between the two modules
currentTime = millis();
if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone jas a throttle up, if we lose connection it can keep flying away if we dont reset the function
}
// Check whether there is data to be received
if (radio.available()) {
radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
lastReceiveTime = millis(); // At this moment we have received the data
}
// Parse the data from the Joystic 1 to the steering and throttle variables
steering = data.j2PotX;
throttle = data.j1PotY;
// Throttle used for forward and backward control
if (throttle < 110) {
// Convert the declining throttle readings for going backward from 110 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
motorSpeedB = map(throttle, 110, 0, 0, 255);
// Set Motor B backward
analogWrite(in3, motorSpeedB);
digitalWrite(in4, LOW);
}
else if (throttle > 140) {
// Convert the increasing throttle readings for going forward from 140 to 255 into 0 to 255 value for the PWM signal for increasing the motor speed
motorSpeedB = map(throttle, 140, 255, 0, 255);
// Set Motor B forward
digitalWrite(in3, LOW);
analogWrite(in4, motorSpeedB);
}
// If joystick stays in middle the motors are not moving
else {
digitalWrite(in3, HIGH);
digitalWrite(in4, HIGH);
}
// steering used for left and right control
if (steering < 110) {
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
}
if (steering > 140) {
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
}
// If joystick stays in middle the motors are not moving
else {
digitalWrite(in1, HIGH);
digitalWrite(in2, HIGH);
}
}
void resetData() {
// Reset the values when there is no radio connection - Set initial default values
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;
}Code language: Arduino (arduino)
Processus de fabrication
- DIY :surveillance et régulation de la température pour HomeBrew
- Mesure de la température pour les projets en laboratoire et scientifiques
- Choisir entre un routeur CNC et une découpeuse laser CNC pour vos projets de bricolage.
- Animation LCD et jeux
- Voltmètre DIY utilisant Arduino et Smartphone
- Voltmètre DIY avec Arduino et un écran Nokia 5110
- L'importance des modèles CAO pour les projets de fabrication métallique
- Tours améliorés pour le polissage et l'ébavurage
- Broche Mkr1000 :un choix privilégié pour les projets IoT