Aéroglisseur RC basé sur Arduino DIY

Dans ce tutoriel, nous allons apprendre à construire un aéroglisseur RC basé sur Arduino. Je vais vous montrer tout le processus de construction, depuis la conception et l'impression 3D des pièces de l'aéroglisseur, y compris les hélices, jusqu'à la connexion des composants électroniques et la programmation de l'Arduino.

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

Aperçu

Pour contrôler l'aéroglisseur, j'ai utilisé mon émetteur RC basé sur Arduino DIY que j'ai fabriqué dans l'une de mes vidéos précédentes. J'ai réglé le joystick droit pour contrôler le servomoteur afin de positionner les gouvernails à l'arrière du moteur de poussée, j'ai réglé l'un des potentiomètres pour contrôler l'hélice de levage qui est en fait fixée sur un moteur à courant continu sans balais, et j'ai réglé le joystick gauche pour contrôler la propulsion. Voyons donc ce qu'il faut pour construire cet aéroglisseur RC.

Modèle 3D d'aéroglisseur

Pour commencer, j'ai conçu l'aéroglisseur à l'aide d'un logiciel de modélisation 3D.

Vous pouvez trouver et télécharger ce modèle 3D, ainsi que l'explorer dans votre navigateur sur Thangs.

Téléchargez le modèle 3D d'assemblage sur Thangs.

Fichiers STL pour l'impression 3D :

Principe de fonctionnement de l'aéroglisseur

Le principe de fonctionnement de base d'un aéroglisseur est que l'engin est soulevé par un coussin d'air. L'hélice centrale souffle de l'air sous l'engin, ce qui gonfle une jupe en matériau souple.

Lorsque la pression d'air dans la jupe est suffisamment élevée, l'engin est soulevé. L'air constamment fourni s'échappe du milieu de l'engin, entre la jupe et le sol, ce qui crée une portance supplémentaire et réduit également la friction entre l'aéroglisseur et le sol.

Une fois soulevé, à l'aide de la deuxième hélice, une poussée est générée qui fait avancer l'aéroglisseur.

À l'arrière de l'hélice de poussée, il y a un simple jeu de gouvernails qui sont utilisés pour diriger l'aéroglisseur.

Impression 3D

Néanmoins, une fois la conception terminée, j'ai commencé par imprimer les pièces en 3D.

La coque de l'aéroglisseur est la plus grande partie à imprimer et j'ai spécialement conçu pour s'adapter à mon imprimante 3D Creality CR-10, qui a un lit d'impression de 30x30cm.

Voici un lien vers cette imprimante 3D au cas où vous voudriez la vérifier.

Une fois l'impression terminée, il est temps de faire un peu de nettoyage. Le corps principal de l'aéroglisseur ou du cockpit était l'impression la plus longue qui a pris environ 18 heures à imprimer. En raison de la conception incurvée et parce que je voulais être une seule impression, il y avait beaucoup de matériel de support utilisé pour cette impression.

Cependant, il était très facile de l'enlever et la pièce finale s'est avérée tout simplement parfaite. La coque de l'aéroglisseur était imprimée à l'envers et il n'y avait qu'une petite quantité de matériau de support à enlever. En fait, j'ai dû faire quelques ajustements à cette impression et découper du matériau dans le boîtier central du ventilateur afin que le support de jupe puisse s'adapter correctement.

J'ai déjà mis à jour le modèle 3D donc je n'aurai pas ce problème.

Certaines des zones rondes des pièces étaient un peu rugueuses, j'ai donc utilisé un simple papier d'envoi pour les lisser.

Les hélices n'ont pas eu besoin d'être nettoyées et elles ont plutôt bien fonctionné dès leur sortie de l'imprimante 3D.

Peindre l'aéroglisseur

Ok, la prochaine étape consiste à peindre les pièces imprimées en 3D. Je n'utilisais pas d'apprêt auparavant mais j'appliquais directement une peinture acrylique sous forme de peinture en aérosol.

J'ai utilisé une couleur chocolat pour la première couche. Pour certaines des plus petites pièces, qui ne sont en fait que des pièces de décoration, j'ai utilisé une couleur marron plus claire.

Afin de rendre l'aéroglisseur un peu plus cool, une fois la première couche sèche, j'ai continué en ajoutant deux couleurs supplémentaires aux pièces. Pour cela, j'ai fait des motifs aléatoires sur une simple feuille de papier, et les ai utilisés pour faire des rayures et des taches de différentes couleurs. J'ai utilisé une couleur marron et noire plus claire à cette fin.

Assemblage de l'aéroglisseur RC Arduino

J'aime vraiment la façon dont les pièces se sont avérées, donc une fois qu'elles ont séché, j'ai continué à les assembler.

J'ai commencé par installer le servomoteur qui contrôle les gouvernails sur le boîtier du ventilateur de poussée. J'ai fixé le servo à l'aide de deux boulons et écrous M2.

Vient ensuite le moteur brushless. Le modèle particulier que j'ai est le D2830 qui a un diamètre de 28 mm et 30 mm de longueur, et bien sûr, le boîtier est spécialement conçu pour s'adapter à ce moteur.

Ici, lors de l'insertion du moteur, j'ai d'abord dû passer les fils à travers les ouvertures. C'est un peu serré, mais toujours gérable pour les traverser. Ensuite, à l'arrière, à l'aide de boulons M3, j'ai fixé le moteur au boîtier.

Ensuite, je peux fusionner le boîtier de poussée avec le corps principal de l'aéroglisseur. Cette partie a une ouverture pour le passage des fils du servo et du moteur BLDC.

À l'aide de quatre boulons M3, je les ai solidement fixés ensemble.

Une fois que j'ai terminé, j'ai continué avec l'installation du deuxième moteur sans balais sur la coque de l'aéroglisseur. Là encore, j'ai utilisé la même méthode. J'ai d'abord passé les fils à travers les ouvertures, puis j'ai fixé le moteur à l'arrière à l'aide de quatre boulons M3.

Schéma du circuit

Vient ensuite l'électronique. Les composants électroniques seront placés entre la coque et le corps principal de l'aéroglisseur. Mais avant cela, examinons le schéma de circuit et voyons comment tout doit être connecté.

Ainsi, le cerveau de cet aéroglisseur est une carte Arduino. Avec l'Arduino, nous pouvons facilement contrôler le servo ainsi que les deux moteurs sans balais à l'aide des deux contrôleurs de vitesse électroniques ou ESC. Pour alimenter les moteurs BLDC, j'utiliserai une batterie Li-Po 3S qui fournit environ 11 V, et pour alimenter l'Arduino, nous pouvons utiliser le 5 V régulé que les ESC fournissent via leur fonction de circuit d'élimination de batterie.

Pour la communication sans fil, j'utiliserai le module émetteur-récepteur NRF24L01 qui, s'il est utilisé avec une antenne amplifiée, peut avoir une portée stable allant jusqu'à 700 mètres en espace ouvert. L'émetteur RC que j'utiliserai pour contrôler l'aéroglisseur est celui que j'ai construit sur mesure dans l'un de mes précédents tutoriels, vous pouvez donc le vérifier si vous avez besoin de plus de détails à ce sujet. Il existe également des didacticiels détaillés sur le module NRF24l01 et sur l'utilisation de moteurs sans balais avec Arduino. Néanmoins, le principe de fonctionnement de base est que l'émetteur envoie les données des joysticks ou des potentiomètres au récepteur qui contrôle la vitesse des moteurs brushless et la position du servo.

Il y a un autre petit détail sur ce schéma de circuit, et c'est le moniteur de batterie. J'ai ajouté un simple diviseur de tension composé de deux résistances, qui est connecté directement à la batterie, et sa sortie va à l'entrée analogique de l'Arduino. Le diviseur de tension fait tomber les 11 volts à environ 4 volts qui sont alors acceptables par les broches Arduino 5V. Avec cela, nous pouvons surveiller la tension de la batterie et régler une LED pour qu'elle s'allume lorsque, par exemple, la tension de la batterie chutera en dessous de 11 volts.

Vous pouvez obtenir les composants nécessaires pour ce didacticiel Arduino à partir des liens ci-dessous :

• Module émetteur-récepteur NRF24L01….
• NRF24L01 + AP + LNA ………….….
• Moteur sans balais ………………….……
• ESC 30A ……………………………….…..
• Batterie Li-Po ………………………………..
• XT60 2 Femelle vers 1 Mâle ………….
• Connecteur XT60 …………………………
• Servomoteur ………………………………..
• Carte Arduino …………………………

J'ai donc commencé à connecter les composants comme expliqué. Pour connecter les deux ESC à une seule batterie, j'ai utilisé un séparateur de connecteur de batterie parallèle, type XT60.

Pour ajouter un interrupteur d'alimentation au projet, j'ai utilisé un autre connecteur XT60, sur lequel j'ai coupé un fil et y ai soudé un interrupteur à bascule. Ainsi, un côté va au câble répartiteur en Y et l'autre côté à la batterie.

Ensuite, j'ai placé les ESC dans le corps principal et je les ai piégés entre celui-ci et la coque de l'aéroglisseur. Ensuite, à l'aide de quatre boulons M3, j'ai fixé les deux pièces ensemble. Depuis l'ouverture supérieure du corps, j'ai ensuite inséré la batterie dans la zone du cockpit.

Ensuite, nous devons connecter les composants à l'Arduino et à cette fin, j'ai ajouté deux en-têtes de broches à l'Arduino qui serviront de broches GND et 5V.

Donc, une fois que j'ai tout connecté à l'Arduino, j'ai passé l'antenne NRF24L01, le voyant LED et l'interrupteur d'alimentation, à travers le capot supérieur du cockpit.

Ensuite, j'avais juste besoin de tout serrer dans le cockpit. C'était un peu serré ici parce que j'ai utilisé Arduino UNO, et j'aurais probablement dû utiliser et Arduino Nano à la place.

Cependant, j'ai réussi à tout ranger, j'ai également attaché une petite pièce de décoration au couvercle, puis je l'ai juste clipsé au corps du cockpit.

J'ai continué avec l'installation du système de direction. Tout d'abord, j'ai connecté un petit lien au servo klaxon à l'aide d'un boulon M2 et d'un écrou. Ensuite, j'ai inséré le premier gouvernail en place et je l'ai fixé au boîtier de poussée à l'aide d'un fil métallique de 2 mm qui traverse son corps et ainsi le gouvernail peut tourner autour de lui. De la même manière, j'ai attaché le deuxième safran.

Ce gouvernail a une fente supplémentaire afin que nous puissions le connecter au lien précédemment inséré au servo. Encore une fois, j'ai utilisé un boulon et un écrou M2 pour les fixer. Et enfin, j'ai connecté les deux safrans entre eux à l'aide d'un autre lien et avec cela le système de direction est terminé.

Ensuite, je vais attacher cette petite pièce de décoration sur le côté de l'aéroglisseur. A l'aide d'une perceuse, j'ai percé un trou puis fixé la pièce à la coque à l'aide d'une seule vis. J'ai placé ces pièces des deux côtés et je pense qu'elles correspondent assez bien à l'apparence générale de l'aéroglisseur.

Ok, ensuite j'ai continué à faire la jupe de cet aéroglisseur. Vous pouvez remarquer ici que le porte-jupe a des trous autour et c'est pour le fixer à la coque.

Il y a aussi des fentes pour y placer des écrous et de cette façon, nous pourrons facilement fixer le support de jupe à la coque à l'aide de boulons M3. Une fois que j'ai fixé tous les écrous en place, j'ai continué avec la confection de la jupe pour laquelle j'ai utilisé un simple sac en plastique de poubelle.

J'ai donc d'abord appliqué une colle AC sur la zone médiane du support et l'ai collée sur le sac en plastique. Ensuite, j'ai décalé le périmètre du support d'environ 6 cm. Je l'ai marqué en plusieurs points, puis je les ai connectés ensemble.

À l'aide d'un couteau utilitaire, j'ai coupé le sac en plastique à la bonne taille. Ensuite, j'ai retourné la jupe et ajouté un support supplémentaire au sac où nous l'avions précédemment collé à l'aide de la colle AC.

Ensuite, l'extérieur du sac doit être collé sur le dessus du support. Encore une fois, j'ai utilisé de la colle AC à cette fin et j'y ai soigneusement fixé le sac en plastique.

Une fois cela fait, voici à quoi la jupe devrait ressembler.

Ensuite, j'ai fait des trous dans le sac en plastique où les boulons doivent passer. Le porte-jupe est juste 1 mm plus petit que la coque de l'aéroglisseur, donc en combinaison avec le sac en plastique, il s'intègre parfaitement dans la coque. Pour fixer la jupe à la coque, j'ai simplement fixé les boulons M3 sur tout le périmètre.

Il y a encore une chose à faire pour la jupe et c'est de découper la zone centrale du sac en plastique.

Ainsi, avec cette moitié de l'air va directement gonfler la jupe puis elle va s'échapper par cette ouverture, créant une bulle d'air supplémentaire au milieu.

Enfin, il reste à fixer les hélices aux moteurs brushless. À cette fin, j'utilise la pince fournie avec le moteur sans balais. C'est un moyen très simple et efficace de fixer l'hélice à l'arbre des moteurs.

Cependant, j'ai perdu le collet de mon autre moteur, j'ai donc dû imprimer une version différente de l'hélice pour qu'elle s'adapte directement sur l'arbre du moteur, qui mesure 3,15 mm. L'impression est en fait assez bonne, elle s'adapte et se fixe parfaitement au moteur sans même utiliser de colle.

Et voilà, notre aéroglisseur radiocommandé est enfin terminé.

Cependant, ce qui reste dans cette vidéo est de jeter un œil au code Arduino et au fonctionnement du programme.

Code d'aéroglisseur Arduino RC

Voici le code de ce projet DIY d'aéroglisseur RC basé sur Arduino :

/*
         Arduino based RC Hovercraft
   == Receiver Code - ESC and Servo 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>

#define led 10

RF24 radio(8, 9);   // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;

Servo esc1;  // create servo object to control the ESC
Servo esc2;
Servo servo1;

int esc1Value, esc2Value, servo1Value;
// 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();
  esc1.attach(7);
  esc2.attach(6);
  servo1.attach(5);
  pinMode(led, OUTPUT);
}
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, 50);
  servo1.write(servo1Value);

  // Controlling brushless motor with ESC
  // Lift propeller
  esc1Value = map(data.pot1, 0, 255, 1000, 2000); // Map the receiving value form 0 to 255 to 0 1000 to 2000, values used for controlling ESCs
  esc1.writeMicroseconds(esc1Value); // Send the PWM control singal to the ESC
  
  // Thrust propeller
  esc2Value = constrain(data.j1PotY, 130, 255); // Joysticks stays in middle. So we only need values the upper values from 130 to 255
  esc2Value = map(esc2Value, 130, 255, 1000, 2000);
  esc2.writeMicroseconds(esc2Value);

  // Monitor the battery voltage
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.00 / 1023.00) * 3; // Convert the reading values from 5v to suitable 12V i
  Serial.println(voltage);
  // If voltage is below 11V turn on the LED
  if (voltage < 11) {
    digitalWrite(led, HIGH);
  }
  else {
    digitalWrite(led, LOW);
  }
}
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)

Description : Nous devons donc d'abord inclure la bibliothèque RF24 pour la communication radio ainsi que la bibliothèque servo pour contrôler à la fois le servo et les moteurs brushless. Ensuite, nous devons définir les objets radio et servo, certaines variables nécessaires pour le programme ci-dessous ainsi que la structure des variables qui sont utilisées pour stocker les données entrantes de mon émetteur RC DIY. Pour plus de détails sur le fonctionnement de cette communication, je vous suggère de consulter mon tutoriel particulier.

Dans la section de configuration, nous devons initialiser la communication radio ainsi que définir les broches auxquelles le servo et les contrôleurs sont connectés.

Dans la section de boucle, nous lisons les données entrantes de l'émetteur et utilisons ces valeurs pour contrôler le servo et les moteurs sans balais. Ainsi, les données entrantes du joystick qui varient de 0 à 255 sont converties en valeurs de 0 à 50 et nous utilisons ces valeurs pour contrôler la position du servo.

Avec la même méthode, nous contrôlons les moteurs sans balais à l'aide des ESC. Les données entrantes qui vont de 0 à 255 sont converties en valeurs de 1000 à 2000 et en utilisant la fonction wirteMicroseconds() nous envoyons ces données à l'ESC comme signal de contrôle.

Pour surveiller la tension de la batterie, nous lisons l'entrée analogique provenant du diviseur de tension et avec quelques calculs simples, nous convertissons les valeurs d'entrée en valeur réelle de la tension de la batterie. Si la tension de la batterie tombe en dessous de 11 V, nous allumons simplement le voyant LED.

Et c'est tout. Au cas où vous auriez besoin de plus de détails, vous pouvez consulter les autres tutoriels suggérés et vous pourrez ainsi comprendre parfaitement comment tout fonctionne.

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 à consulter ma collection de projets Arduino.