Construa uma Máquina de Dobrar Arame 3D Controlada por Arduino – Guia Passo a Passo

Neste tutorial, mostrarei como construí uma máquina de dobrar arame 3D baseada em Arduino. Este é na verdade um sistema mecatrônico típico porque envolve engenharia mecânica, elétrica e de computação. Portanto, acredito que muitos estudantes de engenharia ou qualquer pessoa nova em mecatrônica achará este projeto interessante.

Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo.

Visão Geral

Aqui está o princípio de funcionamento desta máquina de dobrar arame 3D. Primeiro, o arame passa por uma série de rolos, ou endireitadores. Usando um motor de passo, o arame é alimentado precisamente para o mecanismo de dobragem, que também usa um motor de passo, bem como um pequeno servo para o processo de dobragem.

Há também outro motor de passo, chamado eixo Z, que permite que a máquina crie formas tridimensionais. Claro, o cérebro da máquina é uma placa Arduino, que junto com os outros componentes eletrônicos é fixada em uma PCB personalizada.

Quanto ao programa, fiz algumas funções personalizadas para fazer várias formas, como uma estrela, um cubo e um suporte simples, bem como um modo manual onde podemos fazer as formas de arame inserindo comandos através do monitor serial.

Modelo 3D da Máquina de Dobrar Arame 3D DIY

Como de costume, comecei fazendo o projeto usando um software de modelagem 3D. Você pode baixar o modelo 3D abaixo.

Inspiração de design: vídeo no YouTube

Você pode encontrar e baixar este modelo 3D, bem como explorá-lo no seu navegador no Thangs.

Você pode baixar o modelo 3D de montagem no Thangs.

Arquivos STL para Impressão 3D:

Para algumas das peças, como as engrenagens, os blocos de mancais e alguns acopladores de eixo, usei uma impressora 3D para fazê-las. Os arquivos STL dessas peças, que são usados para impressão 3D, podem ser baixados dos arquivos acima.

Minha nova impressora 3D, Creality CR-10, fez um ótimo trabalho e imprimiu as peças com ótima qualidade. Aqui está um link para esta impressora 3D caso queira conferir.

Construindo a Máquina de Dobrar Arame

Continuei preparando as outras peças, para as quais usei MDF e compensado. Então, uma vez que obtive todas as dimensões do modelo 3D, usando uma serra circular, cortei as peças no tamanho certo. Usei MDF de 8mm de espessura e compensado de 18mm. Uma vez prontos, comecei a montagem. Primeiro, fiz a base com duas placas de MDF e 4 colunas de compensado. Para fixá-las, usei cola de madeira e alguns parafusos.

Em seguida, no painel superior, fixei os blocos de mancais impressos em 3D usando alguns parafusos e porcas de 8mm. Podemos notar aqui que adicionei placas de MDF de 3mm entre o topo e os blocos de mancais para obter a altura adequada. Agora, nestes blocos, podemos encaixar os mancais 6202.

O diâmetro externo deles é 35mm e o diâmetro interno é 15mm. Então, através destes mancais, precisamos inserir um eixo oco de 15mm para que o arame possa passar por ele. Este eixo é na verdade o eixo Z, que permite que o mecanismo de dobragem gire em torno do arame e, assim, faça formas tridimensionais. Usei um tubo de cobre para esse fim e seu comprimento precisa ser de cerca de 30cm.

Entre os dois mancais, também inseri uma engrenagem impressa em 3D com módulo 1.5 e 30 dentes. A engrenagem tem slots de design personalizado onde podemos inserir porcas M3 e, então, usando parafusos M3, podemos apertar a engrenagem ao eixo.

Em seguida, precisamos instalar o motor de passo do eixo Z. Para isso, imprimi em 3D um suporte de montagem personalizado. Fixei o motor de passo ao suporte usando parafusos M3 e, então, inseri a engrenagem de 18 dentes no eixo do motor. Usei o mesmo método para fixar a engrenagem ao eixo mostrado anteriormente.

Então, usando uma broca de 6mm, fiz dois furos no topo nos quais o suporte de montagem será fixado. Podemos notar que o suporte, em vez de furos, tem fendas que permitem que as duas engrenagens sejam acopladas corretamente.

Prossegui com a instalação do motor de passo para o mecanismo de alimentação. Este motor será montado diretamente no painel superior, então fiz os furos apropriados nele. Então, usando quatro parafusos, fixei o motor de passo à placa, e caso se pergunte o que aquelas porcas fazem aqui, elas na verdade atuam como porcas de espaçamento porque os parafusos que tinha eram mais longos e não cabiam nas roscas do motor.

Agora, no eixo deste motor de passo, precisamos inserir o alimentador. Para isso, imprimi em 3D um acoplador de eixo personalizado no qual inseri um tubo de cobre que será a superfície de contato do alimentador.

Então, no lado oposto do motor, inseri uma alavanca, na qual fixei um mancal que pressionará contra o alimentador. Para obter aderência suficiente para que o alimentador possa mover o arame, fixarei um pedaço de compensado com uma porca T nele e, então, usando um parafuso, poderemos controlar a aderência do alimentador.

O próximo passo é fazer o sistema de endireitamento do arame. Usando três parafusos M8, fixei um pedaço de compensado que perfurei anteriormente de acordo com o modelo 3D. Agora, em cima dele, inseri os rolos. Fiz os rolos com mancais e anéis externos ranhurados impressos em 3D.

Três rolos vão neste lado e dois rolos no outro lado. Para o outro lado, fiz uma fenda na peça de compensado para que os parafusos fiquem nivelados com a peça. Agora, usando apenas dois parafusos, podemos acoplar os dois lados e, usando as porcas, podemos apertar os endireitadores apropriadamente.

Uma vez terminado este passo, adicionei mais duas peças de compensado na frente e atrás dos endireitadores, que servirão como guias do arame.

Ok, agora podemos prosseguir com a fabricação do mecanismo de dobragem do arame. Primeiro, em uma peça de MDF, precisamos fixar o motor dobra-dor. Antes de fazer isso, a peça de MDF que tinha precisava de algum modelamento, então, usando uma serra manual, uma serra de arco e uma lixa, obtive facilmente o formato desejado. Então, usando uma serra copo de 38mm, fiz uma abertura para o motor de passo maior que usaremos para a dobragem, um motor de passo NEMA 23. Também fiz alguns furos menores necessários para fixar as outras peças.

Fixei o motor de passo NEMA 23 usando parafusos e porcas M4 e, em seu eixo de saída, fixei uma engrenagem com módulo 2.5 e 18 dentes. Esta engrenagem será acoplada com uma engrenagem maior de 30 dentes, que é uma engrenagem projetada sob medida com placa integrada para montar um servo MG996R. Este servo moverá um mecanismo de cremalheira e pinhão, que na verdade é um pino que sairá da engrenagem e servirá para dobrar o arame. Usando epóxi de 5 minutos, fixei um mancal na engrenagem e também adicionei um pedaço de tubo de cobre na cremalheira que será a superfície de contato ao dobrar o arame.

Depois que o epóxi secou, acoplei as duas engrenagens fixando a engrenagem maior no lugar com um parafuso M8 e uma porca. Então, inseri a cremalheira e o servo no lugar e fixei usando os parafusos fornecidos no pacote do servo. Então, fixei a engrenagem do pinhão no chifre redondo do servo usando dois parafusos e porcas M3.

Finalmente, fixei o chifre ao servo e, com isso, o mecanismo de dobragem estava completo.

O que resta fazer agora é fixar o dobrador ao eixo Z. Fiz isso usando os dois grampos de eixo impressos em 3D. Primeiro, fixei-os à placa do dobrador usando parafusos e porcas M6 e, então, os inseri no eixo Z. Inseri as duas porcas no lugar e, usando os parafusos, apertei os grampos ao eixo. Agora, todas as partes móveis estão funcionando corretamente.

Na verdade, há mais dois pequenos detalhes a adicionar. Este bico de 3mm no eixo onde o arame sai.

E na parte inferior do dobrador, coloquei um micro interruptor de fim de curso que será usado para definir a posição inicial do dobrador.

E pronto, nossa máquina de dobrar arame 3D está quase pronta. Digo quase, porque agora precisamos dar vida a esta máquina, ou conectar os componentes eletrônicos e programá-la.

Diagrama de Circuito

Aqui está o diagrama de circuito deste projeto.

Os três motores de passo são controlados usando três drivers de passo DRV8825. Para alimentar os steppers e todo o projeto, usaremos uma fonte de 12V com pelo menos 3A de corrente.

Para alimentar o servo, poderíamos usar os 5V vindos do Arduino, mas o servo MG996R pode ser faminto por energia e o regulador de 5V do Arduino pode não conseguir lidar com isso. Portanto, decidi usar um regulador de tensão 5V separado, o LM7805, que é bom o suficiente para alimentar o servo para este projeto. Há também um interruptor de fim de curso para o dobrador que tem um resistor pull-up e está conectado a um pino digital da placa Arduino.

Você pode obter os componentes necessários para este projeto nos links abaixo:

• Motor de Passo – NEMA 17
• Motor de Passo – NEMA 23
• Driver de Passo DRV8825
• Micro Interruptor de Fim de Curso
• Adaptador 12V 2A
• Conector de Energia (Power Jack)
• Placa Arduino

Design da PCB

Em seguida, para eliminar a bagunça de fiação e manter os componentes eletrônicos organizados, projetei uma PCB personalizada usando o software gratuito de design de circuitos online EasyEDA. O circuito tem muitas conexões, então usei tanto a camada superior quanto a inferior para organizá-las. Também adicionei pinos para selecionar a resolução dos steppers, adicionei mais uma conexão de interruptor de fim de curso e forneci pinos digitais e analógicos adicionais vindos do Arduino, caso precisemos deles para algo.

Aqui está o link para os arquivos do projeto deste design de PCB. Uma vez terminado este design, gerei o arquivo Gerber necessário para a fabricação da PCB.

Arquivo Gerber:

Então, encomendei a PCB na JLCPCB, que é na verdade a patrocinadora deste projeto.

Aqui podemos simplesmente arrastar e soltar o arquivo Gerber e, uma vez carregado, podemos revisar nossa PCB no visualizador Gerber. Se tudo estiver correto, podemos prosseguir, selecionar as propriedades que desejamos para nossa PCB e, então, podemos encomendar nossa PCB a um preço razoável. Note que se for seu primeiro pedido na JLCPCB, você pode obter até 10 PCBs por apenas $2.

Após alguns dias, as PCBs chegaram. A qualidade das PCBs é excelente e tudo é exatamente igual ao design.

Agora podemos prosseguir e instalar os componentes eletrônicos na PCB. Comecei soldando headers de pinos na PCB. Isso permite conectar e desconectar os componentes mais facilmente quando necessário. Quanto aos componentes menores, como capacitores, resistores, regulador de tensão e blocos de terminais, soldei-os diretamente na PCB.

Uma vez terminado este passo, agora podemos inserir os drivers de passo e o Arduino no lugar. Então, precisamos conectar o conector de energia e o interruptor de energia aos blocos de terminais, conectar os cabos aos motores de passo de um lado e conectá-los à PCB do outro lado. O servo está conectado ao pino digital número 2 e alimentado com os 5V vindos do regulador de tensão LM7805. Finalmente, podemos selecionar a resolução do stepper conectando os pinos de resolução abaixo dos drivers.

Decidi usar resolução de 1/16 de passo, então precisamos conectar os pinos certos em vez dos do meio, como visto na foto acima. Então, os componentes eletrônicos estão prontos e podemos prosseguir com a programação da máquina de dobrar arame.

Código Arduino para Projeto Máquina de Dobrar Arame 3D

Como o código é um pouco longo, para melhor entendimento, postarei o código fonte do programa em seções com descrição para cada seção. E no final deste artigo, postarei o código fonte completo.

Para controlar os motores de passo, usarei a biblioteca AccelStepper de Mike McCauley. Então, precisamos incluir esta biblioteca, bem como a biblioteca servo para controlar o motor servo. Então, precisamos definir os pinos aos quais os steppers estão conectados e algumas variáveis necessárias para o programa abaixo.

#include <AccelStepper.h>
#include <Servo.h>
#define limitSwitch 11
// Define os motores de passo e os pinos que usarão
AccelStepper feederStepper(1, 5, 6); // (Tipo:driver, STEP, DIR)
AccelStepper zAxisStepper(1, 7, 8);
AccelStepper benderStepper(1, 9, 10);
Servo servo01;
String dataIn = "";
String manualStatus = "";
int count = 0;
int dist;

Na seção setup, definimos a posição inicial do servo ou do pino de dobragem, e também definimos a posição inicial da engrenagem do dobrador. Isso é feito com a ajuda do interruptor de fim de curso. O motor de passo rotaciona em direção ao interruptor e, uma vez pressionado, o motor começa a contar os passos a partir do zero e se posiciona a zero graus, pronto para dobrar.

void setup() {
  Serial.begin(9600);
  pinMode(limitSwitch, INPUT_PULLUP);
  servo01.attach(2);
  servo01.write(40); // Posição inicial, pino de dobragem para cima
  // Velocidade máxima dos motores de passo
  feederStepper.setMaxSpeed(2000);
  zAxisStepper.setMaxSpeed(2000);
  benderStepper.setMaxSpeed(2000);
  // Homing
  while (digitalRead(limitSwitch) != 0) {
    benderStepper.setSpeed(1200);
    benderStepper.runSpeed();
    benderStepper.setCurrentPosition(0); // Quando interruptor pressionado, define posição como 0 passos
  }
  delay(40);
  // Move 1400 passos do interruptor de fim de curso para posição inicial
  while (benderStepper.currentPosition() != -1400) {
    benderStepper.setSpeed(-1200); // se negativo, rotaciona anti-horário
    benderStepper.run();
  }
  benderStepper.setCurrentPosition(0);
}

Agora, na seção loop, esperamos por comandos vindos do monitor serial. Se digitarmos "manual", entraremos no modo de dobragem manual ou, se digitarmos, por exemplo, "star", a função personalizada star() será executada e a máquina fará automaticamente uma forma de estrela para nós.

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

Vamos ver esta função personalizada.

void star() {
  while (count != 5) {
    int feed = 38; // mm
    int feedDistance = feed * 48; // 48- constante que mapeia valor mm para número de passos que o stepper deve mover
    while (feederStepper.currentPosition() != feedDistance) {
      // roda até atingir o valor de distância
      feederStepper.setSpeed(1200);
      feederStepper.run();
    }
    feederStepper.setCurrentPosition(0); // reseta posição atual para 0
    servo01.write(40); // Define pino do dobrador para cima
    delay(200);
    int angleConst = 18; // constante de ângulo
    // Dobra o arame 52 graus
    while (benderStepper.currentPosition() != -52 * angleConst) {
      benderStepper.setSpeed(-700);
      benderStepper.run();
    }
    benderStepper.setCurrentPosition(0);
    delay(100);
    // Volta 52 graus para posição inicial
    while (benderStepper.currentPosition() != 52 * angleConst) {
      benderStepper.setSpeed(1200);
      benderStepper.run();
    }
    benderStepper.setCurrentPosition(0);
    delay(100);
    // Alimenta a mesma distância novamente
    while (feederStepper.currentPosition() != feedDistance) {
      feederStepper.setSpeed(1200);
      feederStepper.run();
    }
    feederStepper.setCurrentPosition(0);
    delay(100);
    servo01.write(130); // Define pino do dobrador para baixo
    delay(200);
    // Define dobrador para nova posição inicial, para dobrar na outra direção
    while (benderStepper.currentPosition() != -42 * angleConst) {
      benderStepper.setSpeed(-1200);
      benderStepper.run();
    }
    benderStepper.setCurrentPosition(0);
    delay(200);
    servo01.write(40); // Pino do dobrador para cima
    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++;
  }
}

Aqui entramos em um loop while executado 5 vezes, porque obviamente a estrela tem 5 pontas. Começamos definindo o valor de alimentação, ou seja, quanto arame será alimentado em milímetros. Este valor é então multiplicado por 48, que traduz o valor de alimentação em passos apropriados para o motor de passo mover. Então, usando a função run(), rotacionamos o motor alimentador com uma velocidade definida pela função setSpeed(). Paramos quando o valor feedDistance acima é atingido, e logo após definimos o valor de posição atual do stepper como zero.

int feed = 38; // mm
int feedDistance = feed * 48; // 48- constante que mapeia valor mm para número de passos que o stepper deve mover
while (feederStepper.currentPosition() != feedDistance) {
  feederStepper.setSpeed(1200);
  feederStepper.run();
}
feederStepper.setCurrentPosition(0); // reseta posição atual para 0

No próximo passo, dobramos o arame 52 graus. Isso é feito de maneira similar ao explicado acima. Aqui também temos uma constante de ângulo que é multiplicada pelo ângulo desejado. Uma vez que esse valor é atingido pelo motor, o motor para, reseta sua posição atual para 0 e, então, roda o mesmo número de passos na direção oposta, o que na verdade retorna o motor à sua posição inicial.

// Dobra o arame 52 graus
while (benderStepper.currentPosition() != -52 * angleConst) {
  benderStepper.setSpeed(-700);
  benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Volta 52 graus para posição inicial
while (benderStepper.currentPosition() != 52 * angleConst) {
  benderStepper.setSpeed(1200);
  benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);

Então, novamente alimentamos o mesmo comprimento de arame e definimos o pino para baixo para que o dobrador possa mover para uma nova posição inicial usada para dobrar na outra direção. O pino do dobrador é então levantado, e dobramos o arame 105 graus na direção oposta. Os comandos são repetidos 5 vezes e é assim que obtemos a forma de estrela.

De maneira similar, como explicado acima, fazemos a forma de cubo ou qualquer outra forma que possamos imaginar. Quanto ao modo manual, o princípio de funcionamento dos comandos é o mesmo, exceto que temos algumas linhas a mais para ler os comandos vindos do monitor serial. Por exemplo, para alimentar o arame, precisamos digitar "f", mais a distância em milímetros; para dobrar o arame, precisamos digitar "b", mais o ângulo em graus; e para rotacionar o eixo Z, precisamos digitar "z", mais o ângulo em graus.

if (dataIn.startsWith("f")) {
  dataInS = dataIn.substring(1, dataIn.length()); // lê o valor de alimentação
  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);
}

É assim que o programa que fiz funciona, mas, claro, existem muitas outras formas de codificar isso. Aqui está o código Arduino completo para esta Máquina de Dobrar Arame 3D:

/* Arduino 3D Wire Bending Machine
by Dejan Nedelkovski
www.HowToMechatronics.com
Library - AccelStepper by Mike McCauley: https://www.airspayce.com/mikem/arduino/AccelStepper/index.html */
#include <AccelStepper.h>
#include <Servo.h>
#define limitSwitch 11
AccelStepper feederStepper(1, 5, 6);
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);
  feederStepper.setMaxSpeed(2000);
  zAxisStepper.setMaxSpeed(2000);
  benderStepper.setMaxSpeed(2000);
  while (digitalRead(limitSwitch) != 0) {
    benderStepper.setSpeed(1200);
    benderStepper.runSpeed();
    benderStepper.setCurrentPosition(0);
  }
  delay(40);
  while (benderStepper.currentPosition() != -1400) {
    benderStepper.setSpeed(-1200);
    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;
    int feedDistance = feed * 48;
    while (feederStepper.currentPosition() != feedDistance) {
      feederStepper.setSpeed(1200);
      feederStepper.run();
    }
    feederStepper.setCurrentPosition(0);
    servo01.write(40);
    delay(200);
    int angleConst = 18;
    while (benderStepper.currentPosition() != -52 * angleConst) {
      benderStepper.setSpeed(-700);
      benderStepper.run();
    }
    benderStepper.setCurrentPosition(0);
    delay(100);
    while (benderStepper.currentPosition() != 52 * angleConst) {
      benderStepper.setSpeed(1200);
      benderStepper.run();
    }
    benderStepper.setCurrentPosition(0);
    delay(100);
    while (feederStepper.currentPosition() != feedDistance) {
      feederStepper.setSpeed(1200);
      feederStepper.run();
    }
    feederStepper.setCurrentPosition(0);
    delay(100);
    servo01.write(130);
    delay(200);
    while (benderStepper.currentPosition() != -42 * angleConst) {
      benderStepper.setSpeed(-1200);
      benderStepper.run();
    }
    benderStepper.setCurrentPosition(0);
    delay(200);
    servo01.write(40);
    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;
  int feedDistance = feed * 48;
  int angleConst = 16;
  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;
  while (zAxisStepper.currentPosition() != 88 * angleConst) {
    zAxisStepper.setSpeed(500);
    zAxisStepper.run();
  }
  zAxisStepper.setCurrentPosition(0);
  delay(100);
  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;
  while (zAxisStepper.currentPosition() != 85 * angleConst) {
    zAxisStepper.setSpeed(500);
    zAxisStepper.run();
  }
  zAxisStepper.setCurrentPosition(0);
  delay(100);
  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);
    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;
  int feedDistance = feed * 48;
  int angleConst = 16;
  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);
  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);
  feed = 80;
  feedDistance = feed * 48;
  while (feederStepper.currentPosition() != feedDistance) {
    feederStepper.setSpeed(1200);
    feederStepper.run();
  }
  feederStepper.setCurrentPosition(0);
  delay(100);
  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);
  servo01.write(130);
  delay(200);
  feed = 80;
  feedDistance = feed * 48;
  while (feederStepper.currentPosition() != feedDistance) {
    feederStepper.setSpeed(1200);
    feederStepper.run();
  }
  feederStepper.setCurrentPosition(0);
  servo01.write(40);
  delay(200);
  while (zAxisStepper.currentPosition() != -90 * angleConst) {
    zAxisStepper.setSpeed(-500);
    zAxisStepper.run();
  }
  zAxisStepper.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);
  feed = 45;
  feedDistance = feed * 48;
  while (feederStepper.currentPosition() != feedDistance) {
    feederStepper.setSpeed(1200);
    feederStepper.run();
  }
  feederStepper.setCurrentPosition(0);
  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);
  while (zAxisStepper.currentPosition() != 90 * angleConst) {
    zAxisStepper.setSpeed(500);
    zAxisStepper.run();
  }
  zAxisStepper.setCurrentPosition(0);
  delay(100);
  feed = 80;
  feedDistance = feed * 48;
  while (feederStepper.currentPosition() != feedDistance) {
    feederStepper.setSpeed(1200);
    feederStepper.run();
  }
  feederStepper.setCurrentPosition(0);
  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);
  servo01.write(130);
  delay(200);
  feed = 80;
  feedDistance = feed * 48;
  while (feederStepper.currentPosition() != feedDistance) {
    feederStepper.setSpeed(1200);
    feederStepper.run();
  }
  feederStepper.setCurrentPosition(0);
  servo01.write(40);
  delay(200);
  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);
  feed = 25;
  feedDistance = feed * 48;
  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);
  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());
      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());
        angle = dataInS.toInt();
        Serial.print("Bend -");
        Serial.print(angle);
        Serial.println(" degrees.");
        angleConst = 16;
        while (benderStepper.currentPosition() != -43 * angleConst) {
          benderStepper.setSpeed(-1200);
          benderStepper.run();
        }
        benderStepper.setCurrentPosition(0);
        delay(100);
        servo01.write(40);
        delay(200);
        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);
        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);
    }
    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;
  }
}

No final, gostaria de apontar que o sistema de endireitamento de arame da máquina de dobrar arame na verdade não funciona como deveria, porque se eu apertar mais, o alimentador perde aderência e o arame não se move.

Para resolver este problema, você poderia tentar usar material diferente, mais forte que o tubo de cobre, ou fazer um sistema de alimentação diferente.

É isso. Espero que tenha gostado deste vídeo e aprendido algo novo. Sinta-se à vontade para fazer qualquer pergunta na seção de comentários abaixo e confira minha Coleção de Projetos Arduino.