¿Te has preguntado cómo puedes darle forma a tus proyectos de electrónica de una manera más eficiente y precisa? ¡La máquina dobladora de alambre Arduino 3D es la solución que estabas buscando! En este artículo, descubrirás cómo esta innovadora herramienta puede facilitar tus creaciones y darles un toque profesional. Sigue leyendo y sumérgete en el mundo de la fabricación digital con Arduino.
En este tutorial, te mostraré cómo construí una máquina dobladora de cables 3D basada en Arduino. En realidad, se trata de un sistema mecatrónico típico, ya que incluye ingeniería mecánica, ingeniería eléctrica e ingeniería informática. Por lo tanto, creo que muchos estudiantes de ingeniería o cualquier persona nueva en mecatrónica encontraron interesante este proyecto.
Puede ver el vídeo a continuación o leer el tutorial escrito a continuación.
descripción general
Aquí está el principio de funcionamiento de esta máquina dobladora de alambre 3D. Primero, el alambre pasa por una serie de rodillos o enderezadores. Utilizando un motor paso a paso, el cable se alimenta con precisión al mecanismo de doblado de alambre, que también utiliza un motor paso a paso y un pequeño servo para el proceso de doblado.
También>
En>
Máquina dobladora de alambre 3D DIY modelo 3D
Como de costumbre, comencé creando el proyecto utilizando un software de modelado 3D. Puedes descargar el modelo 3D a continuación.
Inspiración>Video de Youtube
Puede buscar y descargar este modelo 3D y explorarlo en su navegador en Thangs.
Puede>Descarga el modelo de montaje 3D en Thangs.
Archivos STL para impresión 3D:
Archivos STL de la máquina dobladora de cables Arduino 3D
Para algunas piezas, como los engranajes, los bloques de cojinetes y algunos acoplamientos de eje, utilicé una impresora 3D. Los archivos STL de estas piezas utilizadas para la impresión 3D se pueden descargar desde los archivos mencionados anteriormente.
Ver también
Las mejores impresoras 3D asequibles para principiantes y aficionados
Mi nueva impresora 3D, Creality CR-10, hizo un gran trabajo imprimiendo las piezas con excelente calidad. Aquí hay un enlace a esta impresora 3D si quieres verla.
Construcción de la máquina dobladora de alambre.
Continué preparando las demás piezas para las que utilicé MDF y contrachapado. Después de tomar todas las dimensiones del modelo 3D con una sierra circular, corté las piezas. Utilicé MDF de 8 mm de espesor y madera contrachapada de 18 mm de espesor. Después de terminarlos, comencé a ensamblarlos. Primero hice la base con dos tableros de MDF y 4 columnas de madera contrachapada. Utilicé pegamento para madera y algunos tornillos para fijarlo.
A>
Su>
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 hechas a medida donde podemos insertar tuercas M3 y luego usar tornillos M3 para apretar el engranaje al eje.
A>
Luego,>
Procedí>
Ahora>
Luego>
El>
Hay>
Después>
Bien, ahora podemos pasar a hacer el mecanismo para doblar cables. Primero necesitamos conectar el motor de doblado a una pieza de MDF. Antes tuve que moldear un poco la pieza de MDF, así que conseguí fácilmente la forma que quería usando una sierra de mano, una sierra circular y una escofina. 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 hice algunos agujeros más pequeños necesarios para unir las otras piezas.
Conecté>
Después>
Finalmente>
Ahora>
En>
Y>
Y>
diagrama de circuito
Aquí está el esquema de este proyecto.
Los>
Para alimentar el servo, podríamos usar los 5 V del Arduino, pero el servo MG996R puede consumir mucha energía y el regulador de voltaje de 5 V del Arduino puede no ser capaz de manejarlo. Por lo tanto, decidí utilizar un regulador de voltaje de 5 V independiente, el LM7805, que es suficiente para alimentar el servo de 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 en la placa Arduino.
Puede obtener los componentes necesarios para este proyecto a través de los siguientes enlaces:
- Motor paso a paso – NEMA 17……… Amazonas / Banggood / AliExpress
- Motor paso a paso – NEMA 23 …….. Amazon / Banggood / AliExpress
- Controlador paso a paso DRV8825…….…. Amazon / Banggood / AliExpress
- Microinterruptor de límite………..………… Amazonas / Banggood / AliExpress
- Adaptador 12V 2A……………………..…. Amazon / Banggood / AliExpress
- Conexión eléctrica………….………….…… Amazonas / Banggood / AliExpress
- Placa Arduino………………………… Amazon / Banggood / AliExpress
Divulgación: estos son enlaces de afiliados. Como asociado de Amazon, gano con compras que califican.
diseño de PCB
A continuación, diseñé una placa de circuito personalizada utilizando el software gratuito de diseño de circuitos en línea EasyEDA para eliminar el desorden de cables y mantener organizados los componentes electrónicos. El circuito tiene muchas conexiones, así que utilicé las capas superior e inferior para organizarlas. También agregué pines para seleccionar la resolución del paso a paso, agregué otro conector de interruptor de límite y proporcioné pines digitales y analógicos adicionales del Arduino en caso de que los necesitemos para algo.
Aquí>Archivos de proyecto de este diseño de PCB.. Después de terminar este diseño, creé el archivo Gerber necesario para hacer la placa de circuito.
Archivo Gerber:
Gerber_Máquina dobladora de alambre 3D automática PCB
Entonces yo Pedí la placa a JLCPCBquien es realmente el patrocinador de este proyecto.
Aquí>
Al>
Ahora>
Una>
Elegí>
Código Arduino para un proyecto de máquina dobladora de alambre 3D
Dado que el código es un poco más largo, para una mejor comprensión publicaré el código fuente del programa en secciones con una descripción para cada sección. Y al final de este artículo publicaré el código fuente completo.
Los uso para controlar los motores paso a paso. Biblioteca AccelStepper de Mike McCauley. Por lo tanto, necesitamos incluir esta biblioteca así como la biblioteca de servomotores para controlar el servomotor. Luego necesitamos definir los pines a los que están conectados los motores paso a paso y algunas variables necesarias para el siguiente programa.
#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)
En el área de configuración ajustamos la posición inicial del servo o del pasador de flexión, así como la posición inicial del engranaje de flexión. Esto se hace con la ayuda del interruptor de límite. El motor paso a paso gira hacia el interruptor y una vez presionado, el motor comienza a contar pasos desde cero y se posiciona en cero grados, listo para doblarse.
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)
Ahora en la sección de bucle esperamos los comandos provenientes del monitor serie. Si ingresamos manualmente, ingresaremos al modo de plegado manual, o por ejemplo, si ingresamos estrella, se ejecutará la función personalizada start() y la máquina creará automáticamente una forma de estrella para nosotros.
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)
Echemos un vistazo a esta función personalizada.
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)
Entonces aquí ingresamos a un ciclo while que se ejecuta 5 veces porque la estrella obviamente tiene 5 picos. Comenzamos configurando el valor de avance, es decir, cuánto alambre se alimenta en milímetros. Luego, este valor se multiplica por 48, lo que convierte el valor de avance en los pasos correspondientes para el movimiento del motor paso a paso. Luego usamos la función run() para girar el motor de alimentación a una velocidad establecida por la función setSpeed(). Nos detenemos cuando se alcanza el valor de feedDistance mencionado anteriormente e inmediatamente después establecemos el valor de posición actual del motor paso a paso a cero.
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
Code language: Arduino (arduino)
En el siguiente paso doblamos el cable 52 grados. Esto se hace de manera similar a la explicada anteriormente. Aquí también tenemos una constante de ángulo que se multiplica por el ángulo deseado. Una vez que el motor alcanza este valor, se detiene, restablece su posición actual a 0 y luego toma la misma cantidad de pasos en la dirección opuesta, devolviendo efectivamente el motor a su posición inicial.
// 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)
Luego reinsertamos la misma longitud de cable y colocamos el pasador hacia abajo para permitir que la dobladora se mueva a una nueva posición inicial, que se usará para doblar en la otra dirección. Luego se levanta el pasador para doblar y así doblamos el cable 105 grados en la dirección opuesta. Las órdenes se repiten cinco veces y así conseguimos la forma de estrella.
De manera similar a la explicada anteriormente, creamos la forma del cubo o cualquier otra forma que se nos ocurra. En cuanto al modo manual, el principio de funcionamiento de los comandos es el mismo, salvo que tenemos unas líneas más para leer los comandos procedentes del monitor serie. Por ejemplo, para alimentar el alambre necesitamos ingresar «f» más la distancia en milímetros, para doblar el alambre necesitamos ingresar «b» más el ángulo en grados, y para rotar el eje Z necesitamos ingresar «b». más el ángulo en grados Ingrese Ingrese “z” más el ángulo en grados.
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)
Así es como funciona el programa que creé, pero por supuesto hay muchas otras formas de codificarlo. Aquí está el código Arduino completo para esta máquina dobladora de cables 3D:
/*
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)
Por último, me gustaría señalar que el sistema de enderezamiento de alambre de la dobladora de alambre en realidad no funciona como debería porque cuando lo aprieto más, el alimentador pierde agarre y el alambre no se mueve.
Para>
Eso es todo. Espero que hayas disfrutado este video y hayas aprendido algo nuevo. No dudes en hacer tus preguntas en la sección de comentarios a continuación y consultar mi colección de proyectos Arduino.
Máquina dobladora de alambre Arduino 3D: Tutorial paso a paso
En este tutorial, te mostraré cómo construí una máquina de doblado de alambre en 3D basada en Arduino. Este proyecto 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 cualquier persona nueva en mecatrónica encontrará este proyecto interesante.
Visión General
El principio de funcionamiento de esta máquina de doblado de alambre en 3D es el siguiente. Primero, el alambre pasa por una serie de rodillos o enderezadores. Utilizando un motor paso a paso, el alambre se alimenta con precisión al mecanismo de doblado de alambre que también utiliza 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 a la máquina crear formas tridimensionales. Por supuesto, el cerebro de la máquina es una placa Arduino que, junto con los otros componentes electrónicos, está conectada a una PCB diseñada a medida.
Para el 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 las formas de alambre ingresando comandos a través del monitor serie.
Máquina de Doblado de Alambre en 3D: Modelo 3D
Como de costumbre, comencé haciendo el proyecto utilizando un software de modelado 3D. Puedes descargar y visualizar el modelo 3D a continuación.
Diseño Inspiración: Video de YouTube
Archivos STL para Impresión 3D: Descargar
Para algunas de las partes, como los engranajes, los soportes de rodamiento y algunos acopladores de ejes, utilicé una impresora 3D para fabricarlas. Los archivos STL de estas partes, que se utilizan para la impresión 3D, se pueden descargar desde los archivos anteriores.
Construcción de la Máquina de Doblado de Alambre
Continué preparando las otras partes, para las cuales utilicé MDF y contrachapado. Una vez que tomé todas las dimensiones del modelo 3D, utilizando una sierra circular, corté las piezas a medida. Utilicé MDF de 8 mm de espesor y contrachapado de 18 mm de espesor. Una vez que las tuve listas, continué con el ensamblaje.
Primero hice la base con dos placas de MDF y 4 columnas de contrachapado. Para fijarlas, utilicé pegamento para madera y algunos tornillos.
Luego en el panel superior, adjunté los bloques de rodamiento impresos en 3D usando algunos pernos M8 y tuercas. Podemos notar aquí que agregué placas de MDF de 3 mm de espesor entre la parte superior y los bloques de cojinetes para que obtenga la altura adecuada.
Ahora, en estos bloques, podemos colocar los rodamientos 6202. Su diámetro exterior es de 35 mm y el diámetro interior es de 15 mm. Por lo tanto, a través de estos rodamientos, necesitamos insertar un eje hueco de 15 mm para que el alambre pueda pasar a través de él. Este eje es en realidad el eje Z, que permite que el mecanismo de doblado gire alrededor del alambre y de esa manera cree formas tridimensionales. Utilicé un tubo de cobre para ese propósito y su longitud necesita ser de aproximadamente 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 donde podemos insertar tuercas M3 y luego, utilizando pernos M3, podemos apretar el engranaje al eje.
Luego necesitamos instalar el motor paso a paso del eje Z. Para este propósito, imprimí en 3D un soporte de montaje personalizado. Luego fijé el motor paso a paso al soporte con pernos M3 y tuercas, e inserté el engranaje de 18 dientes en el eje del motor. Utilicé el mismo método para fijar el engranaje al eje que se mostró anteriormente.
Luego, mediante una broca de 6 mm, hice dos agujeros en la parte superior en los que se fijará el soporte de montaje. Podemos notar que en lugar de agujeros, el soporte tiene ranuras que permiten que los dos engranajes se emparejen adecuadamente.
Continué con la instalación del motor paso a paso para el mecanismo de alimentación. Este motor se montará directamente en la placa superior, así que taladré los agujeros apropiados en ella. Luego, aseguré el motor paso a paso a la placa con cuatro pernos y luego en el eje inserté el alimentador. Para este propósito, 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.
En el lado opuesto del motor, inserté una palanca, en la que coloqué un cojinete que presionará el alimentador. Para obtener suficiente agarre para que el alimentador pueda mover el alambre, adjuntaré una pieza de contrachapado con una tuerca en T, y luego, utilizando un perno, podremos controlar el agarre del alimentador.
El próximo paso es hacer el sistema de enderezamiento del alambre. Utilizando tres pernos M8, fijé una pieza de contrachapado que previamente perforé de acuerdo con el modelo 3D. Luego, en la parte superior, inserté los rodillos. Hice los rodillos con rodamientos y anillos exteriores acanalados impresos en 3D.
Tres rodillos van en este lado, y dos rodillos en el otro lado. Para el otro lado, hice una ranura en la pieza de contrachapado para que los pernos queden al ras con la pieza. Ahora, usando solo dos pernos, podemos emparejar los dos lados y, utilizando las tuercas, podemos apretar los enderezadores apropiadamente.
Una vez finalizado este paso, añadí otras dos piezas de contrachapado delante y después de los enderezadores que servirán como guías de alambre.
Conclusiones
En conclusión, la máquina de doblado de alambre en 3D que construí es un proyecto emocionante y desafiante para los entusiastas de la mecatrónica. A través de diferentes funciones personalizadas, como la creación de formas estelares, cúbicas o soportes simples, este proyecto ofrece una excelente oportunidad para explorar las capacidades de la ingeniería mecánica, eléctrica e informática.
Si deseas aprender más sobre el proceso de construcción detallado y la programación de esta máquina, asegúrate de revisar todos los recursos mencionados en este artículo.
Para obtener los componentes necesarios para este proyecto, puedes revisar los siguientes enlaces:
- Motor Paso a Paso – NEMA 17
- Motor Paso a Paso – NEMA 23
- Driver de Motor Paso a Paso DRV8825
- Interruptor de Límite
- Adaptador de 12V 2A
- Placa Arduino
Si deseas explorar más proyectos y tutoriales de Arduino, ¡no dudes en consultar nuestra colección de proyectos Arduino!