Construire un aéroglisseur RC Arduino : Conception 3D imprimée et guide programmation

Dans ce tutoriel, nous allons apprendre à construire un aéroglisseur RC basé sur Arduino. Je vous montrerai tout le processus : conception et impression 3D des pièces (y compris hélices), câblage électronique et programmation Arduino.

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

Vue d'ensemble

Pour le contrôle, j'ai utilisé mon émetteur RC Arduino DIY (vidéo précédente). Joystick droit → servo pour orientation gouvernes arrière du moteur de propulsion. Un potentiomètre → hélice de sustentation (moteur brushless DC). Joystick gauche → propulsion.

Modèle 3D de l'aéroglisseur

Conception via logiciel 3D.

Modèle 3D disponible en téléchargement et exploration navigateur sur Thangs.

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

Fichiers STL pour impression 3D :

Principe de fonctionnement de l'aéroglisseur

Base : l'engin est soulevé par un coussin d'air. L'hélice centrale souffle l'air sous l'engin, gonflant une jupe en matière souple.

Quand la pression dans la jupe est suffisante, l'engin se soulève. L'air s'échappe constamment par le centre, entre jupe et sol, créant sustentation supplémentaire et réduisant frottements.

Une fois soulevé, la seconde hélice génère la poussée pour avancer.

À l'arrière de l'hélice de propulsion, un jeu de gouvernes simples assure la direction.

Impression 3D

Une fois la conception finie, impression des pièces.

Coque de l'aéroglisseur = plus grosse pièce, conçue pour mon Creality CR-10 (plateau 30x30cm).

Lien vers cette imprimante 3D.

Après impression, nettoyage. Cockpit (corps principal) = impression la plus longue (~18h). Design courbé + pièce unique = beaucoup de supports.

Supports faciles à retirer, pièce finale parfaite. Coque imprimée à l'envers, peu de supports. Ajustement nécessaire : découpe matière dans logement souffleur central pour passer support de jupe. Modèle 3D mis à jour pour corriger.

Zones arrondies un peu rugueuses → ponçage papier de verre.

Hélices : pas de nettoyage nécessaire, fonctionnent bien direct sortie imprimante.

Peinture de l'aéroglisseur

Peinture pièces 3D. Pas d'apprêt, directement peinture acrylique en bombe.

Première couche : marron chocolat. Petites pièces décoratives : marron plus clair.

Pour look plus sympa : après séchage première couche, ajout de deux couleurs via motifs aléatoires sur papier servant de pochoirs pour rayures/taches. Marron clair et noir.

Assemblage de l'aéroglisseur RC Arduino

Pièces sèches → assemblage.

Installation servo gouvernes sur logement souffleur propulsion. Fixation 2 boulons/écrous M2.

Moteur brushless : modèle D2830 (28mm diam, 30mm long), logement adapté.

Insertion moteur : passage fils par ouvertures (serré mais faisable). Fixation arrière par 4 boulons M3.

Assemblage logement propulsion + corps principal. Ouverture pour passage fils servo et BLDC.

Fixation ferme par 4 boulons M3.

Second moteur brushless sur coque. Même méthode : passage fils, fixation 4 boulons M3 arrière.

Schéma de circuit

Électronique placée entre coque et corps principal. Schéma de câblage :

Cerveau : carte Arduino. Contrôle servo + 2 moteurs brushless via 2 ESC. Alimentation BLDC : batterie Li-Po 3S ~11V. Arduino alimenté par 5V régulé des ESC via BEC.

Communication sans fil : module NRF24L01 (avec antenne amplifiée : portée stable jusqu'à 700m en espace ouvert). Émetteur RC = mon émetteur DIY précédent (voir tutoriel dédié). Tutoriels détaillés NRF24L01 et moteurs brushless Arduino disponibles. Principe de base : émetteur envoie données joysticks/potentiomètres au récepteur qui contrôle vitesse moteurs brushless et position servo.

Détail supplémentaire : surveillance batterie. Diviseur de tension (2 résistances) connecté directement à la batterie, sortie vers entrée analogique Arduino. Diviseur abaisse 11V → ~4V acceptable par broches 5V Arduino. Permet surveillance tension, allumage LED si tension < 11V.

Composants nécessaires :

• Module NRF24L01
• NRF24L01 + PA + LNA
• Moteur brushless
• ESC 30A
• Batterie Li-Po
• XT60 2 Femelles vers 1 Mâle
• Connecteur XT60
• Servomoteur
• Carte Arduino

Connexion composants. Pour 2 ESC sur une batterie : répartiteur parallèle type XT60.

Interrupteur d'alimentation : connecteur XT60, coupe un fil, soude interrupteur bascule. Un côté vers répartiteur Y, autre vers batterie.

Placement ESC dans corps principal, coincés entre corps et coque. Fixation 4 boulons M3 assemblant les deux parties. Insertion batterie dans cockpit par ouverture supérieure.

Connexion composants à l'Arduino : ajout 2 rangées de connecteurs sur Arduino pour GND et 5V.

Tout connecté → passage antenne NRF24L01, LED indicateur, interrupteur, par couvercle supérieur du cockpit.

Tassement dans cockpit. Un peu serré avec Arduino UNO, Nano aurait été mieux.

Tout rentré, pièce décorative sur couvercle, clipser sur corps cockpit.

Système de direction : petit lien sur disque servo (boulon/écrou M2). Insertion première gouverne, fixation au logement propulsion par fil métallique 2mm traversant son corps (rotation libre). Même chose pour seconde gouverne.

Seconde gouverne a fente supplémentaire pour connexion au lien servo. Fixation boulon/écrou M2. Connexion deux gouvernes entre elles par autre lien. Système direction terminé.

Pièce décorative latérale : perçage, fixation par vis unique sur coque. Deux côtés, s'intègre bien à l'allure générale.

Fabrication jupe aéroglisseur. Support jupe a trous pour fixation sur coque.

Emplacements pour écrous → fixation support jupe sur coque par boulons M3. Jupe en sac poubelle plastique simple.

Colle cyanoacrylate zone centrale support → collage sur sac. Décalage périmètre support ~6cm, repérage points, liaison.

Découpe sac au cutter à la bonne taille. Retour jupe, renforts collage zone centrale (colle cyano).

Extérieur sac collé sur haut support. Colle cyano, fixation soignée.

Jupe finie :

Perçage trous sac pour passage boulons. Support jupe 1mm plus petit que coque → avec sac, ajustement parfait dans coque. Fixation jupe à coque : serrage boulons M3 tout le pourtour.

Dernière étape jupe : découpe zone centrale du sac.

Moitié air gonfle jupe directement, moitié s'échappe par ouverture → bulle d'air centrale additionnelle.

Fixation hélices sur moteurs brushless. Collet fourni avec moteur : méthode simple/efficace pour fixer hélice sur arbre.

Collet perdu pour l'autre moteur → impression version hélice adaptée directement sur arbre (3.15mm). Impression réussie, ajustement parfait sans colle.

Notre aéroglisseur radiocommandé est enfin terminé.

Reste à examiner le code Arduino et son fonctionnement.

Code aéroglisseur RC Arduino

Code pour ce projet DIY aéroglisseur RC Arduino :

/* Aéroglisseur RC Arduino == Code Récepteur - Contrôle ESC et Servo 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>
#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; // objet servo pour contrôle ESC
Servo esc2;
Servo servo1;
int esc1Value, esc2Value, servo1Value;
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();
  esc1.attach(7);
  esc2.attach(6);
  servo1.attach(5);
  pinMode(led, OUTPUT);
}
void loop() {
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) { resetData(); }
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package));
    lastReceiveTime = millis();
  }
  // Contrôle servo
  servo1Value = map(data.j2PotX, 0, 255, 0, 50);
  servo1.write(servo1Value);
  // Contrôle moteurs brushless via ESC
  // Hélice sustentation
  esc1Value = map(data.pot1, 0, 255, 1000, 2000);
  esc1.writeMicroseconds(esc1Value);
  // Hélice propulsion
  esc2Value = constrain(data.j1PotY, 130, 255); // Joystick centre, valeurs supérieures 130-255
  esc2Value = map(esc2Value, 130, 255, 1000, 2000);
  esc2.writeMicroseconds(esc2Value);
  // Surveillance tension batterie
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.00 / 1023.00) * 3;
  Serial.println(voltage);
  if (voltage < 11) { digitalWrite(led, HIGH); } else { digitalWrite(led, LOW); }
}
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 : Inclusion bibliothèque RF24 (radio) et Servo (servo + moteurs brushless via ESC). Définition radio, objets servo, variables, structure données pour stockage données entrantes de mon émetteur RC DIY. Détails communication : voir tutoriel dédié.

Setup : initialisation radio, définition broches servo/ESC.

Loop : lecture données émetteur, utilisation valeurs pour contrôle servo et brushless. Données joystick (0-255) → conversion 0-50 pour position servo. Même méthode pour brushless via ESC : 0-255 → 1000-2000µs via writeMicroseconds().

Surveillance batterie : lecture entrée analogique diviseur tension, conversion math simple → tension réelle. Si < 11V → allumage LED indicateur.

Pour plus de détails, consultez les tutos suggérés pour tout comprendre.

J'espère que ce tutoriel vous a plu et appris quelque chose. Questions en commentaires, et découvrez ma collection de projets Arduino.