Char Entièrement Imprimé en 3D : Construire une Plateforme Robotique Chenillée Polyvalente

Dans ce tutoriel, je vous montre comment j'ai construit un véhicule chenillé radiocommandé, une plateforme robotique, ou un char — appelez-le comme vous voulez. Je l'ai conçu from scratch pour être entièrement imprimable en 3D, pour que vous puissiez tout imprimer et en construire un vous-même facilement.

Regardez la vidéo ou suivez le tutoriel écrit.

Vue d'ensemble

Mon but : une plateforme polyvalente capable de traverser divers terrains et servir à diverses applications. Le meilleur choix : chenilles continues. Elles répartissent le poids sur une plus grande surface → excellente adhérence, moins de risque de s'enliser dans boue, neige, terrain mou.

La plateforme roule bien dans la boue ; dommage que je n'aie pas pu tester sur neige. J'espère le faire dans de futures vidéos où je prévois d'installer un bras robotique ou une tourelle. Avec un bras robotique dessus : tâches de préhension/déplacement, ou caméra pour inspection visuelle. Ou une tourelle tirant des fléchettes Nerf, combinée aux LED sympas déjà installées → de quoi bien s'amuser.

Pour la suspension, j'ai utilisé un système Christie (utilisé sur les chars depuis des décennies). Chaque galet a sa propre suspension (ressort + amortisseur).

Ça permet de rouler souplement sur terrain accidenté et de franchir des obstacles tout en gardant un bon contact chenilles/sol.

Pour le pilotage : émetteur RC commercial bon marché envoie les commandes à la plateforme.

À bord : récepteur RC reçoit les commandes et les transmet au microcontrôleur. Cerveau : carte ATmega2560, avec PCB custom qui se clipse dessus pour câblage facile.

Accrochez-vous, je vous guide à travers tout : conception, impression 3D, assemblage, électronique, programmation.

Conception de la Plateforme Robotique

J'ai conçu cette plateforme avec SOLIDWORKS, sponsor de cette vidéo.

— Section sponsorisée —

« Il est à noter que ces outils de conception professionnels leaders du secteur sont maintenant accessibles à tous les makers à un prix remarquablement bas : seulement 99 $/an ou 9,99 $/mois. Oui, 3DEXPERIENCE SOLIDWORKS for Makers est idéal pour quiconque apprend le métier, fait des projets DIY, et plus.

Cette offre inclut 3DEXPERIENCE SOLIDWORKS Professional, l'outil CAO le plus demandé de l'offre, qui tourne en local sur votre PC. Stockage fichiers en local ou cloud via la plateforme 3DEXPERIENCE.

« xDesign », CAO basée navigateur, utilisable avec 3DEXPERIENCE SOLIDWORKS ou seule. Super pour modéliser n'importe où, n'importe quand, sur n'importe quel appareil.

« xShape », CAO libre forme basée navigateur, facile pour modélisation surfacique sur tout appareil.

« Visualize Connected », création facile d'images photo-réalistes, animations, contenus web interactifs et plus pour impressionner votre audience.

« NC Shop Floor Programmer », FAO pour stratégies d'usinage intelligentes 3 axes et EDM fil dans un package facile.

Cliquez le lien ci-dessous pour 20 % de réduction – commencez à créer avec le meilleur dès aujourd'hui ! Grand merci à SOLIDWORKS pour le sponsoring et le soutien à l'éducation comme ça. »

Acheter : https://www.solidworks.com/makers20

En savoir plus : https://discover.solidworks.com/3dexperience-solidworks-makers

— Retour au sujet —

Expliquons la conception. Premiers paramètres d'entrée : ces amortisseurs RC que j'avais et leurs dimensions.

J'en avais 8 → 4 galets par côté. Longueur déployée 41 mm, débattement 11 mm. Selon ces dimensions, je voulais plus de débattement vertical pour les galets → mécanisme donnant 16 mm de débattement vertical.

Je pourrais avoir plus en rapprochant l'articulation amortisseur/bras de galet du point de pivot du bras, mais je perdrais la force du ressort, ou il me faudrait un ressort plus fort pour tenir la plateforme.

J'ai fait des simulations simples sous SOLIDWORKS pour voir les forces de réaction sur les ressorts avec différents mécanismes, et j'ai choisi celui-ci qui offre aussi une bonne compacité globale.

Regardons le galet avant : il est relié à la roue tendeuse avant pour tension dynamique de la chenille. Quand le galet monte, la circonférence de la chenille diminue → tension se relâche.

Avec cette liaison, la roue tendeuse est poussée vers l'avant pour retendre. On peut aussi tendre statiquement en ajustant boulon et écrou d'écartement.

À l'arrière, le pignon de sortie en 3 parties : manchon d'arbre + sections gauche/droite du pignon, assemblées par 3 boulons M3.

Dimension clé du pignon : le pas, qui doit matcher le pas de la chenille. Pas 11 mm ici, 12 dents → diamètre primitif ~42 mm.

Le pas de 11 mm vient du design du maillon de chenille. But : maillon le plus compact possible, raccordable au suivant par une seule pièce (axe), assez solide pour l'impression 3D. Et sans support d'impression → objectif atteint.

Pour relier les maillons : axes 2 mm → un côté 2 mm (serré), l'autre 2,3 mm (libre pour rotation libre).

Les dents du pignon s'engrènent dans cette ouverture où les axes du maillon font 8,8 mm de diam., pignon 9,1 mm (jeu libre).

Une fois toutes ces pièces définies, j'ai fait un croquis dans l'environnement assemblage : contour fermé autour du pignon, roue tendeuse et galets.

Puis j'ai utilisé ce croquis avec la fonction « Chaîne de composants » de SOLIDWORKS pour générer tous les maillons le long de ce contour.

J'ai dessiné le reste de la plateforme : base où tout se fixe, flancs logeant des LED, couvercles supérieurs, dans un style moderne et cool. Dimensions globales ~400×300 mm > plateau imprimante classique → toutes pièces divisées en 2 sections pour imprimer sur presque n'importe quelle imprimante. Assemblées par équerres et boulons M3.

Pour l'assemblage complet : divers boulons/écrous M3/M4, inserts filetés, roulements. Liste complète ci-dessous en section assemblage.

Modèle 3D et Fichiers STL à Télécharger

Modèle 3D de ce char RC / plateforme robotique et fichiers STL pour impression 3D disponibles sur Cults3D.

Impression 3D

Pour des pièces dimensionnellement précises, utilisez les réglages « Expansion horizontale » et « Expansion horizontale des trous » dans votre trancheur. Par défaut, dimensions extérieures et trous sortent plus petits que le modèle.

J'ai mis expansion horizontale à 0,02 mm et expansion horizontale des trous à 0,04 mm. Faites des essais pour trouver les meilleures valeurs sur votre imprimante. Dimensions précises = assemblage facile entre pièces et avec composants (roulements, boulons).

Pour les maillons de chenille, j'ai utilisé un radeau (raft) pour l'adhérence au plateau : surface de contact petite, risque de décollement si adhérence moyenne. Surtout par gros lots, le radeau est plus sûr.

Assemblage du Char Imprimé en 3D – Plateforme Robotique Chenillée

Voici toutes les pièces imprimées. Honnêtement, ça a pris du temps.

Exemple : chaque section de base ~22 h d'impression, 156 maillons ~96 h. ~200 h total. Heureusement, 2 imprimantes → ~100 h.

Liste des pièces

Composants pour l'assemblage de ce char 3D – plateforme robotique. Liste électronique en section schéma de câblage.

• 8× Amortisseurs RC …………………………………….. Amazon / AliExpress
• 8× Ressorts ……………………………………………………………. Amazon / AliExpress
• 40× Roulements 624 – 4×13×5 mm ………………… Amazon / AliExpress
• Inserts filetés M3 ………………………………………….. Amazon / AliExpress
• Boulons/écrous M3 et M4 ……………………………. Amazon / AliExpress
  Boulons :
  M4×40 mm – 8 ; M4×35 mm – 2 ; M4×30 mm – 8 ; M4×25 mm – 2 ; M3×25 mm – 16 ; M3×20 mm – 8 ; M3×16 mm – 10 ; M3×12/14 mm – 32 ; M3×10 mm – 8 ; M3×8 mm – 14
  Écrous :
  M4 – 25 ; M3 – 30
  Rondelles :
  M4 – 30

Note : Ce sont des liens d'affiliation. En tant qu'associé Amazon, je gagne sur les achats éligibles.

J'ai commencé par assembler la base. Comme dit, 2 sections reliées par équerres et boulons/écrous M3.

Pour fixer les équerres latérales, j'utilise des inserts M3 5 mm dans la paroi latérale de la base. Ainsi, l'extérieur du mur est propre (pas de boulons/écrous) pour que les chenilles passent à côté.

Puis je fixe les équerres pour les amortisseurs avec boulons M3.

Ensuite, installation des roulements où pivoteront les bras de galets. Roulements 13 mm ext. / 4 mm int., 2 par galet.

Comme axe : boulon M4×30 mm. Rondelle entre roulement et bras, écrou frein de l'intérieur. Attention au serrage : ni trop fort, ni trop lâche.

Installation de l'amortisseur. Fixé par le boulon M1,4 fourni. Pas de petit tournevis → pince pour serrer. Ça a l'air de marcher nickel.

Galet au bout du bras. Galet en 2 sections pour éviter supports impression. Peut-être imprimable en une pièce, mais pas testé.

Du coup, faut relier les 2 sections. J'ai utilisé tiges acier 2 mm (mêmes que pour maillons chenilles). C'est du laiton pour soudure, assez tendre, se coupe facile à la pince.

3 tiges ~23 mm par roue, + 2 roulements (mêmes qu'avant) de chaque côté. Encore boulon M4, rondelle, écrou frein. La roue doit tourner librement sans jeu axial.

Répéter pour les autres galets. Galet avant : bras légèrement différent avec levier pour tension dynamique chenille, mais montage identique.

Assemblage mécanisme roue tendeuse : 3 pièces imprimées, boulons, écrou d'écartement.

Avant de fixer le premier maillon, mettre écrou frein M4 à l'arrière pour fixer la roue tendeuse plus tard.

Mêmes tiges cuivre 2 mm pour ces articulations. Au 2ème maillon côté roue tendeuse, on fixe un écrou d'écartement M3×15 mm avec boulon M3. De l'autre côté, boulon M3×20 mm + écrou dans l'écrou d'écartement. Avec ça, on règle la distance roue tendeuse/bras de galet → tension statique ET dynamique. Puis on fixe la roue tendeuse par boulon M4. Système de tension + suspension terminés.

Assemblage du pignon : d'abord le moteur. Base conçue pour moteurs diam. 37 mm, axe central ou décentré.

On peut mettre n'importe quel moteur DC 12 V de 20 à 1 000 tr/min selon l'application (on en reparle). Moteur fixé par 6 boulons M3.

Pour fixer le pignon sur l'arbre moteur : d'abord préparer le manchon d'arbre (inserts filetés). On l'insère et on bloque par vis sans tête M3.

Les 2 sections du pignon s'insèrent et se fixent par 3 boulons M3.

Voilà le train de roulement fini. Place à l'assemblage de la chenille — que j'ai trouvé assez fun.

Regard de près sur les maillons : simples et propres.

Ils sortent prêts à l'emploi de l'imprimante (pas de support). Il faut des axes 2 mm. Comme dit, tiges laiton 2 mm pour soudure faciles à couper.

Trous extérieurs = ajustement serré (force pour insérer, mais ça tient). Trous intérieurs = ajustement libre (rotation libre entre maillons).

Thé/café et on profite de l'assemblage pendant 2-3 h. Le fun arrive quand on en a connecté plusieurs et qu'on voit la chenille prendre forme. 78 maillons par chenille. Longueur tiges : ~3,5 m par chenille (chaque axe ~43 mm).

Chenille prête → on l'enroule autour pignon, galets, roue tendeuse, on boucle avec un axe 2 mm au joint. Avec 78 maillons, tension juste, bien que le dernier galet remonte un peu.

C'est parce que le ressort est pas assez fort. On peut ajuster la tension du ressort via l'écrou sur l'amortisseur, mais c'était pas suffisant. Du coup, j'ai changé le ressort d'origine pour un plus fort.

Changement facile : on dévisse une extrémité de l'amortisseur, on met le ressort plus fort, on revisse. Mon ressort était un peu plus large que l'original → rondelle M4 en bas. Maintenant, force suffisante pour tenir le galet en place avec 78 maillons.

J'ai changé les ressorts sur tous les amortisseurs, car ils n'auraient pas tenu le poids de la plateforme complète. Système d'entraînement fini, plutôt réussi je trouve.

Si besoin, on peut encore ajuster la tension chenille via l'écrou d'écartement à la roue tendeuse. Un peu de jeu en haut c'est OK pour que ça marche bien. La partie supérieure lâche est supportée sur les équerres d'amortisseurs.

J'ai branché le moteur pour tester. Parfait. Vraiment super sensation de voir son truc avec autant de pièces imprimées prendre vie.

Faut répéter pour l'autre côté. Plateforme ~80 % finie. Maintenant, panneaux latéraux (surtout pour l'esthétique).

Fixés via équerres et boulons M3. Couvercles supérieurs pour fermer la plateforme. Pour cette vidéo, design purement esthétique.

Comme dit, futures vidéos : bras robotique ou tourelle dessus → faudra redessiner les couvercles.

Électronique – Schéma de Câblage de la Plateforme Robotique

Passons à l'électronique. Carte ATmega2560 comme dit.

Composants nécessaires :

• 2× Moteur DC 12 V – 50 à 500 tr/min ………. Amazon / AliExpress
• Driver DC DRV8871 ……………….…. Amazon / AliExpress
• Arduino MEGA…………………………….….…..… Amazon / AliExpress
• Batterie LiPo 3S ………………………..………….. Amazon / AliExpress
• Connecteur XT60 …………………………..……… Amazon / AliExpress
• Émetteur RC FLYSKY ………………………………. Amazon / AliExpress

Note : Ce sont des liens d'affiliation. En tant qu'associé Amazon, je gagne sur les achats éligibles.

Pour piloter les 2 moteurs : 2 drivers DRV8871 (PWM, jusqu'à 3,6 A crête). Moteurs 12 V, alimentation LiPo 3S (~12 V). J'ai inclus un régulateur 5 V (LM350) pour avoir un 5 V dédié pour usages futurs (ex: servomoteurs). Ici, ce 5 V alimente le récepteur RC et quelques LED.

LED utilisées : simples LED 5 mm blanches et rouges. Disposition :

• Arrière : 2 LED rouges par côté = feux arrière
• Avant : 3 LED blanches par côté = phares
• Supérieur : 6 LED sur couvercle avant = feux de route

Pour allumer correctement : circuit avec résistances de limitation. Connexions combinées série/parallèle.

Exemple phares avant : 2 lignes parallèles 12 V pour 6 LED, 3 par côté gauche/droite en série. Selon tension/courant direct des LED, résistance calculée = 150 Ω par ligne. Pour activer : transistors NPN génériques 200 mA.

Diviseur de tension simple pour surveiller tension batterie : 12 V abaissés sous 5 V → entrée analogique microcontrôleur. Dans le code, conversion en vraie tension et envoi du récepteur à l'émetteur pour affichage sur écran.

Conception PCB Custom

Beaucoup de connexions → PCB custom pour éviter le bazar.

PCB compatible carte ATmega2560, montage direct dessus.

Inclus : régulateur 3,3 V + connecteur pour module NRF24L01 (au cas où contrôle par ce module). Rail 12 V, rails 5 V et 6 V avec broches digitales pour servos. Rail 6 V alimentable par convertisseur abaisseur externe.

Commandé chez PCBWay : upload Gerber, choix propriétés, prix raisonnable. Juste changé couleur = blanc. Fichiers Gerber dispo sur communauté PCBWay pour téléchargement/commande directe.

Dispo aussi ici :

Quelques jours plus tard, PCB reçus. Qualité top, tout conforme au design.

Assemblage PCB simple : tout étiqueté. Commencé par connecteurs pin header au dos (connexion ATmega2560), puis face avant. Pour commodité : petits composants d'abord (résistances, transistors), puis gros (LED, connecteurs alim).

Pin headers pour toutes les connexions = flexibilité pour modifications. Pas soudé connecteurs pour convertisseur abaisseur externe et ses rails, ni régulateur 3,3 V (pas utilisés pour l'instant). J'aime bien le rendu propre de ce PCB blanc.

Finalisation de l'Assemblage du Char Imprimé en 3D

D'abord, on fixe la carte microcontrôleur par boulons M3, puis le PCB custom par-dessus.

Installation des LED. Elles s'insèrent dans les panneaux latéraux via des supports pour LED 5 mm. Selon schéma, souder chaque ligne de LED en série.

Cathode = fil noir, anode = fil rouge. Fils passent par petite ouverture dans panneaux latéraux vers le PCB.

Le support LED fait ajustement serré avec le panneau → look propre une fois inséré.

LED de route directement sur couvercle avant supérieur.

Pour connecter LED : j'ai soudé connecteurs mâles XH2,54 mm (DuPont) sur PCB, il me fallait connecteurs femelles DuPont sur fils. Faut pince à sertir mais j'en avais pas à ce moment.

J'ai fait avec petite pince normale, connexions nickel. Chaque ligne LED dans le bon connecteur étiqueté sur PCB.

Pour les moteurs : pas de connecteurs adaptés → soudure directe sur moteurs. Connexion moteur → driver DRV8871 → PCB.

Radio : émetteur/récepteur FLYSKY, abordables et fiables.

Connexion récepteur → micro : fils dupont. Récepteur communique via I-BUS et port série → 3 fils : VCC, GND, Signal.

Pour renvoyer données récepteur→émetteur (surveillance tension batterie), il faut aussi connecter le capteur I-BUS du récepteur à un autre port série.

Enfin, connexion batterie LiPo. Connecteur selon batterie. Dans connecteur 12 V, à côté interrupteur ON/OFF pour couper l'alim.

Important : avant d'alimenter la carte, retirer le récepteur RC de l'alim et régler la tension variable du LM350 à 5 V via le potentiomètre de réglage.

On remet le couvercle arrière supérieur, et c'est fini.

Programmation de la Plateforme Robotique

Il faut programmer le char 3D / plateforme robotique. Voici le code Arduino :

/* Plateforme Robotique Chenillée Imprimée 3D - Code Arduino par Dejan, www.HowToMechatronics.com
Bibliothèques: IBusBM: https://github.com/bmellink/IBusBM */
#include 
#define motorLeft_IN1 4
#define motorLeft_IN2 5
#define motorRight_IN1 6
#define motorRight_IN2 7
IBusBM IBus;
IBusBM IBusSensor;
int ch0, ch1, ch6, ch8 = 0;
int motorSpeed, steeringValue, leftMotorSpeed, rightMotorSpeed = 0;
int ledBlinkPeriod = 50;
int isOn = LOW;
unsigned long time_now = 0;
void setup() {
  Serial.begin(115200);
  IBus.begin(Serial1, IBUSBM_NOTIMER); // Servo iBUS
  IBusSensor.begin(Serial2, IBUSBM_NOTIMER); // Capteur iBUS
  IBusSensor.addSensor(IBUSS_INTV); // capteur tension
  // Moteurs DC - arrêt initial
  // Chenille gauche
  digitalWrite(motorLeft_IN1, LOW); // PWM
  digitalWrite(motorLeft_IN2, LOW); // Avant
  // Chenille droite
  digitalWrite(motorRight_IN1, LOW); // PWM
  digitalWrite(motorRight_IN2, LOW); // Avant
  digitalWrite(46, LOW);
  digitalWrite(47, LOW);
  digitalWrite(48, LOW);
}
void loop() {
  // Lecture données émetteur RC
  IBus.loop();
  ch0 = IBus.readChannel(0); // gauche/droite
  ch1 = IBus.readChannel(1); // avant/arrière
  ch6 = IBus.readChannel(6); // phares
  ch8 = IBus.readChannel(8); // feux de route
  // Conversion en valeurs PWM
  steeringValue = map(ch0, 1000, 2000, -185, 185); // 0-185 car +70 après pour éviter PWM trop bas
  motorSpeed = map(ch1, 1000, 2000, -185, 185);
  motorSpeed = abs(motorSpeed);
  leftMotorSpeed = 70 + motorSpeed + steeringValue; // 70 + (0-185) + (0-185) = 70-255
  rightMotorSpeed = 70 + motorSpeed - steeringValue;
  leftMotorSpeed = constrain(leftMotorSpeed, 0, 255);
  rightMotorSpeed = constrain(rightMotorSpeed, 0, 255);
  // Si PWM < 72 → 0
  if (leftMotorSpeed < 72) { leftMotorSpeed = 0; }
  if (rightMotorSpeed < 72) { rightMotorSpeed = 0; }
  // Joystick droit haut = avance
  if (ch1 > 1510 && ch1 < 2000) {
    analogWrite(motorLeft_IN1, leftMotorSpeed);
    digitalWrite(motorLeft_IN2, LOW);
    analogWrite(motorRight_IN1, rightMotorSpeed);
    digitalWrite(motorRight_IN2, LOW);
  }
  // Joystick droit bas = recule
  if (ch1 > 1000 && ch1 < 1420) {
    digitalWrite(motorLeft_IN1, LOW);
    analogWrite(motorLeft_IN2, leftMotorSpeed);
    digitalWrite(motorRight_IN1, LOW);
    analogWrite(motorRight_IN2, rightMotorSpeed);
  }
  // Joystick centre = arrêt
  if (ch1 > 1420 && ch1 < 1520) {
    if (leftMotorSpeed < 75 && rightMotorSpeed < 75) {
      digitalWrite(motorLeft_IN1, LOW);
      digitalWrite(motorLeft_IN2, LOW);
      digitalWrite(motorRight_IN1, LOW);
      digitalWrite(motorRight_IN2, LOW);
    }
    // Juste gauche/droite sans avant/arrière = rotation sur place (1 seul moteur)
    else {
      analogWrite(motorLeft_IN1, leftMotorSpeed);
      digitalWrite(motorLeft_IN2, LOW);
      analogWrite(motorRight_IN1, rightMotorSpeed);
      digitalWrite(motorRight_IN2, LOW);
    }
  }
  // Contrôle LED
  // Phares et feux arrière
  if (ch6 > 1500) {
    digitalWrite(47, HIGH);
    digitalWrite(48, HIGH);
  } else {
    digitalWrite(47, LOW);
    digitalWrite(48, LOW);
  }
  // Feux de route
  if (ch8 == 1500) {
    digitalWrite(46, HIGH);
  }
  // Interrupteur position 3 (2000) = clignotement feux de route
  else if (ch8 == 2000) {
    if (millis() >= time_now + ledBlinkPeriod) {
      time_now += ledBlinkPeriod;
      if (isOn == HIGH) { isOn = LOW; }
      else { isOn = HIGH; }
      digitalWrite(46, isOn);
    }
  } else {
    digitalWrite(46, LOW);
  }
  // Surveillance tension batterie
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.00 / 1023.00) * 3.02; // Conversion 5V → 12V
  // Envoi tension à l'émetteur
  IBusSensor.loop();
  IBusSensor.setSensorMeasurement(1, voltage * 100);
}

Aperçu du Code

Via bibliothèque IBusBM, lecture données émetteur RC :

// Lecture données émetteur RC
IBus.loop();
ch0 = IBus.readChannel(0); // gauche/droite
ch1 = IBus.readChannel(1); // avant/arrière
ch6 = IBus.readChannel(6); // phares
ch8 = IBus.readChannel(8); // feux de route

Joystick droit (canaux 0, 1) = mouvement plateforme ; 2 interrupteurs (canaux 6, 8) = LED.

Conversion données en valeurs PWM 0–255 pour moteurs DC :

// Conversion en valeurs PWM
steeringValue = map(ch0, 1000, 2000, -185, 185);
motorSpeed = map(ch1, 1000, 2000, -185, 185);
motorSpeed = abs(motorSpeed);
leftMotorSpeed = 70 + motorSpeed + steeringValue;
rightMotorSpeed = 70 + motorSpeed - steeringValue;
leftMotorSpeed = constrain(leftMotorSpeed, 0, 255);
rightMotorSpeed = constrain(rightMotorSpeed, 0, 255);

Envoi PWM aux drivers/moteurs via analogWrite().

// Joystick haut = avance
if (ch1 > 1510 && ch1 < 2000) {
  analogWrite(motorLeft_IN1, leftMotorSpeed);
  digitalWrite(motorLeft_IN2, LOW);
  analogWrite(motorRight_IN1, rightMotorSpeed);
  digitalWrite(motorRight_IN2, LOW);
}

Globalement, code pas compliqué car plateforme pas de fonctions complexes.

Test du Robot Imprimé 3D – Plateforme Robotique Chenillée

Code uploadé, on alimente plateforme et émetteur. Sur écran : tension LiPo, tensions récepteur/émetteur.

Voilà. Joystick droit = mouvement plateforme. Interrupteur gauche = phares/feux arrière. Interrupteur droit 3 positions = feux de route (2 modes : fixe et clignotant).

Note : les moteurs installés sont un peu sous-dimensionnés pour cette plateforme.

Il faut pousser le joystick presque à fond pour que les chenilles démarrent. Et j'arrête la chenille facile à la main. Suspension + chenilles = beaucoup de tension/résistance pour les moteurs. Moteurs 888 tr/min (vitesse OK) mais petits, < 500 mA nominal.

Je les ai remplacés par des plus gros que j'avais : presque mêmes résultats. Plus puissants, mais réduction de vitesse moindre (1 280 tr/min) → même résultat.

En fait, pas si mal. La plateforme roule bien avec.

Honnêtement, c'est vraiment fun à piloter, surtout avec LED clignotantes et burnouts/donuts.

Mais le fun n'a pas duré : dehors, ça a planté vite. Problème : moteurs sous-dimensionnés, MAIS AUSSI design des maillons de chenille. La boue/saleté se coince là où les dents du pignon s'engrènent.

J'ai redessiné les maillons avec une ouverture de l'autre côté pour que la saleté passe au travers. J'ai aussi réduit un peu le pignon (décalage 0,2 mm) pour un jeu plus large pignon/chenille.

Réassemblé avec ces modifs → plateforme capable de rouler dehors. Mais moteurs encore limite : plateforme coincée par moments, ne monte pas les côtes. Suggestion : moteurs ≤ 500 tr/min, et plus costauds (≥ 1 A ou 2 A nominal).

J'ai testé avec moteurs plus forts : 20 tr/min (trop lent pour fun/donuts), mais plateforme = vrai char. Grimpe partout.

20 tr/min = assez puissant pour tout franchir. Très lent, mais OK pour certaines applis. Mon conseil : si vitesse lente nécessaire → ~50 tr/min ; si vitesse rapide → ~500 tr/min.

J'espère que cette vidéo vous a plu et appris quelque chose. Questions en commentaires, abonnez-vous pour les mises à jour et voir ma collection Projets Arduino.