Dobladora de alambre 3D Arduino
En este tutorial, le mostraré cómo construí una máquina dobladora de alambre 3D basada en Arduino. Este es en realidad un sistema mecatrónico típico porque involucra ingeniería mecánica, eléctrica e informática. Por lo tanto, creo que muchos estudiantes de ingeniería o cualquiera que sea nuevo en mecatrónica encontró este proyecto interesante.
Puede ver el siguiente video o leer el tutorial escrito a continuación.
Este es el principio de funcionamiento de esta máquina dobladora de alambre 3D. Entonces, primero, el alambre pasa por una serie de rodillos o enderezadores. Con un motor paso a paso, el alambre se alimenta con precisión al mecanismo de doblado de alambre, que también usa un motor paso a paso y un pequeño servo para el proceso de doblado.
También hay otro motor paso a paso, llamado eje Z, que en realidad permite que la máquina cree formas tridimensionales. Por supuesto, el cerebro de la máquina es una placa Arduino que, junto con los demás componentes electrónicos, se conecta a una PCB diseñada a medida.
En cuanto al programa, hice algunas funciones personalizadas para hacer varias formas, como una estrella, un cubo y un soporte simple, así como un modo manual donde podemos hacer formas de alambre ingresando comandos a través del monitor serial.
Como de costumbre, comencé haciendo el proyecto utilizando un software de modelado 3D. Puede descargar el modelo 3D a continuación.
Inspiración de diseño:vídeo de YouTube
Puede buscar y descargar este modelo 3D, así como explorarlo en su navegador en Thangs.
Puede descargar el modelo 3D del ensamblaje en Thangs.
Archivos STL para impresión 3D:
Para algunas de las piezas, como los engranajes, las chumaceras de los cojinetes y algunos acopladores de eje, utilicé una impresora 3D para fabricarlas. Los archivos STL de estas piezas, que se utilizan para la impresión 3D, se pueden descargar desde los archivos anteriores.
Mi nueva impresora 3D, Creality CR-10, hizo un gran trabajo e imprimió las piezas con gran calidad. Aquí hay un enlace a esta impresora 3D en caso de que quiera verla.
Continué con la preparación de las otras partes, para lo cual usé MDF y madera contrachapada. Entonces, una vez que tomé todas las dimensiones del modelo 3D, usando una sierra circular, corté las piezas a la medida. Usé MDF de 8 mm y madera contrachapada de 18 mm. Una vez que los tuve listos comencé con el montaje. Primero hice la base con dos placas de MDF y 4 columnas de madera contrachapada. Para asegurarlos usé cola para madera y algunos tornillos.
A continuación, en el panel superior, fijé los soportes de rodamientos impresos en 3D con pernos y tuercas de 8 mm. Podemos notar aquí que agregué placas de MDF de 3 mm entre la parte superior y los bloques de almohada para obtener la altura adecuada. Ahora en estos bloques podemos encajar los rodamientos 6202.
Su diámetro exterior es de 35 mm y el diámetro interior es de 15 mm. Entonces ahora, a través de estos rodamientos, necesitamos insertar un eje hueco de 15 mm para que el cable pueda pasar a través de él. Este eje es en realidad el eje Z, que permite que el mecanismo de flexión gire alrededor del alambre y de esa manera haga formas tridimensionales. Usé un tubo de cobre para ese propósito y su longitud debe ser de unos 30 cm.
Entre los dos rodamientos también inserté un engranaje impreso en 3D con un módulo de 1,5 y 30 dientes. El engranaje tiene ranuras de diseño personalizado en las que podemos insertar tuercas M3 y luego, usando pernos M3, podemos apretar el engranaje al eje.
A continuación, necesitamos instalar el motor paso a paso del eje Z. Para ese propósito, imprimí en 3D un soporte de montaje personalizado. Así que aseguré el paso a paso al soporte con pernos M3 y luego inserté el engranaje de 18 dientes en el eje del motor. Usé el mismo método para asegurar el engranaje al eje como se muestra anteriormente.
Luego, con un taladro de 6 mm, hice dos orificios en la parte superior en los que se asegurará el soporte de montaje. Podemos notar que el soporte en lugar de agujeros, tiene ranuras que permiten emparejar correctamente los dos engranajes.
Seguí adelante con la instalación del motor paso a paso para el mecanismo del alimentador. Este motor se montará directamente en la placa superior, por lo que taladré los agujeros apropiados en él. Luego, usando cuatro pernos, aseguré el paso a paso a la placa y, en caso de que se pregunte qué hacen esas tuercas aquí, en realidad actúan como tuercas de distancia porque los pernos que tenía eran más largos y no podían encajar en las roscas de los motores.
Así que ahora en el eje de este paso a paso necesitamos insertar el alimentador. Para ello, imprimí en 3D un acoplador de eje personalizado en el que inserté un tubo de cobre que en realidad será la superficie de contacto del alimentador.
Luego, en el lado opuesto del motor, inserté una palanca, en la que adjunté un cojinete que presionará contra el alimentador. Para obtener suficiente agarre para que el alimentador pueda mover el alambre, colocaré una pieza de madera contrachapada con una tuerca en T y luego, usando un perno, podremos controlar el agarre del alimentador.
El siguiente paso es hacer el sistema de enderezamiento de alambre. Usando tres pernos M8 aseguré una pieza de madera contrachapada que perforé previamente de acuerdo con el modelo 3D. Ahora encima inserté los rodillos. Hice los rodillos con rodamientos y anillos exteriores ranurados impresos en 3D.
Tres rodillos van de este lado y dos rodillos del otro lado. Para el otro lado hice una ranura en la pieza de madera contrachapada para que los pernos quedaran al ras con la pieza. Ahora, usando solo dos pernos, podemos emparejar los dos lados, y usando las tuercas, podemos apretar los enderezadores de manera adecuada.
Una vez terminado con este paso, añadí dos piezas más de madera contrachapada al frente y después de los enderezadores que servirán como guías de alambre.
Bien, ahora podemos continuar con la fabricación del mecanismo de doblado de alambre. Primero, en una pieza de MDF, debemos colocar el motor doblador. Antes de hacer eso, la pieza de MDF que tenía necesitaba un poco de forma, así que con una sierra de mano, una sierra caladora y una escofina conseguí fácilmente la forma deseada. Luego, usando una sierra perforadora de 38 mm, hice una abertura para el motor paso a paso más grande que usaremos para doblar, un motor paso a paso NEMA 23. También taladré algunos agujeros más pequeños necesarios para unir las otras partes.
Aseguré el paso a paso NEMA 23 usando pernos y tuercas M4 y en su eje de salida coloqué un engranaje con módulo de 2.5 y 18 dientes. Este engranaje se combinará con un engranaje más grande de 30 dientes, que es un engranaje diseñado a medida con placa integrada para montar un servo MG996R. Este servo moverá un mecanismo de cremallera y piñón, que en realidad es un pasador que saldrá del engranaje y servirá para doblar el cable. Usando un epoxi de 5 minutos, aseguré un cojinete en el engranaje y también agregué un trozo de tubo de cobre en el bastidor que será la superficie de contacto al doblar el cable.
Después de que se secó el epoxi, apareé los dos engranajes asegurando el engranaje más grande en su lugar con un perno M8 y tuercas. Luego inserté el bastidor y el servo en su lugar, y lo aseguré con los tornillos provistos en el paquete de servos. Luego aseguré el piñón en la bocina redonda del servo con dos pernos y tuercas M3.
Finalmente coloqué la bocina en el servo y con esto se completó el mecanismo de doblado.
Lo que queda por hacer ahora es unir el doblador al eje Z. Lo hice usando las dos abrazaderas de eje impresas en 3D. Primero los aseguré a la placa del doblador usando pernos y tuercas M6 y luego los inserté en el eje Z. Inserté las dos tuercas en su lugar y usando los pernos apreté las abrazaderas al eje. Así que ahora todas las piezas móviles funcionan correctamente.
En realidad, hay que añadir dos pequeños detalles más. Esa es esta boquilla de 3 mm en el eje por donde sale el alambre.
Y en la parte inferior del doblador coloqué un microinterruptor de límite que se usará para establecer la posición inicial del doblador.
Y eso es todo, nuestra máquina dobladora de alambre 3D está casi terminada. Digo casi, porque ahora falta darle vida a esta máquina, o conectar los componentes electrónicos y programarla.
Aquí está el diagrama de circuito de este proyecto.
Por lo tanto, los tres motores paso a paso se controlan mediante los tres controladores paso a paso DRV8825. Para alimentar los motores paso a paso y todo el proyecto, utilizaremos una fuente de alimentación de 12 V con al menos 3 A de corriente.
Para alimentar el servo, podríamos usar los 5 V provenientes del Arduino, pero el servo MG996R puede consumir mucha energía y es posible que el regulador de voltaje de 5 V del Arduino no pueda manejarlo. Por lo tanto, decidí usar un regulador de voltaje de 5 V por separado, el LM7805, que es lo suficientemente bueno para alimentar el servo para este proyecto. También hay un interruptor de límite para el doblador que tiene una resistencia pull up y está conectado a un pin digital de la placa Arduino.
Puede obtener los componentes necesarios para este proyecto en los siguientes enlaces:
Luego, para deshacerme del desorden del cableado y mantener los componentes electrónicos organizados, diseñé una PCB personalizada utilizando el software gratuito de diseño de circuitos en línea EasyEDA. El circuito tiene muchas conexiones, así que usé las capas superior e inferior para organizarlas. También agregué pines para seleccionar la resolución de los motores paso a paso, agregué una conexión de interruptor de límite más y proporcioné pines digitales y analógicos adicionales provenientes del Arduino en caso de que los necesitemos para algo.
Aquí hay un enlace a los archivos de proyecto de este diseño de PCB. Entonces, una vez que terminé con este diseño, generé el archivo Gerber necesario para fabricar la PCB.
Archivo Gerber:
Luego ordené el PCB de JLCPCB, que en realidad es el patrocinador de este proyecto.
Aquí podemos simplemente arrastrar y soltar el archivo Gerber y una vez cargado, podemos revisar nuestro PCB en el visor de Gerber. Si todo está bien, podemos continuar, seleccionar las propiedades que queremos para nuestra PCB y luego podemos pedir nuestra PCB a un precio razonable. Tenga en cuenta que si es su primer pedido de JLCPCB, puede obtener hasta 10 PCB por solo $2.
Después de varios días han llegado los PCB. La calidad de los PCB es excelente y todo es exactamente igual que en el diseño.
Entonces ahora podemos continuar e instalar los componentes electrónicos en la PCB. Empecé soldando los cabezales de los pines a la PCB. Esto permite una conexión y desconexión más fácil de los componentes cuando sea necesario. En cuanto a los componentes más pequeños, como los condensadores, las resistencias, el regulador de voltaje y los bloques de terminales, los soldé directamente en la PCB.
Una vez terminado con este paso, ahora podemos insertar los controladores paso a paso y el Arduino en su lugar. Luego, debemos conectar el enchufe de alimentación y el interruptor de alimentación a los bloques de terminales, conectar los cables a los motores paso a paso en un lado y conectarlos a la PCB en el otro lado. El servo está conectado al pin digital número 2 y alimentado con los 5V provenientes del regulador de voltaje LM7805. Finalmente, podemos seleccionar la resolución paso a paso conectando los pines de resolución debajo de los controladores.
Decidí usar la resolución de paso 16, por lo que necesitamos conectar los pines correctos en lugar de los del medio como se ve en la foto de arriba. Entonces, los componentes electrónicos ya están listos y podemos continuar con la programación de la máquina dobladora de alambre.
Como el código es un poco más largo, para una mejor comprensión, publicaré el código fuente del programa en secciones con descripción para cada sección. Y al final de este artículo publicaré el código fuente completo.
Para controlar los motores paso a paso, usaré la biblioteca AccelStepper de Mike McCauley. Por lo tanto, debemos incluir esta biblioteca, así como la biblioteca de servo para controlar el servomotor. Luego, debemos definir los pines a los que se conectan los motores paso a paso y algunas variables necesarias para el programa a continuación.
En la sección de configuración establecemos la posición inicial del servo o el pasador de flexión, y también establecemos la posición inicial del engranaje de flexión. Esto se hace con la ayuda del interruptor de límite. El paso a paso gira hacia el interruptor y, una vez que se presiona, el motor comienza a contar los pasos desde cero y se posiciona a sí mismo en cero grados, listo para doblarse.
Ahora en la sección de bucle, esperamos los comandos provenientes del monitor en serie. Si escribimos manual, entraremos en el modo de plegado manual o si escribimos, por ejemplo, estrella, se ejecutará la función personalizada start() y la máquina automáticamente hará una forma de estrella para nosotros.
Echemos un vistazo a esta función personalizada.
Así que aquí entramos en un ciclo while que se ejecuta 5 veces, porque obviamente la estrella tiene 5 puntas. Comenzamos configurando el valor de avance, o esa es la cantidad de alambre que se alimentará en milímetros. Luego, este valor se multiplica por 48, lo que traduce el valor de avance en los pasos apropiados para que se mueva el motor paso a paso. Luego, usando la función run(), giramos el motor del alimentador con una velocidad establecida por la función setSpeed(). Nos detenemos cuando se alcanza el valor feedDistance anterior y, justo después, establecemos el valor de posición actual del paso a paso cero.
En el siguiente paso doblamos el alambre 52 grados. Esto se hace de manera similar a como se explicó anteriormente. Aquí también tenemos una constante de ángulo que se multiplica por el ángulo deseado. Una vez que el motor alcanza ese valor, el motor se detiene, restablece su posición actual a 0 y luego ejecuta la misma cantidad de pasos en la dirección opuesta, lo que en realidad devuelve el motor a su posición inicial.
Luego, nuevamente alimentamos la misma longitud de cable y colocamos el pasador hacia abajo para que el doblador pueda moverse a una nueva posición inicial que se usa para doblar en la otra dirección. Luego se levanta el pasador del doblador y doblamos el alambre 105 grados en la dirección opuesta. Los comandos se repiten 5 veces y así obtenemos la forma de estrella.
De manera similar a como se explicó anteriormente, hacemos la forma de cubo o cualquier otra forma que se nos ocurra. En cuanto al modo manual, el principio de funcionamiento de los comandos es el mismo, excepto que tenemos algunas líneas más para leer los comandos que provienen del monitor serie. Por ejemplo, para alimentar el alambre, necesitamos escribir "f", más la distancia en milímetros, para doblar el alambre, necesitamos escribir "b", más el ángulo en grados, y para rotar el eje Z, necesitamos para escribir "z", más el ángulo en grados.
Así es como funciona el programa que hice, pero por supuesto, hay muchas otras formas de codificar esto. Aquí está el código completo de Arduino para esta máquina dobladora de alambre 3D:
At the end I would like to point out that the wire straightening system of the wire bending machine is actually not working like it should work, because if I tighten it more, the feeder loses grip and the wire doesn’t move.
For solving this issue you could try to use different, stronger material than the copper tube or make a different feeder system.
Eso es todo. I hope you enjoyed this video and learned something new. No dude en hacer cualquier pregunta en la sección de comentarios a continuación y consulte mi Colección de proyectos de Arduino.Resumen
DIY 3D Wire Bending Machine 3D Model
Construyendo la Máquina Dobladora de Alambres
Diagrama de circuito
Diseño de PCB
Código Arduino para el proyecto de máquina dobladora de alambre 3D
#include <AccelStepper.h>
#include <Servo.h>
#define limitSwitch 11
// Define the stepper motors and the pins the will use
AccelStepper feederStepper(1, 5, 6); // (Type:driver, STEP, DIR)
AccelStepper zAxisStepper(1, 7, 8);
AccelStepper benderStepper(1, 9, 10);
Servo servo01;
String dataIn = "";
String manualStatus = "";
int count = 0;
int dist;Code language: Arduino (arduino)void setup() {
Serial.begin(9600);
pinMode(limitSwitch, INPUT_PULLUP);
servo01.attach(2);
servo01.write(40); // Initial position, bending pin up
// Stepper motors max speed
feederStepper.setMaxSpeed(2000);
zAxisStepper.setMaxSpeed(2000);
benderStepper.setMaxSpeed(2000);
// Homing
while (digitalRead(limitSwitch) != 0) {
benderStepper.setSpeed(1200);
benderStepper.runSpeed();
benderStepper.setCurrentPosition(0); // When limit switch pressed set position to 0 steps
}
delay(40);
// Move 1400 steps from the limit switch to starting position
while (benderStepper.currentPosition() != -1400) {
benderStepper.setSpeed(-1200); // if negative rotates anti-clockwise
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
}Code language: Arduino (arduino)void loop() {
String mode = Serial.readString();
if (mode.startsWith("manual")) {
manual();
}
if (mode.startsWith("star")) {
star();
}
if (mode.startsWith("cube")) {
cube();
}
if (mode.startsWith("stand")) {
stand();
}
}Code language: Arduino (arduino)void star() {
while (count != 5) {
int feed = 38; // mm
int feedDistance = feed * 48; // 48- constats that map the mm value to number of steps the stepper show move
while (feederStepper.currentPosition() != feedDistance) { // run until it reaches the distance value
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0); // reset the current position to 0
servo01.write(40); // Set the bender pin up
delay(200);
int angleConst = 18; // angle constant
// Bend the wire 52 degrees
while (benderStepper.currentPosition() != -52 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Go back 52 degrees to initial position
while (benderStepper.currentPosition() != 52 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Feed the same distance again
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
servo01.write(130); // Set the bender pin down
delay(200);
// Set bender to new initial position, for bending in the other direction
while (benderStepper.currentPosition() != -42 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(200);
servo01.write(40); // Bender pin up
delay(200);
while (benderStepper.currentPosition() != 105 * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(50);
while (benderStepper.currentPosition() != -63 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
delay(100);
servo01.write(130);
benderStepper.setCurrentPosition(0);
count++;
}
}Code language: Arduino (arduino)int feed = 38; // mm
int feedDistance = feed * 48; // 48- constats that map the mm value to number of steps the stepper show move
while (feederStepper.currentPosition() != feedDistance) { // run until it reaches the distance value
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0); // reset the current position to 0Code language: Arduino (arduino)// Bend the wire 52 degrees
while (benderStepper.currentPosition() != -52 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Go back 52 degrees to initial position
while (benderStepper.currentPosition() != 52 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);Code language: Arduino (arduino)if (dataIn.startsWith("f")) {
dataInS = dataIn.substring(1, dataIn.length()); // reads the feed value
dist = dataInS.toInt();
Serial.print("Feed ");
Serial.print(dist);
Serial.println("mm wire.");
dist = dist * 48;
while (feederStepper.currentPosition() != dist) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
}Code language: Arduino (arduino)/*
Arduino 3D Wire Bending Machine
by Dejan Nedelkovski
www.HowToMechatronics.com
Library - AccelStepper by Mike McCauley:
http://www.airspayce.com/mikem/arduino/AccelStepper/index.html
*/
#include <AccelStepper.h>
#include <Servo.h>
#define limitSwitch 11
// Define the stepper motors and the pins the will use
AccelStepper feederStepper(1, 5, 6); // (Type:driver, STEP, DIR)
AccelStepper zAxisStepper(1, 7, 8);
AccelStepper benderStepper(1, 9, 10);
Servo servo01;
String dataIn = "";
String manualStatus = "";
int count = 0;
int dist;
void setup() {
Serial.begin(9600);
pinMode(limitSwitch, INPUT_PULLUP);
servo01.attach(2);
servo01.write(40); // Initial position, bending pin up
// Stepper motors max speed
feederStepper.setMaxSpeed(2000);
zAxisStepper.setMaxSpeed(2000);
benderStepper.setMaxSpeed(2000);
// Homing
while (digitalRead(limitSwitch) != 0) {
benderStepper.setSpeed(1200);
benderStepper.runSpeed();
benderStepper.setCurrentPosition(0); // When limit switch pressed set position to 0 steps
}
delay(40);
// Move 1400 steps from the limit switch to starting position
while (benderStepper.currentPosition() != -1400) {
benderStepper.setSpeed(-1200); // if negative rotates anti-clockwise
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
}
void loop() {
String mode = Serial.readString();
if (mode.startsWith("manual")) {
manual();
}
if (mode.startsWith("star")) {
star();
}
if (mode.startsWith("cube")) {
cube();
}
if (mode.startsWith("stand")) {
stand();
}
}
void star() {
while (count != 5) {
int feed = 38; // mm
int feedDistance = feed * 48; // 48- constats that map the mm value to number of steps the stepper show move
while (feederStepper.currentPosition() != feedDistance) { // run until it reaches the distance value
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0); // reset the current position to 0
servo01.write(40); // Set the bender pin up
delay(200);
int angleConst = 18; // angle constant
// Bend the wire 52 degrees
while (benderStepper.currentPosition() != -52 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Go back 52 degrees to initial position
while (benderStepper.currentPosition() != 52 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Feed the same distance again
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
servo01.write(130); // Set the bender pin down
delay(200);
// Set bender to new initial position, for bending in the other direction
while (benderStepper.currentPosition() != -42 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(200);
servo01.write(40); // Bender pin up
delay(200);
while (benderStepper.currentPosition() != 105 * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(50);
while (benderStepper.currentPosition() != -63 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
delay(100);
servo01.write(130);
benderStepper.setCurrentPosition(0);
count++;
}
}
void cube() {
int feed = 40; // mm
int feedDistance = feed * 48;
int angleConst = 16;
// Step 1
while (count != 3) {
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
count++;
}
count = 0;
// Step 2
while (zAxisStepper.currentPosition() != 88 * angleConst) {
zAxisStepper.setSpeed(500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
//Step 3
while (count != 2) {
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
count++;
}
count = 0;
// Step 4
while (zAxisStepper.currentPosition() != 85 * angleConst) {
zAxisStepper.setSpeed(500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
// Step 5
servo01.write(130);
delay(200);
while (benderStepper.currentPosition() != -42 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
while (count != 3) {
delay(100);
servo01.write(40);
delay(200);
// Step 6
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
count++;
}
count = 0;
}
void stand() {
int feed = 20; // mm
int feedDistance = feed * 48;
int angleConst = 16;
// Step 1
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Step 2
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -70 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 70 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Step 3
feed = 80; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
// Step 4
servo01.write(130);
delay(200);
while (benderStepper.currentPosition() != -42 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
servo01.write(40);
delay(200);
while (benderStepper.currentPosition() != 108 * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -66 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
//Step 5
servo01.write(130);
delay(200);
// Step 6
feed = 80; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
servo01.write(40);
delay(200);
// Step 7
while (zAxisStepper.currentPosition() != -90 * angleConst) {
zAxisStepper.setSpeed(-500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
// Step 8
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Step 6
feed = 45; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
// Step 10
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 48 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Step 11
while (zAxisStepper.currentPosition() != 90 * angleConst) {
zAxisStepper.setSpeed(500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
feed = 80; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
// Step 12
while (benderStepper.currentPosition() != 110 * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -68 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
//Step 13
servo01.write(130);
delay(200);
feed = 80; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
servo01.write(40);
delay(200);
// Step 14
while (benderStepper.currentPosition() != -70 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 70 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
//Step 15
feed = 25; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
// Step 16
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Step 17
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
}
void manual() {
int sign;
String dataInS;
int angle;
int angleConst;
Serial.println(" // MANUAL MODE //");
while (!dataIn.startsWith("end")) {
servo01.write(130);
delay(200);
dataIn = Serial.readString();
if (dataIn.startsWith("f")) {
dataInS = dataIn.substring(1, dataIn.length()); // reads the feed value
dist = dataInS.toInt();
Serial.print("Feed ");
Serial.print(dist);
Serial.println("mm wire.");
dist = dist * 48;
while (feederStepper.currentPosition() != dist) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
}
if (dataIn.startsWith("b")) {
if (dataIn.charAt(1) == '-') {
dataInS = dataIn.substring(2, dataIn.length()); ///reads the angle value
angle = dataInS.toInt();
Serial.print("Bend -");
Serial.print(angle);
Serial.println(" degrees.");
angleConst = 16;
// Set "negative" bending initial position
while (benderStepper.currentPosition() != -43 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
servo01.write(40);
delay(200);
// Bend the wire
while (benderStepper.currentPosition() != angle * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != (-1) * angle * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
servo01.write(130);
delay(200);
// Get back to original "positive" bending initial poistion
while (benderStepper.currentPosition() != 43 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
}
else {
dataInS = dataIn.substring(1, dataIn.length());
angle = dataInS.toInt();
Serial.print("Bend ");
Serial.print(angle);
Serial.println(" degrees.");
angleConst = 16;
servo01.write(40);
delay(200);
while (benderStepper.currentPosition() != (-1) *angle * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != angle * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
}
dataInS = dataIn.substring(2, dataIn.length());
angle = dataInS.toInt();
angleConst = 16;
while (benderStepper.currentPosition() != sign * angle * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != sign * angle * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
}
// Z-Axis Control
if (dataIn.startsWith("z")) {
if (dataIn.charAt(1) == '-') {
dataInS = dataIn.substring(2, dataIn.length());
angle = dataInS.toInt();
Serial.print("Move Z-Axis -");
Serial.print(angle);
Serial.println(" degrees.");
angleConst = 16;
while (zAxisStepper.currentPosition() != angle * angleConst) {
zAxisStepper.setSpeed(500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
}
else {
dataInS = dataIn.substring(1, dataIn.length());
angle = dataInS.toInt();
Serial.print("Move Z-Axis ");
Serial.print(angle);
Serial.println(" degrees.");
angleConst = 16;
while (zAxisStepper.currentPosition() != (-1) *angle * angleConst) {
zAxisStepper.setSpeed(-500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
}
}
manualStatus = dataIn;
}
}
Code language: Arduino (arduino)
Proceso de manufactura
- Máquina de coser
- Alambre de púas
- Máquina de malla de alambre hexagonal
- ¿Cómo puede ayudar una máquina cortadora de alambre?
- ¿Qué es la máquina dobladora de láminas?
- Electroerosión por hilo:un vistazo a la industria metalúrgica de Taiwán
- Última máquina de electroerosión por hilo en Taiwán
- La impresionante máquina dobladora de tubos CNC
- Una guía rápida para la máquina dobladora de tubos cuadrados
- Máquina dobladora de tubos hidráulica para talleres
- ¿Qué es una máquina dobladora de tubos eléctrica?