Construire une machine à cintrer le fil 3D pilotée par Arduino : guide complet

Présentation

Ce tutoriel montre la construction d'une machine à cintrer le fil 3D pilotée par Arduino. Système méchatronique typique (mécanique, électrique, informatique), idéal pour étudiants ou débutants en méca.

Vidéo ou tutoriel écrit.

Principe de fonctionnement

Le fil passe par des rouleaux redresseurs. Un moteur pas-à-pas (alimentation) avance le fil précisément vers le mécanisme de cintrage (moteur pas-à-pas + micro servo). Un 3ème moteur pas-à-pas (axe Z) fait pivoter le mécanisme autour du fil pour créer des formes 3D. Cerveau : Arduino + électronique sur PCB custom.

Programme : fonctions formes prédéfinies (étoile, cube, support) + mode manuel (commandes série).

Modélisation 3D

Inspiration : vidéo YouTube. Modèle sur Thangs (visualisation + téléchargement).

Pièces imprimées 3D : engrenages, paliers à semelle, manchons d'arbre. Fichiers STL inclus. Creality CR-10 : excellente qualité.

Construction mécanique

Base et rails

MDF 8 mm + contreplaqué 18 mm. Découpe scie circulaire (établi maison avec scie circulaire, toupie, scie sauteuse - chaîne YouTube Creativity Hero). Ouvertures scie sauteuse inversée.

Base : 2 plaques MDF + 4 colonnes contreplaqué (colle bois + vis). Rail horizontal : 2 tubes alu 16 mm × 27 cm. Rail vertical : 3 tubes 20 mm × 45 cm. Fixation sur bois massif avec alésages forêt Forstner.

Chariots (sliders)

Planche 21×21 cm, trous 8 mm, tiges filetées M8 + roulements 22 mm (horizontal : roulements 16 mm). Problème : jeu excessif. Solution : réduire écart rails (élargir alésages, fentes perpendiculaires, tige filetée pour rapprocher).

Axe Z (rotation)

Tube cuivre 15 mm (intérieur) × 30 cm traversant roulements 6202 (ext. 35 mm, int. 15 mm). Engrenage imprimé 3D (module 1.5, 30 dents) avec encoches pour écrous M3 + boulons serrage sur arbre.

Moteur pas-à-pas Z : support imprimé, engrenage 18 dents sur arbre. Fixation par fentes (ajustement engrenages).

Moteur alimentation (feeder)

NEMA 17 fixé directement sur plaque supérieure (écrous comme entretoises). Accouplement imprimé + tube cuivre (surface contact). Levier opposé avec roulement pressant sur tube + plaque contreplaqué + écrou T pour réglage pression.

Redresseur fil (straightener)

3 boulons M8 fixent plaque contreplaqué percée. Rouleaux = roulements + bagues cannelées imprimées 3D. 3 rouleaux d'un côté, 2 de l'autre (fentes pour affleurement boulons). Serrage écrous. Guides fil avant/après.

Mécanisme de cintrage (bender)

Plaque MDF façonnée (scie, râpe). Perçage 38 mm (scie cloche) pour NEMA 23 (cintrage). Fixation M4. Engrenage module 2.5, 18 dents sur arbre NEMA 23. Engrenage 30 dents custom avec plaque fixation servo MG996R. Servo actionne crémaillère (pignon sur rondelle) → goupille sort de l'engrenage pour cintrer fil. Époxy 5 min : roulement sur engrenage + tube cuivre sur crémaillère (surface contact).

Assemblage : engrenage 30 dents fixé boulon M8 + écrou. Crémaillère + servo en place (vis fournies). Pignon sur rondelle servo (2 vis M3).

Fixation bender sur axe Z

2 colliers d'arbre imprimés 3D. Fixés sur plaque bender (M6), insérés sur axe Z, serrage boulons/écrous. Toutes pièces mobiles fonctionnelles.

Détails finaux

Buse 3 mm sur arbre sortie fil. Fin de course micro sous bender (position initiale).

Schéma électronique

3 moteurs pas-à-pas → 3 drivers DRV8825. Alimentation 12V ≥3A. Servo MG996R gourmand → régulateur 5V dédié LM7805 (Arduino 5V insuffisant). Fin de course + résistance pull-up sur pin digital.

Composants

• Moteur pas-à-pas NEMA 17 (×2)
• Moteur pas-à-pas NEMA 23
• Drivers DRV8825 (×3)
• Fin de course micro
• Alim 12V 2A+ / Jack DC
• Arduino (Uno/Nano/Mega)

PCB Custom

Élimination câblage désordonné. EasyEDA, double face. Sélection résolution pas-à-pas, 2ème fin de course, broches digitales/analogiques supplémentaires.

Fichiers projet PCB. Gerber → JLCPCB (sponsor). Qualité parfaite.

Assemblage électronique

Connecteurs mâles soudés (facilite déconnexion). Composants CMS (condensateurs, résistances, LM7805, borniers) soudés directement. Drivers pas-à-pas + Arduino insérés. Câblage : prise alim + interrupteur sur borniers, câbles moteurs ↔ PCB, servo pin 2 + 5V LM7805. Sélection micro-pas (1/16 étape : broches spécifiques).

Code Arduino

Librairie AccelStepper (Mike McCauley) + Servo.h.

#include <AccelStepper.h> 
#include <Servo.h> 
#define limitSwitch 11

AccelStepper feederStepper(1, 5, 6);  // Driver, STEP, DIR
AccelStepper zAxisStepper(1, 7, 8);
AccelStepper benderStepper(1, 9, 10);
Servo servo01;

String dataIn = ""; String manualStatus = "";
int count = 0; int dist;

Setup : position initiale servo + homing bender

void setup() {
  Serial.begin(9600);
  pinMode(limitSwitch, INPUT_PULLUP);
  servo01.attach(2); servo01.write(40); // Goupille relevée
  
  feederStepper.setMaxSpeed(2000);
  zAxisStepper.setMaxSpeed(2000);
  benderStepper.setMaxSpeed(2000);
  
  // Homing bender vers fin de course
  while (digitalRead(limitSwitch) != 0) {
    benderStepper.setSpeed(1200);
    benderStepper.runSpeed();
    benderStepper.setCurrentPosition(0);
  }
  delay(40);
  // Décalage 1400 pas depuis fin de course = position 0°
  while (benderStepper.currentPosition() != -1400) {
    benderStepper.setSpeed(-1200); // Anti-horaire
    benderStepper.run();
  }
  benderStepper.setCurrentPosition(0);
}

Boucle principale : modes automatique / manuel

void loop() {
  String mode = Serial.readString();
  if (mode.startsWith("manual")) manual();
  if (mode.startsWith("star")) star();
  if (mode.startsWith("cube")) cube();
  if (mode.startsWith("stand")) stand();
}

Fonction star() : étoile 5 branches

void star() {
  while (count != 5) {
    int feed = 38; // mm
    int feedDistance = feed * 48; // 48 pas/mm
    
    // Avancer fil
    while (feederStepper.currentPosition() != feedDistance) {
      feederStepper.setSpeed(1200); feederStepper.run();
    }
    feederStepper.setCurrentPosition(0);
    servo01.write(40); delay(200); // Goupille up
    
    int angleConst = 18; // Constante angle→pas
    
    // Cintrage 52°
    while (benderStepper.currentPosition() != -52 * angleConst) {
      benderStepper.setSpeed(-700); benderStepper.run();
    }
    benderStepper.setCurrentPosition(0); delay(100);
    
    // Retour 52°
    while (benderStepper.currentPosition() != 52 * angleConst) {
      benderStepper.setSpeed(1200); benderStepper.run();
    }
    benderStepper.setCurrentPosition(0); delay(100);
    
    // Avancer même longueur
    while (feederStepper.currentPosition() != feedDistance) {
      feederStepper.setSpeed(1200); feederStepper.run();
    }
    feederStepper.setCurrentPosition(0); delay(100);
    
    servo01.write(130); delay(200); // Goupille down
    
    // Nouvelle position initiale sens inverse
    while (benderStepper.currentPosition() != -42 * angleConst) {
      benderStepper.setSpeed(-1200); benderStepper.run();
    }
    benderStepper.setCurrentPosition(0); delay(200);
    servo01.write(40); delay(200); // Goupille up
    
    // Cintrage 105° sens inverse
    while (benderStepper.currentPosition() != 105 * angleConst) {
      benderStepper.setSpeed(700); benderStepper.run();
    }
    benderStepper.setCurrentPosition(0); delay(50);
    
    // Retour 63°
    while (benderStepper.currentPosition() != -63 * angleConst) {
      benderStepper.setSpeed(-1200); benderStepper.run();
    }
    delay(100); servo01.write(130); // Goupille down
    benderStepper.setCurrentPosition(0);
    count++;
  }
}

Fonctions cube() et stand() : même principe

Séquences d'avance, cintrage ±90°, rotation axe Z, alternance goupille up/down. Code complet en fin d'article.

Mode manuel : commandes série

if (dataIn.startsWith("f")) { // Feed: f + distance mm
  dataInS = dataIn.substring(1); dist = dataInS.toInt();
  dist = dist * 48;
  while (feederStepper.currentPosition() != dist) { ... }
}
if (dataIn.startsWith("b")) { // Bend: b + angle (ex: b-30 ou b45)
  // Gestion signe, position initiale adaptée, cintrage, retour
}
if (dataIn.startsWith("z")) { // Z-axis: z + angle
  // Rotation axe Z
}

Code complet disponible ici.

Problème connu : redresseur

Si serrage trop fort → perte adhérence alimentation. Solutions : matériau plus dur que cuivre, ou système d'alimentation différent.

J'espère que ce projet vous a plu. Questions en commentaires, découvrez mes autres projets Arduino !