¡Es hora de dar vida a un proyecto creativo y educativo! 🎉 Vamos a construir un CNC casero para escribir o dibujar utilizando un Arduino, motores de un lector de DVD reciclado y un simple bolígrafo. Es una excelente forma de aprender sobre mecánica, electrónica y programación. 🧑💻
¿Qué necesitas para crear tu CNC con lectores de DVD?
Lista de piezas:
- Grabadora de DVD (2x)
- Arduino Nano o equivalente.
- Controlador de motor L293D (2x)
- Base de cicuito integrado(2x)
- Micromotor servo.
- Placa PCB Pines de cabecera macho y hembra.
- Zócalo cilíndrico.
- Lámina de acrílico de 3 mm
Lista de herramientas:
- Soldador.
- Super Glue.
- Sierra de mano.
- Papel de lija.
- Regla.
- Rotulador.
Paso 1: Fabricación del marco para el plotter CNC
Para comenzar nuestro proyecto, utilizaremos una lámina de acrílico para construir el marco del CNC. El acrílico es una opción excelente para proyectos de bricolaje, ya que es fácil de trabajar, duradero y económico. Además, se puede cortar, doblar y lijar sin complicaciones. Aquí te explico cómo preparar las piezas para el marco:
1️⃣ Mide y marca:
- Toma las medidas necesarias para las piezas del marco, ajustándolas a las dimensiones de tu diseño.
- Usa un marcador para señalar los cortes sobre la lámina de acrílico.
2️⃣ Corta las piezas:
- Con una sierra de mano o una herramienta de corte adecuada, corta la lámina siguiendo las marcas realizadas.
3️⃣ Lija los bordes:
- Usa papel de lija para alisar los bordes y eliminar imperfecciones. Esto no solo mejora la apariencia, sino que también asegura un buen ajuste al ensamblar el marco.
⚠️ Consejo: Si es necesario, calienta ligeramente el acrílico para doblarlo y adaptarlo a las formas que necesites.
¡El marco ya está listo para el siguiente paso! 👌 😊 Descarga la plantilla con las medidas.
Paso 2: Fabrica la base para el Plotter CNC
En este paso, crearemos la base del plotter CNC. Es un proceso sencillo pero crucial para garantizar la estabilidad de la estructura. Sigue estos pasos cuidadosamente:
1️⃣ Prepara las piezas:
- Asegúrate de tener las piezas de acrílico cortadas previamente para la base y el soporte.
2️⃣ Aplica el pegamento:
- Usa super glue y aplica una capa uniforme en una de las piezas principales.
- Une esta pieza con otras dos, asegurándote de que queden perfectamente alineadas.
3️⃣ Fija el marco del eje X:
- Coloca el marco del eje X sobre la base y fíjalo usando super glue para garantizar que quede bien sujeto.
4️⃣ Añade soporte adicional:
- Para mayor estabilidad, une dos piezas de acrílico adicionales en los lados. Esto fortalecerá la base y evitará movimientos no deseados.
⚠️ Consejo: Asegúrate de que todo esté seco y firme antes de continuar con el siguiente paso. ¡Una base sólida es clave para el éxito del proyecto! 💪
¡El siguiente paso es ensamblar los demás componentes! 😊
Paso 3: Extracción de los motores
En este paso, recuperaremos los motores paso a paso y rieles necesarios para el CNC a partir de viejos reproductores de DVD. Es una forma económica y sostenible de reciclar componentes electrónicos. Esto es lo que debes hacer:
1️⃣ Consigue los reproductores de DVD:
- Busca en tiendas de hardware local o entre equipos electrónicos antiguos. Normalmente, los reproductores dañados se consiguen a precios muy bajos o incluso gratis.
- En este caso, uno lo obtuve gratis y otro lo tenía guardado.
2️⃣ Desmonta los reproductores de DVD:
- Usa un destornillador para abrir la carcasa de los reproductores.
- Localiza los motores paso a paso y los rieles en el interior.
3️⃣ Retira los motores y rieles:
- Con cuidado, extrae los motores y rieles del marco. Guárdalos con sus tornillos, ya que serán esenciales para ensamblar el CNC.
⚠️ Nota: Asegúrate de no dañar los motores o los rieles al desmontarlos, ya que son partes clave del sistema.
¡Listo! Ahora tienes los componentes principales para el sistema de movimiento del CNC. 🚀
Paso 4: Modificación de los deslizadores para los ejes X e Y
Ahora personalizaremos los deslizadores recuperados para que funcionen como soporte de los ejes X e Y en el CNC. Este paso requiere precisión para garantizar un movimiento suave y eficiente.
1️⃣ Retira los deslizadores:
- Desmonta los dos deslizadores de sus respectivos rieles.
2️⃣ Corta las piezas:
- Usa una sierra de mano para cortar las dos pequeñas secciones del deslizador según lo necesites. Trabaja con cuidado para evitar dañar el material.
3️⃣ Une las piezas:
- Aplica super glue en las secciones cortadas y fíjalas juntas. Asegúrate de que estén perfectamente alineadas para garantizar estabilidad y precisión en los movimientos.
⚠️ Consejo: Antes de pegar, verifica que las piezas cortadas encajen correctamente en tu diseño para evitar errores.
¡Ahora tienes los deslizadores listos para montar los ejes del CNC! 🚀
Paso 5: Colocación de las varillas deslizantes
Ahora aseguraremos las varillas deslizantes en el marco del CNC. Estas guiarán los movimientos de los ejes X e Y, así que la instalación debe ser precisa.
1️⃣ Inserta las varillas en los deslizadores:
- Toma una varilla deslizante e insértala en el deslizador correspondiente, asegurándote de que encaje correctamente.
2️⃣ Fija las varillas al marco:
- Aplica super glue en las áreas de contacto de la varilla con el marco.
- Coloca la varilla en su posición en el marco y mantenla fija durante unos minutos para que el pegamento se adhiera bien.
3️⃣ Repite el proceso:
- Usa el mismo método para fijar la segunda varilla deslizante al marco.
- A continuación, aplica este procedimiento para las varillas del marco del eje X.
⚠️ Consejo: Verifica que las varillas queden completamente alineadas y paralelas para asegurar un movimiento suave y sin atascos.
Con esto, el sistema de guiado del CNC está listo. ¡Avancemos al siguiente paso! 🚀
Paso 6: Montaje de los motores paso a paso
En este paso, montaremos los motores paso a paso en los ejes X e Y.
1️⃣ Fija los motores a los ejes:
- Usa un destornillador para fijar cada motor paso a paso en su lugar en los ejes X e Y.
- Asegúrate de que estén bien ajustados y alineados con las varillas deslizantes.
Paso 7: Conexión de los ejes X e Y 🛠️
Ahora uniremos el eje Y encima del eje X para completar la estructura.
1️⃣ Alinea los ejes:
- Coloca el marco del eje Y sobre el eje X.
- Asegúrate de que los deslizadores y las varillas queden perfectamente alineados.
2️⃣ Fija los ejes:
- Usa pegamento o tornillos (según tu diseño) para asegurar ambos ejes.
⚠️ Nota: Verifica que ambos ejes puedan moverse suavemente antes de continuar.
Paso 8: Construcción del eje Z ✍️
El eje Z permite el movimiento vertical del bolígrafo. Aquí está el proceso detallado:
1️⃣ Reúne los materiales:
- Necesitarás: una varilla deslizante, un resorte (como los de bolígrafo), un soporte de compás para lápices, piezas de acrílico y un servo motor.
2️⃣ Prepara la varilla deslizante:
- Inserta la varilla deslizante en su soporte.
- Coloca el resorte en la varilla y usa un pequeño soporte de plástico para mantener el resorte en su lugar.
3️⃣ Fija la varilla al marco:
- Aplica super glue en el soporte de la varilla y pégalo a la estructura de acrílico.
4️⃣ Añade el soporte superior:
- Coloca una pieza pequeña de acrílico en la parte superior de la varilla deslizante para facilitar el movimiento vertical.
5️⃣ Coloca el portabolígrafos:
- Fija el soporte del lápiz (o bolígrafo) al extremo de la varilla deslizante.
6️⃣ Instala el servo motor:
- Usa super glue para montar el servo motor en la estructura. Este controlará el movimiento del lápiz hacia arriba y hacia abajo.
Paso 9: Conexión del eje Z al eje Y ⚙️
Ahora uniremos el eje Z al eje Y para completar el sistema de movimiento del CNC. Sigue estos pasos:
1️⃣ Alinea el eje Z con el eje Y:
- Coloca el marco del eje Z sobre el eje Y asegurándote de que las piezas estén perfectamente alineadas para evitar movimientos torpes.
2️⃣ Fija el eje Z:
- Aplica super glue en los puntos de contacto del marco del eje Z y pégalo al marco del eje Y.
- Mantén presionadas las piezas durante unos minutos para que el pegamento se adhiera correctamente.
⚠️ Consejo: Asegúrate de que el eje Z pueda moverse suavemente hacia arriba y hacia abajo antes de dejar que el pegamento se seque por completo.
Con esto, la estructura de tu CNC plotter está lista. 🚀 Ahora es momento de trabajar en la electrónica y programación. 😊
Paso 10: soldar cables a los motores 🔧
En este paso, prepararemos los motores para conectarlos al circuito:
1️⃣ Corta la PCB flexible de los motores:
- Usa unas tijeras o un cortador pequeño para retirar la placa flexible de los motores paso a paso.
2️⃣ Suelda los cables:
- Suelda cables a los terminales de los motores con cuidado de no dañar las conexiones.
- Usa pequeñas piezas de un rotulador como soporte para elevar ligeramente la placa del circuito.
Paso 11: diagrama del circuito 🛠️
Aquí conectaremos todos los componentes según el esquema del circuito:
1️⃣ Sigue el diagrama completo:
- Conecta los motores paso a paso, el Arduino Nano y el controlador L293D.
- Si los motores no funcionan correctamente, ajusta las combinaciones de pines del L293D según sea necesario.
Paso 12: crea la placa de circuito 🖇️
1️⃣ Montaje inicial:
- Inserta las bases de los IC y los pines de cabecera en la placa.
2️⃣ Soldadura:
- Suelda los pines y realiza todas las conexiones siguiendo el diagrama. Trabaja con precisión para evitar errores.
Paso 13: Ensamblando la placa de circuito 🛠️
1️⃣ Monta los componentes:
- Inserta los IC en sus bases, el Arduino Nano y, finalmente, conecta todos los cables al circuito.
Paso 14: sube el código CNC a Arduino 📥
1️⃣ Conecta la placa Arduino al PC:
- Usa un cable USB para conectar el Arduino Nano al ordenador.
2️⃣ Carga el código:
- Selecciona el puerto y la placa correcta en el IDE de Arduino.
- Sube el código CNC.
/*
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
// Servo position for Up and Down
const int penZUp = 40;
const int penZDown = 85;
// Servo on PWM pin 6
const int penServoPin = 6;
// Should be right for DVD steppers, but is not too important here
const int stepsPerRevolution = 20;
// 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
Stepper myStepperY(stepsPerRevolution, 2,3,4,5);
Stepper myStepperX(stepsPerRevolution, 8,9,10,11);
/* 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;
// 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 = 6.0;
float StepsPerMillimeterY = 6.0;
// 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(250);
myStepperY.setSpeed(250);
// 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.");
}
}
Paso 15: configuración el programa GCTRL 🖥️
1️⃣ Abre el software Processing:
- Ejecuta el archivo
gctrl.pdepara el CNC.
2️⃣ Selecciona puerto y gcode:
- Presiona la tecla p para seleccionar el puerto correcto.
- Presiona g para cargar el archivo de gcode.
import java.awt.event.KeyEvent;
import javax.swing.JOptionPane;
import processing.serial.*;
Serial port = null;
// select and modify the appropriate line for your operating system
// leave as null to use interactive port (press 'p' in the program)
String portname = null;
//String portname = Serial.list()[0]; // Mac OS X
//String portname = "/dev/ttyUSB0"; // Linux
//String portname = "COM6"; // Windows
boolean streaming = false;
float speed = 0.001;
String[] gcode;
int i = 0;
void openSerialPort()
{
if (portname == null) return;
if (port != null) port.stop();
port = new Serial(this, portname, 9600);
port.bufferUntil('\n');
}
void selectSerialPort()
{
String result = (String) JOptionPane.showInputDialog(frame,
"Select the serial port that corresponds to your Arduino board.",
"Select serial port",
JOptionPane.QUESTION_MESSAGE,
null,
Serial.list(),
0);
if (result != null) {
portname = result;
openSerialPort();
}
}
void setup()
{
size(600, 400);
openSerialPort();
}
void draw()
{
background(155);
fill(0);
int y = 24, dy = 12;
text("INSTRUCTIONS", 12, y); y += dy;
text("p: select serial port", 12, y); y += dy;
text("1: set speed to 0.001 inches (1 mil) per jog", 12, y); y += dy;
text("2: set speed to 0.010 inches (10 mil) per jog", 12, y); y += dy;
text("3: set speed to 0.100 inches (100 mil) per jog", 12, y); y += dy;
text("arrow keys: jog in x-y plane", 12, y); y += dy;
text("page up & page down: jog in z axis", 12, y); y += dy;
text("$: display grbl settings", 12, y); y+= dy;
text("h: go home", 12, y); y += dy;
text("0: zero machine (set home to the current location)", 12, y); y += dy;
text("g: stream a g-code file", 12, y); y += dy;
text("x: stop streaming g-code (this is NOT immediate)", 12, y); y += dy;
y = height - dy;
text("current jog speed: " + speed + " inches per step", 12, y); y -= dy;
text("current serial port: " + portname, 12, y); y -= dy;
}
void keyPressed()
{
if (key == '1') speed = 0.001;
if (key == '2') speed = 0.01;
if (key == '3') speed = 0.1;
if (!streaming) {
if (keyCode == LEFT) port.write("G91\nG20\nG00 X-" + speed + " Y0.000 Z0.000\n");
if (keyCode == RIGHT) port.write("G91\nG20\nG00 X" + speed + " Y0.000 Z0.000\n");
if (keyCode == UP) port.write("G91\nG20\nG00 X0.000 Y" + speed + " Z0.000\n");
if (keyCode == DOWN) port.write("G91\nG20\nG00 X0.000 Y-" + speed + " Z0.000\n");
if (keyCode == KeyEvent.VK_PAGE_UP) port.write("G91\nG20\nG00 X0.000 Y0.000 Z" + speed + "\n");
if (keyCode == KeyEvent.VK_PAGE_DOWN) port.write("G91\nG20\nG00 X0.000 Y0.000 Z-" + speed + "\n");
if (key == 'h') port.write("G90\nG20\nG00 X0.000 Y0.000 Z0.000\n");
if (key == 'v') port.write("$0=75\n$1=74\n$2=75\n");
//if (key == 'v') port.write("$0=100\n$1=74\n$2=75\n");
if (key == 's') port.write("$3=10\n");
if (key == 'e') port.write("$16=1\n");
if (key == 'd') port.write("$16=0\n");
if (key == '0') openSerialPort();
if (key == 'p') selectSerialPort();
if (key == '$') port.write("$$\n");
}
if (!streaming && key == 'g') {
gcode = null; i = 0;
File file = null;
println("Loading file...");
selectInput("Select a file to process:", "fileSelected", file);
}
if (key == 'x') streaming = false;
}
void fileSelected(File selection) {
if (selection == null) {
println("Window was closed or the user hit cancel.");
} else {
println("User selected " + selection.getAbsolutePath());
gcode = loadStrings(selection.getAbsolutePath());
if (gcode == null) return;
streaming = true;
stream();
}
}
void stream()
{
if (!streaming) return;
while (true) {
if (i == gcode.length) {
streaming = false;
return;
}
if (gcode[i].trim().length() == 0) i++;
else break;
}
println(gcode[i]);
port.write(gcode[i] + '\n');
i++;
}
void serialEvent(Serial p)
{
String s = p.readStringUntil('\n');
println(s.trim());
if (s.trim().startsWith("ok")) stream();
if (s.trim().startsWith("error")) stream(); // XXX: really?
}Paso 16: ¡Hemos terminado! 🎉
Tu máquina CNC para dibujar está lista para imprimir tu primera imagen. Si haces este proyecto, comparte tus fotos y resultados. ¡Estoy emocionado de ver tus creaciones! 😊
Deja una respuesta