On trouve de nombreux projets pour recycler d’anciens lecteurs de DVD en mini traceur CNC (CNC Plotter) à base d’Arduino. C’est un projet sympa et idéal pour débuter avec son Arduino. La réalisation mécanique et plus particulièrement le support de crayon peut être difficile. Je vous propose donc dans cet article de réaliser un mini traceur en réalisant les éléments mécaniques par impression 3D. Nous utiliserons deux ponts en H L293D pour piloter les moteurs des lecteurs de DVD. On en trouve pour moins de 2€ en Chine.

Etape 1 : matériel nécessaire pour réaliser le Mini Plotter CNC

J’ai essayé d’employer des matériaux que l’on peut se procurer facilement en magasin de bricolage et des composants les moins chers possibles pour la fabrication du Mini Traceur. Pour piloter les moteurs pas à pas des axes X et Y, nous avons deux possibilités. Soit utiliser deux ponts en H L293D (un pour chaque axe), c’est ce qui coûte le moins cher, soit utiliser un Motor Shield pour Arduino.

• 1x Arduino Uno (ou n’importe quel clone)
• 1x Breadboard 400 points
• 2x ponts en H L293D
• 1x servomoteur (par exemple un SG90)
• 2x lecteurs de DVD à recycler
• Du fils 22AWG 15cm pour chaque couleur (jaune, vert, rouge, blanc)
• 20 cm de gaine thermo-retractable
• 1x plaque de contreplaque de 20 x 16 cm (épaisseur 10mm) pour la base du Mini Traceur (axe X). Vous pouvez remplacer le contreplaqué par du plexiglass, le tout est d’avoir un plaque très plane.
• 2x plaques de contreplaqué de  15 x 5 cm pour réaliser les montants de l’axe Y.
• 1x plaque support de dessin de 76 x 76 mm (la taille d’un post it). Je vous conseille d’utiliser du plexiglass de 5mm d’épaisseur pour une bonne planéité.
• 1x ressort diamètre 8mm, 6 à 8 spires récupéré sur un stylo par exemple
• 1x axe diamètre 3mm x  80mm ou de la tige filetée. Vous pouvez également utiliser un axe de guidage d’un autre lecteur de CD/DVD usagé.
• 1x pistolet à colle
• Vis et écrous
  • 2x vis M2 pour fixer le servomoteur. Vous pouvez également le coller
  • 8x vis M4 x 35mm
  • 8x écrou M4
  • 1x vis M5 x 20mm
  • 1x écrou M5
  • 1x écrou papillon M5
  • Des rondelles diamètre 14mm
• Câbles Dupont M/M

Etape 2 : Démonter les lecteurs de DVD pour récupérer les systèmes de translation

Démontez vos lecteurs de DVD pour ne conserver que le mécanisme de déplacement de la tête de lecture. Vous pouvez également démonter (et conserver) le moteur d’ouverture de la porte (ce n’est pas toujours facile).

Quelques astuces

Je vous conseille une course d’au moins 35mm. Certains lecteurs ont une course plus courte. Il est possible de le changer dans les réglages mais j’ai trouvé la mise au point laborieuse et surtout la surface de dessin sera vraiment petite.

Retirez tous les éléments électroniques de la tête de lecture(et les conserver pour d’autres projets). Il faut obtenir une surface plane pour pouvoir coller correctement le plateau de dessin et le porte de crayon.

Etape 3 : Préparer les moteurs pas à pas (stepper motors) des axes X et Y

Dans cette étape, nous allons réaliser les soudures sur les moteurs pas à pas des axes X et Y.

Nous avons deux possibilités pour souder les fils sur les moteurs pas à pas. La première solution consiste à souder directement les fils au niveau du moteur. Sur certains moteurs comme celui-ci c’est assez facile car les 4 pistes sont bien distincts.

Je vous le déconseille toutefois car vous risquer des désouder les fils des bobines ou des les arracher ultérieurement lors du montage. Je vous conseille plutôt de réaliser vos soudures au niveau du ruban souple. Tout d’abord, utilisez un cutter pour séparer chaque piste sur environ 2cm. Etamez ensuite le bout de la piste et le fil préalablement dénudé. Protégez chaque soudure avec un morceau de 25mm de gaine thermo-retractable.

Il n’y a aucun repérage sur le moteur mais le branchement est assez simple. Le premier fil correspond (en général) à la 1ère sortie du L293D (ou Motor Shield) et ainsi de suite. Je vous conseille vivement d’utiliser un code couleur pour vous y repérer plus facilement lors du câblage.

Etape 4 : Impression des éléments de structure

Vous pouvez récupérer les fichiers STL des éléments de structure à imprimer sur Thingiverse ou Cults3D.

Le kit contient les éléments de structure suivants :

Tous les éléments de structure ont été conçu à l’aide du logiciel open source Open Scad. Vous êtes libre de les adapter en fonction de vos besoins. Vous aurez besoin de 9.55m de PLA (29 grammes). L’impression en mode rapide demande environ 3h sur ma Dagoma discovery200.

Etape 5 : Fabrication de la structure en contreplaqué

Pour réduire le coût du projet, j’ai opté pour réaliser la structure en contreplaqué de 10mm d’épaisseur disponible dans n’importe quel magasin de bricolage. La fabrication est très simple. Il n’y a que 3 plaques de contreplaqué à découper. Vous devrez adapter le perçage pour la fixation des axes en fonction de vos lecteurs de DVD. Généralement, l’entre axe est de 85mm en largeur. La longueur est variable.

Etape 6 : Branchement du circuit

Le câblage du Mini Traceur est assez simple. Il est composé de 2 ponts en H L293D et d’un servomoteur pour l’axe Z. Une breadboard 400 points est suffisante.

Etape 7 : Assemblage du Mini Traceur

Axes X et Y

Commencez par fixer l’axe X à l’aide des 4 entretoises et de 4 vis M4 x 30mm.

Fixez ensuite les 2 montants verticaux de l’axe Y en venant vous appuyer contre le cadre de l’axe X à l’aide des 4 équerres.

Enfin fixez l’axe Y sur les montants verticaux. La hauteur n’est pas importante, elle sera régler ultérieurement en ajustant simplement la position du crayon dans son support.

Plateau de dessin

Utilisez un pistolet à colle pour fixer le plateau de dessin. Pour trouver la bonne position du plateau, je vous conseille de déplacer le chariot au maximum. Utilisez des rondelles pour ajuster la planéité du plateau de dessin. Inutile de sortir le niveau à bulle, le ressort va compenser les petits défauts.

Porte crayon (axe Z)

Après avoir vissé le servomoteur à l’aide de 2 vis M2 (ou collé) sur le support, collez celle-ci sur le chariot de l’axe Y.

Insérer l’axe de diamètre 3mm par le haut. En maintenant le ressort, mettez en place sur porte crayon puis glissez l’axe dans le logement prévu sur le porte crayon. Allez jusqu’en butée. Terminez le montage en ajoutant le serrage du crayon qui sert également d’arbre pour lever le porte crayon. Pour assembler le système de serrage, vissez un écrou M5 sur une vis M5 x 25mm en laissant un espace de 3 mm. Insérez la vis dans le logement puis vissez l’écrou papillon.

 

Vue de gauche du porte crayon	Vue de droite du porte crayon

Breadboard et Arduino

Fixez la breadboard sur les 2 montants à l’aide en collant les 4 équerres. L’Arduino prend place sous la breadboard à l’arrière du traceur.

Etape 8 : Test des axes X / Y et valeurs de calibration

Le câblage et l’assemblage réalisé, nous allons maintenant pouvoir tester le bon fonctionnement de mouvements des axes X et Y et calculer les valeurs de calibration.

Test de l’axe X

L’axe X est relié aux Pins 8, 9, 10 et 11. Lancez ce code pour tester si l’axe X se déplace comme prévu. Par défaut il a du se déplacer de 100 pas. En divisant 100 par la distance parcourue en millimètre, vous obtenez la calibration de l’axe X nécessaire pour la configuration.

/*
  Mini Traceur Arduino (CNC Plotter)
  Test de l'axe X
  Projets DIY 02/2016
*/
#include <Stepper.h>         //Librairie pour piloter les moteurs pas à pas
 
const int pasParRotation = 20;  //Nombre de pas pour réaliser un tour
 
//Pins sur lesquels est relié le moteur de l'axe X
Stepper myStepperX(pasParRotation, 8,9,10,11); 
 
void setup() {
 myStepperX.setSpeed(100);      //Vitesse de déplacement
 //Indiquer le nombre de pas que le moteur pas à pas doit faire
 //Généralement un moteur de lecteur CD/DVD peut faire 250 pas au maxium
 //Indiquer un chiffre négatif pour inverser le sens de déplacement
 myStepperX.step(100);          
 delay(100);
}
 
void loop() {}

Test de l’axe Y

Procédez de la même manière pour tester l’axe Y et calculez la valeur de calibration.

/*
  Mini Traceur Arduino (CNC Plotter)
  Test de l'axe Y
  Projets DIY 02/2016
*/
#include <Stepper.h>         //Librairie pour piloter les moteurs pas à pas
 
const int pasParRotation = 20;  //Nombre de pas pour réaliser un tour
 
//Pins sur lesquels est relié le moteur de l'axe X
Stepper myStepperX(pasParRotation, 2,3,4,5); 
 
void setup() {
 myStepperX.setSpeed(100);      //Vitesse de déplacement
 //Indiquer le nombre de pas que le moteur pas à pas doit faire
 //Généralement un moteur de lecteur CD/DVD peut faire 250 pas au maxium
 //Indiquer un chiffre négatif pour inverser le sens de déplacement
 myStepperX.step(100);          
 delay(100);
}
 
void loop() {}

Problèmes fréquents

Voici les principaux problèmes que j’ai rencontré durant la mise au point de mon traceur.

• Le moteur ne bouge pas : commencez par vérifier le câblage du L293D. Les Pins IN et OUT sont peut être inversés.
• Le sens de déplacement est inversé. Inversez les branchements au niveau du L293D. Les deux fils du haut vont en bas et inversement et ça devrait fonctionner.
• Le moteur s’arrête, ne va pas à la fin de sa course ou “saute”. Il y a probablement un obstacle sur son chemin. Vérifiez si une vis de fixation n’est pas trop longue…

Etape 9 : Chargement du code CNC dans l’Arduino

Calibration des axes X et YNotre mini traceur est presque terminé, il ne reste plus qu’à charger le programme CNC dans l’Arduino. Avant de téléverser le programme, vous devrez ajuster les paramètres suivants en fonction de votre Mini Traceur (une section configuration se trouve au début du code) :

• Angle du servomoteur pour lever le crayon
• Angle du servomoteur pour baisser le crayon

/* 
 Mini Traceur CNC Arduino
 Traduction de la configuration du traceur en français et ajout d'une variable "vitesseDeplacement" permettant d'ajuster la vitesse de déplacement des axes X et Y
 Projets DIY - 02/2016
 
 D'après 
 Mini CNC Plotter firmware, based in TinyCNC https://github.com/MakerBlock/TinyCNC-Sketches
 Send GCODE to this Sketch using gctrl.pde https://github.com/damellis/gctrl
 Convert SVG to GCODE with MakerBot Unicorn plugin for Inkscape available here https://github.com/martymcguire/inkscape-unicorn
 
 More information about the Mini CNC Plotter here (german, sorry): http://www.makerblog.at/2015/02/projekt-mini-cnc-plotter-aus-alten-cddvd-laufwerken/
  */

#include <Servo.h>
#include <Stepper.h>

#define LINE_BUFFER_LENGTH 512

/*
   PARAMETRES DE CONFIGURATION
*/

const int penZUp = 130;                 // Angle servomoteur, crayon relevé
const int penZDown = 40;                            // Angle servomoteur, crayon baissé
const int penServoPin = 6;              // Pin sur lequel est relié le servomoteur
const int stepsPerRevolution = 20;              // Valeur par défaut
const int vitesseDeplacement = 250;             // Vitesse de déplacement des axes X et Y

Servo penServo;                     // Objet pour actionner le servomoteur

// Initialisation des moteurs pas à pas pilotés à l'aide d'un pont H L293D
Stepper myStepperY(stepsPerRevolution, 2,3,4,5);    // Axe Y         
Stepper myStepperX(stepsPerRevolution, 8,9,10,11);  // Axe X

// Calibration, nombre de pas par millimètre
float StepsPerMillimeterX = 6.0;
float StepsPerMillimeterY = 6.0;

/*
    FIN DE LA CONFIGURATION
*/

/* Structures, global variables    */
struct point { 
  float x; 
  float y; 
  float z; 
};

// Current position of plothead
struct point actuatorPos;

//  Drawing settings, should be OK
float StepInc = 1;
int StepDelay = 0;
int LineDelay = 50;
int penDelay = 50;

// Drawing robot limits, in mm
// OK to start with. Could go up to 50 mm if calibrated well. 
float Xmin = 0;
float Xmax = 40;
float Ymin = 0;
float Ymax = 40;
float Zmin = 0;
float Zmax = 1;

float Xpos = Xmin;
float Ypos = Ymin;
float Zpos = Zmax; 

// Set to true to get debug output.
boolean verbose = false;

//  Needs to interpret 
//  G1 for moving
//  G4 P300 (wait 150ms)
//  M300 S30 (pen down)
//  M300 S50 (pen up)
//  Discard anything with a (
//  Discard any other command!

/**********************
 * void setup() - Initialisations
 ***********************/
void setup() {
  //  Setup
  Serial.begin( 9600 );
  
  penServo.attach(penServoPin);
  penServo.write(penZUp);
  delay(200);

  // Decrease if necessary
  myStepperX.setSpeed(vitesseDeplacement);
  myStepperY.setSpeed(vitesseDeplacement);  

  //  Set & move to initial default position
  // TBD

  //  Notifications!!!
  Serial.println("Mini CNC Plotter alive and kicking!");
  Serial.print("X range is from "); 
  Serial.print(Xmin); 
  Serial.print(" to "); 
  Serial.print(Xmax); 
  Serial.println(" mm."); 
  Serial.print("Y range is from "); 
  Serial.print(Ymin); 
  Serial.print(" to "); 
  Serial.print(Ymax); 
  Serial.println(" mm."); 
}

/**********************
 * void loop() - Main loop
 ***********************/
void loop() 
{
  delay(200);
  char line[ LINE_BUFFER_LENGTH ];
  char c;
  int lineIndex;
  bool lineIsComment, lineSemiColon;

  lineIndex = 0;
  lineSemiColon = false;
  lineIsComment = false;

  while (1) {

    // Serial reception - Mostly from Grbl, added semicolon support
    while ( Serial.available()>0 ) {
      c = Serial.read();
      if (( c == '\n') || (c == '\r') ) {             // End of line reached
        if ( lineIndex > 0 ) {                        // Line is complete. Then execute!
          line[ lineIndex ] = '\0';                   // Terminate string
          if (verbose) { 
            Serial.print( "Received : "); 
            Serial.println( line ); 
          }
          processIncomingLine( line, lineIndex );
          lineIndex = 0;
        } 
        else { 
          // Empty or comment line. Skip block.
        }
        lineIsComment = false;
        lineSemiColon = false;
        Serial.println("ok");    
      } 
      else {
        if ( (lineIsComment) || (lineSemiColon) ) {   // Throw away all comment characters
          if ( c == ')' )  lineIsComment = false;     // End of comment. Resume line.
        } 
        else {
          if ( c <= ' ' ) {                           // Throw away whitepace and control characters
          } 
          else if ( c == '/' ) {                    // Block delete not supported. Ignore character.
          } 
          else if ( c == '(' ) {                    // Enable comments flag and ignore all characters until ')' or EOL.
            lineIsComment = true;
          } 
          else if ( c == ';' ) {
            lineSemiColon = true;
          } 
          else if ( lineIndex >= LINE_BUFFER_LENGTH-1 ) {
            Serial.println( "ERROR - lineBuffer overflow" );
            lineIsComment = false;
            lineSemiColon = false;
          } 
          else if ( c >= 'a' && c <= 'z' ) {        // Upcase lowercase
            line[ lineIndex++ ] = c-'a'+'A';
          } 
          else {
            line[ lineIndex++ ] = c;
          }
        }
      }
    }
  }
}

void processIncomingLine( char* line, int charNB ) {
  int currentIndex = 0;
  char buffer[ 64 ];                                 // Hope that 64 is enough for 1 parameter
  struct point newPos;

  newPos.x = 0.0;
  newPos.y = 0.0;

  //  Needs to interpret 
  //  G1 for moving
  //  G4 P300 (wait 150ms)
  //  G1 X60 Y30
  //  G1 X30 Y50
  //  M300 S30 (pen down)
  //  M300 S50 (pen up)
  //  Discard anything with a (
  //  Discard any other command!

  while( currentIndex < charNB ) {
    switch ( line[ currentIndex++ ] ) {              // Select command, if any
    case 'U':
      penUp(); 
      break;
    case 'D':
      penDown(); 
      break;
    case 'G':
      buffer[0] = line[ currentIndex++ ];          // /!\ Dirty - Only works with 2 digit commands
      //      buffer[1] = line[ currentIndex++ ];
      //      buffer[2] = '\0';
      buffer[1] = '\0';

      switch ( atoi( buffer ) ){                   // Select G command
      case 0:                                   // G00 & G01 - Movement or fast movement. Same here
      case 1:
        // /!\ Dirty - Suppose that X is before Y
        char* indexX = strchr( line+currentIndex, 'X' );  // Get X/Y position in the string (if any)
        char* indexY = strchr( line+currentIndex, 'Y' );
        if ( indexY <= 0 ) {
          newPos.x = atof( indexX + 1); 
          newPos.y = actuatorPos.y;
        } 
        else if ( indexX <= 0 ) {
          newPos.y = atof( indexY + 1);
          newPos.x = actuatorPos.x;
        } 
        else {
          newPos.y = atof( indexY + 1);
          indexY = '\0';
          newPos.x = atof( indexX + 1);
        }
        drawLine(newPos.x, newPos.y );
        //        Serial.println("ok");
        actuatorPos.x = newPos.x;
        actuatorPos.y = newPos.y;
        break;
      }
      break;
    case 'M':
      buffer[0] = line[ currentIndex++ ];        // /!\ Dirty - Only works with 3 digit commands
      buffer[1] = line[ currentIndex++ ];
      buffer[2] = line[ currentIndex++ ];
      buffer[3] = '\0';
      switch ( atoi( buffer ) ){
      case 300:
        {
          char* indexS = strchr( line+currentIndex, 'S' );
          float Spos = atof( indexS + 1);
          //          Serial.println("ok");
          if (Spos == 30) { 
            penDown(); 
          }
          if (Spos == 50) { 
            penUp(); 
          }
          break;
        }
      case 114:                                // M114 - Repport position
        Serial.print( "Absolute position : X = " );
        Serial.print( actuatorPos.x );
        Serial.print( "  -  Y = " );
        Serial.println( actuatorPos.y );
        break;
      default:
        Serial.print( "Command not recognized : M");
        Serial.println( buffer );
      }
    }
  }



}


/*********************************
 * Draw a line from (x0;y0) to (x1;y1). 
 * Bresenham algo from https://www.marginallyclever.com/blog/2013/08/how-to-build-an-2-axis-arduino-cnc-gcode-interpreter/
 * int (x1;y1) : Starting coordinates
 * int (x2;y2) : Ending coordinates
 **********************************/
void drawLine(float x1, float y1) {

  if (verbose)
  {
    Serial.print("fx1, fy1: ");
    Serial.print(x1);
    Serial.print(",");
    Serial.print(y1);
    Serial.println("");
  }  

  //  Bring instructions within limits
  if (x1 >= Xmax) { 
    x1 = Xmax; 
  }
  if (x1 <= Xmin) { 
    x1 = Xmin; 
  }
  if (y1 >= Ymax) { 
    y1 = Ymax; 
  }
  if (y1 <= Ymin) { 
    y1 = Ymin; 
  }

  if (verbose)
  {
    Serial.print("Xpos, Ypos: ");
    Serial.print(Xpos);
    Serial.print(",");
    Serial.print(Ypos);
    Serial.println("");
  }

  if (verbose)
  {
    Serial.print("x1, y1: ");
    Serial.print(x1);
    Serial.print(",");
    Serial.print(y1);
    Serial.println("");
  }

  //  Convert coordinates to steps
  x1 = (int)(x1*StepsPerMillimeterX);
  y1 = (int)(y1*StepsPerMillimeterY);
  float x0 = Xpos;
  float y0 = Ypos;

  //  Let's find out the change for the coordinates
  long dx = abs(x1-x0);
  long dy = abs(y1-y0);
  int sx = x0<x1 ? StepInc : -StepInc;
  int sy = y0<y1 ? StepInc : -StepInc;

  long i;
  long over = 0;

  if (dx > dy) {
    for (i=0; i<dx; ++i) {
      myStepperX.step(sx);
      over+=dy;
      if (over>=dx) {
        over-=dx;
        myStepperY.step(sy);
      }
      delay(StepDelay);
    }
  }
  else {
    for (i=0; i<dy; ++i) {
      myStepperY.step(sy);
      over+=dx;
      if (over>=dy) {
        over-=dy;
        myStepperX.step(sx);
      }
      delay(StepDelay);
    }    
  }

  if (verbose)
  {
    Serial.print("dx, dy:");
    Serial.print(dx);
    Serial.print(",");
    Serial.print(dy);
    Serial.println("");
  }

  if (verbose)
  {
    Serial.print("Going to (");
    Serial.print(x0);
    Serial.print(",");
    Serial.print(y0);
    Serial.println(")");
  }

  //  Delay before any next lines are submitted
  delay(LineDelay);
  //  Update the positions
  Xpos = x1;
  Ypos = y1;
}

//  Raises pen
void penUp() { 
  penServo.write(penZUp); 
  delay(LineDelay); 
  Zpos=Zmax; 
  if (verbose) { 
    Serial.println("Pen up!"); 
  } 
}
//  Lowers pen
void penDown() { 
  penServo.write(penZDown); 
  delay(LineDelay); 
  Zpos=Zmin; 
  if (verbose) { 
    Serial.println("Pen down."); 
  } 
}

Etape 10 : Préparez votre ordinateur à envoyer des fichiers gcode avec Processing

C’est presque prêt ! Tous les axes fonctionnent, la calibration est faite, le programme CNC est téléversé dans l’Arduino. Il ne reste plus qu’à préparer votre ordinateur pour envoyer les fichier gcode à votre Mini Traceur.

Pour les utilisateurs de Windows, téléchargez gctrl.exe ici et lancez le.

Pour les utilisateur Mac OS et Linux, installez tout d’abord Processing en le récupérant ici puis ouvrez gctrl.pde que vous pouvez récupérer ici.

Etape 11 : Tracer votre premier dessin avec gctrl

Avant de faire votre premier tracer

• Assurez vous que les chariots sont à l’origine.
• Vérifiez que rien n’entrave les mouvements des axes
• Placez une feuille sur la zone de dessin

gctrl est un programme efficace mais basique dans le sens ou il n’effectue aucun contrôle du fichier sélectionné, le tracé démarre dès la sélection du fichier (vous pouvez l’interrompre en appuyant sur ‘x’).

C’est parti !

• Appuyez sur ‘p’. Sélectionnez le port série sur lequel est branché votre Arduino dans la boite de dialogue qui s’affiche.
• Appuyez ensuite sur ‘g’ pour sélectionner le fichier gcode à tracer.
• C’est parti 🙂

Les autres commandes utiles de gctrl :

1. ‘x’ : arrêter le tracé en cours. Attention, le crayon reste dans sa position actuelle
2. ‘h’ : renvoie les axes aux origines

Etape 11 : Comment préparer vos propres fichiers gcode

Il est très facile de préparer ses propres fichiers gcode grâce à l’extension MakerBot Unicorn pour Inkscape. Pour ceux qui ne connaissent pas, Inkscape est un logiciel de dessin vectoriel open source (et gratuit).

En fonction de votre ordinateur, téléchargez et installez Inkscape version 0.48.5 à cette adresse. Ensuite, récupérez l’extension MakerBot Unicorn sur github. Pour l’installer, il suffit de copier le contenu de répertoire src dans le répertoire des extensions d’Inkscape. En fonction de votre environnement, voici le chemin d’installation de l’extension.

• OS X – /Applications/Inkscape.app/Contents/Resources/extensions
• Linux – /usr/share/inkscape/extensions
• Windows – C:\Program Files\Inkscape\share\extensions

L’extension installée, vous pouvez ouvrir Inkscape.

Vous devez tout d’abord commencer par configurer les propriétés du document (fichier -> propriétés du document). Choisissez l’unité par défaut en cm avec une dimension de page de 8 cm x 8 cm.

Vous disposez d’une zone de 4cm x 4 cm. Votre dessin doit rester dans le quart supérieur droit.

Votre dessin terminé, sélectionné tous les éléments puis allez dans Chemin -> Objet en chemin. Cette transformation est nécessaire avant de générer le fichier gcode. Par contre vous allez perdre certaines propriétés des objets (par exemple le texte ne sera plus éditable). Si vous voulez faire des modifications ultérieures, sauvegardez votre travail au format svg avant de faire la conversion.

La conversion faite, nous pouvons générer le fichier gcode. Il suffit de faire fichier -> enregistrer sous puis de sélectionner Makerbot Unicorn (c’est l’extension que nous avons installé précédemment). Si l’option n’est pas disponible c’est que l’extension n’est pas correctement installée.

Validez sans rien changez dans la boîte de dialogue qui apparait ensuite.

Et voilà, vous êtes prêt à tracer votre oeuvre !

J’espère que vous trouverez tout ce dont vous avez besoin pour fabriquer votre Mini Traceur. J’espère ne rien avoir oublié. N’hésitez pas à partager votre expérience ou ajouter vos astuces. Les commentaires sont là pour ça.

Pour vous aider, voici une petite vidéo qui résume l’assemblage du Mini Traceur CNC avec l’impression du Minion ci-dessus.

Licence sur les éléments de structure proposés dans ce projet

Mini Traceur Arduino est mis à disposition selon les termes de la licence Creative Commons Attribution – Pas d’Utilisation Commerciale – Partage dans les Mêmes Conditions 4.0 International.

• Débuter avec le BH1750 (GY-302), mesurer la qualité de l’éclairage de votre habitation (Arduino/ESP8266/ESP32)
• Routeur MQTT Node-RED vers cloudMQTT, accéder à vos modules Sonoff Tasmota
• Test de cloudMQTT, broker MQTT en ligne gratuit. Piloter Domoticz avec l’API JSON
• Inclure les accessoires domotiques Xiaomi Aqara ou Mijia à Jeedom avec les plugins Virtuel et MQTT
• Comparaison HC-SR04 (ultrasons), Sharp GP2Y0A02YK0F (IR), VL53L0X (Laser), quelle solution choisir pour la mesure de distance avec Arduino ou Raspberry Pi
• Test et étalonnage du capteur de proximité A02YK0, clone asiatique du Sharp GP2Y0A02YK0F