Accueil | Arduino | Recycler 2 lecteurs DVD en Mini Traceur (CNC Plotter) avec un Arduino Uno et 2x L293D

Recycler 2 lecteurs DVD en Mini Traceur (CNC Plotter) avec un Arduino Uno et 2x L293D

26 février 2016 Arduino, Avancé, Ludique, Niveau de difficulté, Projets, Tutoriels Arduino 18 Commentaires 24,902 Vues

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.

Sommaire

1 Etape 1 : matériel nécessaire pour réaliser le Mini Plotter CNC
2 Etape 2 : Démonter les lecteurs de DVD pour récupérer les système de translation
- 2.1 Quelques astuces
3 Etape 3 : Préparer les moteurs pas à pas (stepper motors) des axes X et Y
4 Etape 4 : Impression des éléments de structure
5 Etape 5 : Fabrication de la structure en contreplaqué
6 Etape 6 : Branchement du circuit
7 Etape 7 : Assemblage du Mini Traceur
8 Etape 8 : Test des axes X / Y et valeurs de calibration
9 Etape 9 : Chargement du code CNC dans l’Arduino
10 Etape 10 : Préparez votre ordinateur à envoyer des fichiers gcode avec Processing
11 Etape 11 : Tracer votre premier dessin avec gctrl
- 11.1 C’est parti !
- 11.2 Les autres commandes utiles de gctrl :
12 Etape 11 : Comment préparer vos propres fichiers gcode

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 micro-contrôleurs 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ème 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).

mini traceur cnc plotter projets diy lecteur dvd — Système de déplacement linéaire récupéré sur un lecteur de DVD

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.

mini traceur cnc plotter soudure stepper motor projetdisy

mini traceur cnc plotter soudure stepper motor gaine thermo projetdisy

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 :

Elément	3D	Quantité
Equerres de fixation des montants de l’axe X		4x
Entretoises		4x 4x
Equerres de fixation pour la breadboard		4x
Plateau support axe Z		1x
Porte crayon pour crayon de diamètre 8mm (par exemple pour Stabilo Point 88)		1x
Bague anti-basculement diamètre 8mm		1x

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.

elements de structure impression3d mini traceur cnc plotter arduino — Eléments de structure à imprimer en 3D.

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.

mini traceur cnc plotter arduino projet diy cablage l293d breadboard — Câblage des deux ponts en H L293D

mini traceur cnc plotter arduino projet diy zoom cablage arduino — Câblage de l’Arduino Uno

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.

mini traceur cnc plotter arduino projet diy zoom plateau dessin — Plateau de dessin correctement réglé et fixé (vue de face)

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.

mini traceur cnc plotter arduino vue ensemble porte crayon — Modèle 3D du porte crayon sur son support

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.

mini traceur cnc plotter arduino projet diy arriere breadboard — Vue arrière : breadboard accueillant les deux L293D et l’arduino

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() {}

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() {}

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

Notre 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) :

Calibration des axes X et Y
Angle du servomoteur pour lever le crayon
Angle du servomoteur pour baisser le crayon

Attention : il ne faut pas utiliser le servomoteur pour appuyer le crayon sur la feuille. La force exercée par le servomoteur risque d’être trop forte et empêcher le déplacement de l’axe X. Le crayon est appuyé sur la feuille grâce au ressort.

/* 
 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."); 
  } 
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

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 :

‘x’ : arrêter le tracé en cours. Attention, le crayon reste dans sa position actuelle
‘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).

Attention, l’extension MaketBot Unicorn ne fonctionne pas au delà de la version 0.48.5 d’Inkscape.

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.