Máquina de dobra de fio Arduino 3D

Neste tutorial, mostrarei como construí uma máquina de dobra de fios 3D baseada em Arduino. Este é realmente 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 acharam esse 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 dobra de arame 3D. Então, primeiro, o fio passa por uma série de rolos, ou alisadores. Usando um motor de passo, o fio é alimentado com precisão ao mecanismo de dobra de fio que também usa um motor de passo, bem como um pequeno servo para o processo de dobra.

Há também outro motor de passo, chamado eixo Z, que realmente permite que a máquina crie formas tridimensionais. Obviamente, o cérebro da máquina é uma placa Arduino que, juntamente com os outros componentes eletrônicos, é anexada a um PCB personalizado.

Quanto ao programa, fiz algumas funções customizadas para fazer várias formas, como uma estrela, um cubo e um suporte simples, além de um modo manual onde podemos fazer as formas dos fios digitando comandos através do monitor serial.

Modelo 3D de máquina de dobra de fio DIY 3D

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

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

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

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

Arquivos STL para impressão 3D:

Para algumas das peças, como as engrenagens, os mancais de rolamento e alguns acopladores de eixo, usei uma impressora 3D para fazê-los. 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 você queira conferir.

Construindo a máquina de dobra de arame

Continuei com a preparação das outras peças, para as quais usei MDF e compensado. Então, uma vez que tirei todas as dimensões do modelo 3D, usando uma serra circular, cortei as peças no tamanho certo. Usei MDF de 8 mm e compensado de 18 mm. Assim que os preparei, comecei com a montagem. Primeiro fiz a base com duas placas de MDF e 4 colunas de compensado. Para prendê-los, usei uma cola de madeira e alguns parafusos.

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

Seu diâmetro externo é de 35 mm e o diâmetro interno é de 15 mm. Então agora, através desses rolamentos, precisamos inserir um eixo oco de 15 mm para que o fio possa passar por ele. Este eixo é na verdade o eixo Z, que permite que o mecanismo de dobra gire em torno do fio e, dessa forma, faça formas tridimensionais. Usei um tubo de cobre para isso e seu comprimento precisa ser em torno de 30 cm.

Entre os dois rolamentos também inseri uma engrenagem impressa em 3D com módulo de 1,5 e 30 dentes. A engrenagem tem ranhuras de design personalizado onde podemos inserir porcas M3 e, em seguida, 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. Então eu prendi o stepper ao suporte usando parafusos M3 e, em seguida, inseri a engrenagem de 18 dentes no eixo do motor. Eu usei o mesmo método para prender a engrenagem ao eixo, conforme mostrado anteriormente.

Em seguida, usando uma furadeira de 6 mm, fiz dois furos na parte superior onde o suporte de montagem será fixado. Podemos notar que o suporte em vez de furos, possui ranhuras que permitem o emparelhamento adequado das duas engrenagens.

Continuei com a instalação do motor de passo para o mecanismo de alimentação. Este motor será montado diretamente na placa superior, então fiz os furos apropriados nele. Então, usando quatro parafusos, prendi o stepper na placa e, caso você se pergunte o que essas porcas fazem aqui, elas realmente agem como porcas de distância porque os parafusos que eu tinha eram mais longos e não cabiam nas roscas do motor.

Então agora no eixo deste stepper precisamos inserir o alimentador. Para isso, imprimi em 3D um acoplador de eixo personalizado no qual inseri um tubo de cobre que na verdade será a superfície de contato do alimentador.

Em seguida, no lado oposto do motor, inseri uma alavanca, na qual prendi um rolamento que pressionará o alimentador. Para obter aderência suficiente para que o alimentador possa mover o fio, vou prender um pedaço de madeira compensada com uma porca em T e, em seguida, usando um parafuso, poderemos controlar a aderência do alimentador.

O próximo passo é fazer o sistema de alisamento do fio. Usando três parafusos M8, prendi um pedaço de compensado que furei anteriormente de acordo com o modelo 3D. Agora em cima disso eu inseri os rolos. Eu fiz os rolos de rolamentos e anéis externos ranhurados impressos em 3D.

Três rolos vão deste lado e dois rolos do outro lado. Para o outro lado fiz uma ranhura na peça de compensado para que os parafusos ficassem alinhados com a peça. Agora usando apenas dois parafusos podemos emparelhar os dois lados, e usando as porcas podemos apertar os alisadores adequadamente.

Uma vez terminado este passo, adicionei mais dois pedaços de compensado na frente e depois dos alisadores que servirão como guias de arame.

Ok, agora podemos seguir em frente com o mecanismo de dobra do fio. Primeiro em um pedaço de MDF precisamos prender o motor do dobrador. Antes de fazer isso, a peça de MDF que eu tinha precisava de um pouco de modelagem, então usando um serrote, uma serra e uma lima consegui facilmente a forma desejada. Em seguida, usando uma serra copo de 38 mm, fiz uma abertura para o passo maior que usaremos para a dobra, um motor de passo NEMA 23. Também fiz alguns furos menores necessários para prender as outras peças.

Fixei o stepper NEMA 23 com parafusos e porcas M4 e em seu eixo de saída fixei uma engrenagem com módulo de 2,5 e 18 dentes. Esta engrenagem será combinada 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 fio. Usando um epóxi de 5 minutos eu prendi um rolamento na engrenagem e também adicionei um pedaço de tubo de cobre no rack que será a superfície de contato ao dobrar o fio.

Depois que o epóxi secou, emparelhei as duas engrenagens, prendendo a engrenagem maior no lugar com um parafuso M8 e uma porca. Em seguida, inseri o rack e o servo no local e fixei-o usando os parafusos fornecidos na embalagem dos servos. Então eu prendi a engrenagem do pinhão no chifre redondo do servo usando dois parafusos e porcas M3.

Finalmente liguei a buzina ao servo e com isso o mecanismo de dobra foi concluído.

O que resta a fazer agora é anexar o dobrador ao eixo Z. Eu fiz isso usando os dois grampos de eixo impressos em 3D. Primeiro, prendi-os à placa dobrável usando parafusos e porcas M6 e, em seguida, inseri-os no eixo Z. Coloquei as duas porcas no lugar e, usando os parafusos, apertei os grampos no eixo. Então agora todas as partes móveis estão funcionando corretamente.

Na verdade, há mais dois pequenos detalhes a serem adicionados. Esse é esse bico de 3 mm no eixo por onde sai o fio.

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

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

Diagrama de circuito

Aqui está o diagrama de circuito deste projeto.

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

Para alimentar o servo, poderíamos usar os 5V vindos do Arduino, mas o servo MG996R pode consumir muita energia e o regulador de tensão de 5V do Arduino pode não ser capaz de lidar com isso. Portanto, decidi usar um regulador de tensão de 5V separado, o LM7805, que é bom o suficiente para alimentar o servo para este projeto. Há também um interruptor de limite para o dobrador que possui um resistor de pull up 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 limite ………..………
Adaptador 12V 2A…………………..….
Tomada de força…………….………….…
Placa Arduino ………………………

Projeto de PCB

Em seguida, para me livrar da bagunça da fiação e manter os componentes eletrônicos organizados, projetei uma PCB personalizada usando o software de design de circuito online gratuito EasyEDA. O circuito tem muitas conexões, então usei as camadas superior e inferior para organizá-las. Eu também adicionei pinos para selecionar a resolução dos steppers, adicionei mais uma conexão de chave de limite e forneci pinos digitais e analógicos adicionais vindos do Arduino caso precisemos deles para alguma coisa.

Aqui está um link para os arquivos de projeto deste design de PCB. Assim, uma vez finalizado este projeto, gerei o arquivo Gerber necessário para a fabricação do PCB.

arquivo Gerber:

Então encomendei o PCB da JLCPCB, que na verdade é o patrocinador deste projeto.

Aqui podemos simplesmente arrastar e soltar o arquivo Gerber e, uma vez carregado, podemos revisar nosso PCB no visualizador Gerber. Se tudo estiver bem, podemos continuar, selecionar as propriedades que queremos para o nosso PCB, e então podemos encomendar o nosso PCB a um preço razoável. Observe que, se for seu primeiro pedido da JLCPCB, você poderá obter até 10 PCBs por apenas US $ 2.

Depois de vários dias, os PCBs chegaram. A qualidade dos PCBs é ótima e tudo é exatamente igual ao design.

Então agora podemos seguir em frente e instalar os componentes eletrônicos no PCB. Comecei soldando os pinos na placa de circuito impresso. Isso facilita a conexão e desconexão dos componentes quando necessário. Quanto aos componentes menores, como os capacitores, os resistores, o regulador de tensão e os blocos de terminais, eu os soldei diretamente na placa de circuito impresso.

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

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

Código Arduino para projeto de máquina de dobra de fio 3D

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

Para controlar os motores de passo usarei a biblioteca AccelStepper de Mike McCauley. Portanto, precisamos incluir esta biblioteca, bem como a biblioteca servo para controlar o servo motor. Em seguida, 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 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)

Na seção de configuração, definimos a posição inicial do servo ou do pino de dobra, e também definimos a posição inicial da engrenagem do dobrador. Isso é feito com a ajuda do interruptor de limite. O stepper gira em direção ao interruptor e uma vez pressionado o motor começa a contar os passos 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); // 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)

Agora na seção de loop, aguardamos os comandos vindos do monitor serial. Se digitarmos manual, entraremos no modo de dobra manual ou se digitarmos, por exemplo, estrela, a função personalizada start() 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();
  }
}Code language: Arduino (arduino)

Vamos dar uma olhada nesta função 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)

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

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)

Na próxima etapa, dobramos o fio 52 graus. Isso é feito de maneira semelhante, conforme explicado acima. Aqui também temos uma constante de ângulo que é multiplicada pelo ângulo desejado. Uma vez que esse valor é alcançado pelo motor, o motor para, redefine sua posição atual para 0 e, em seguida, executa o mesmo número de etapas na direção oposta que realmente retorna o motor à sua posição 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)

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

De maneira semelhante, conforme explicado acima, fazemos a forma do cubo ou qualquer outra forma que possamos criar. Quanto ao modo manual, o princípio de funcionamento dos comandos é o mesmo, exceto que temos algumas linhas a mais para leitura dos comandos vindos do monitor serial. Por exemplo, para alimentar o fio, precisamos digitar “f”, mais a distância em milímetros, para dobrar o fio, precisamos digitar “b”, mais o ângulo em graus, e para girar o eixo Z, precisamos para digitar “z”, mais o ângulo em graus.

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)

Então é assim que o programa que eu fiz funciona, mas é claro que existem muitas outras maneiras de codificar isso. Aqui está o código completo do Arduino para esta máquina de dobra de fios 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)

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.

So that’s it. Espero que tenham 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 do Arduino.

Robô Arduino Ant Hexapod DIY Vending Machine – Projeto Mecatrônico baseado em Arduino