Embedded Files
18 de diciembre de 2016
En el siguiente tutorial veremos como hacer un plotter con dos motores paso a paso, el shield para motores de Adafruit y un Arduino UNO R3.
El funcionamiento del CNC es muy similar al que podéis ver en este vídeo -de hecho está basado en él- con la única diferencia de que en el plotter del vídeo el soporte del papel se mueve en el eje Y, y el cabezal se mueve en el eje X, y aquí el cabezal del plotter se mueve en ambos ejes y el soporte para el papel es fijo. A pesar de esta diferencia el software de control es el mismo para ambas máquinas.
Para materializar este proyecto he partido de un viejo escáner de radiografías al que he sustituido la cámara CCD por un rotulador. Toda la electrónica ha sido retirada, dejando únicamente la estructura de las guías y los dos motores paso a paso, encargados de mover el cabezal en los ejes X e Y.
Si alguno quiere hacer una estructura de unas dimensiones concretas, o aprovechar una vieja máquina para hacer su propio CNC, puede utilizar el software aquí descrito, ya que para adaptar el área de dibujo a nuestro plotter, solo hay que modificar dos parámetros en el sketch.
En el siguiente vídeo podéis ver algunos detalles de montaje y un ejemplo de funcionamiento.
Esquema
Esquema
El esquema de conexión es muy sencillo. El motor del eje X se conecta en los terminales marcados como M1 y M2. El motor del eje Y se conecta en los terminales M3 y M4. El servo para el rotulador se conecta en los pines marcados con Servo 1.
Alimentar el circuito a 12V -o lo que corresponda según los motores que se vayan a utilizar- y quitar el jumper.
Sketch
Sketch
Como decía más arriba, para adaptar este sketch a cualquier CNC, sólo hay que modificar una serie de parámetros; el área de dibujo y los pasos/mm del motor empleado.
Para modificar el área de impresión poner en float Xmax y float Ymax lo que corresponda. El plotter funciona mejor si las dimensiones X e Y son iguales.
Otros parámetros importantes son: const int stepsPerRevolution = 200; en este caso los motores empleados tienen una resolución de 1,8º por paso, luego 200 pasos por vuelta. Y float StepsPerMillimeterX = 70.0;float StepsPerMillimeterY = 70.0;
Para calcular este valor se hace una prueba haciendo que los motores se muevan 100 pasos en línea recta, se mide la longitud del segmento dibujado y se calculan los pasos/mm.
Si el resultado no es satisfactorio, se puede dibujar con el plotter un segmento de longitud conocida e ir poniendo valores hasta que la longitud medida sobre el papel sea la correcta.
En mi caso tuve que calcular parámetro de este último modo, ya que con el valor obtenido de manera experimental, la CNC tenía un comportamiento defectuoso.
A continuación el código para el Arduino.
/*
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 <AFMotor.h>
#define LINE_BUFFER_LENGTH 512
char STEP = MICROSTEP ;
// Servo position for Up and Down
const int penZUp = 120; //115
const int penZDown = 90; //83
// Servo on PWM pin 10
const int penServoPin =10 ;
// Should be right for DVD steppers, but is not too important here
const int stepsPerRevolution = 200;
// create servo object to control a servo
Servo penServo;
// Initialize steppers for X- and Y-axis using this Arduino pins for the L293D H-bridge
AF_Stepper myStepperY(stepsPerRevolution,1);
AF_Stepper myStepperX(stepsPerRevolution,2);
/* 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 = 1;
int LineDelay = 1;
int penDelay = 50;
// Motor steps to go 1 millimeter.
// Use test sketch to go 100 steps. Measure the length of line.
// Calculate steps per mm. Enter here.
float StepsPerMillimeterX = 70.0;
float StepsPerMillimeterY = 70.0;
// Drawing robot limits, in mm
// OK to start with.
float Xmin = 0;
float Xmax = 150;
float Ymin = 0;
float Ymax = 150;
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(100);
// Decrease if necessary
myStepperX.setSpeed(100);
myStepperY.setSpeed(100);
myStepperX.release();
myStepperY.release();
// 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(100);
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).
* 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.onestep(sx,STEP);
over+=dy;
if (over>=dx) {
over-=dx;
myStepperY.onestep(sy,STEP);
}
delay(StepDelay);
}
}
else {
for (i=0; i<dy; ++i) {
myStepperY.onestep(sy,STEP);
over+=dx;
if (over>=dy) {
over-=dy;
myStepperX.onestep(sx,STEP);
}
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(penDelay);
Zpos=Zmax;
digitalWrite(15, LOW);
digitalWrite(16, HIGH);
if (verbose) {
Serial.println("Pen up!");
}
}
// Lowers pen
void penDown() {
penServo.write(penZDown);
delay(penDelay);
Zpos=Zmin;
digitalWrite(15, HIGH);
digitalWrite(16, LOW);
if (verbose) {
Serial.println("Pen down.");
}
}
Bien, ya tenemos programado el Arduino, pero a diferencia de otros proyectos, aquí hacen falta dos pasos más para que el plotter funcione correctamente. Por un lado necesitamos el archivo que contiene el dibujo que debe trazar el plotter y además un software que envíe los datos del archivo al Arduino, a través del puerto COM.
Los archivos con el dibujo a trazar son archivos con extensión gcode. Estos archivos se generan partiendo de la imagen que queremos dibujar en formato JPG, BMP, PNG, etc… y con el programa InkScape la convertimos a gcode, mediante un proceso llamado vectorización.
El siguiente vídeo explica cómo convertir una imagen en un archivo gcode. La versión de Inkscape debe ser la 0.48.5. La puedes descargar aquí, para Windows XP.
A la hora de escribir estas líneas, para W10 la versión actual de Inkscape es la v0.91. La puedes descargar aquí.
Esta versión de Inkscape de un error a la hora de salvar el archivo en formato gcode. Para solucionarlo hay que seleccionar “px” en unidades en lugar de “mm” en las propiedades del documento.
Una vez tenemos el archivo gcode creado, podemos simular su funcionamiento con el software CAMotics. Viene explicado en el vídeo anterior. Para que el plotter trace el dibujo correctamente, la simulación debe quedar como en la imagen siguiente, es decir, el cursor en la esquina inferior izquierda y el offset negativo y entre -3 ó -5 mm.
En el caso de que la simulación quede un offset elevado y el cursor en el centro, lo más seguro es que el dibujo quede recortado en el plotter. Mira el ejemplo siguiente.
Para solucionar este problema, probad a desplazar la imagen hacia una esquina en el InkScape, no pasa nada si queda fuera del documento. Guardar el archivo y abrirlo con el CAMotics, haced pruebas hasta que salga bien.
Una vez tenemos el archivo gcode correctamente vectorizado, lo siguiente es enviarlo al Arduino mediante una herramienta llamada Processing, se puede descargar aquí.
Instalar Processing y abrirlo. Para enviar el archivo gcode, necesitamos una interfaz gráfica de usuario llamada Gctrl.pde disponible para descargar aquí. Ir a Archivo→Abrir→Gcontrol→source→gctrl.pde
Se abrirá una ventana como la siguiente:
Hacer clic en el icono Play, aparece el siguiente menú:
Pulsar p (en minúsculas) para seleccionar el puerto COM del Arduino. Si no responde, click en Stop y de nuevo en Play.
Pulsar g para seleccionar el archivo gcode con el dibujo. Tan pronto como pulsemos Enter, el plotter comenzará a trazar el dibujo.
Links
Links
Canal YouTube de Mr. Innovative, How to make Mini CNC plotter machine
Instructables, How to Make Arduino Based Mini CNC Plotter
Mini CNC Plotter firmware, based in TinyCNC
Send GCODE to this Sketch using gctrl.pde
Convert SVG to GCODE with Maker Bot Unicorn plugin for Inkscape
Más información sobre Mini Plotter CNC aquí (en alemán)
A continuación puedes descargar el sketch para el Arduino.
Google Sites
Report abuse