Arduino Uno com eixo e motor de passo: 19 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

Hoje vamos falar sobre um assunto muito importante na mecânica e na mecatrônica: os elementos das máquinas. Neste artigo, abordaremos especificamente os eixos-árvore, apresentando alguns recursos e aplicações interessantes. Ainda, vamos demonstrar algumas formas de calcular o movimento provocado por um fuso e apresentar uma montagem de teste.

Fiz a montagem abaixo, portanto, que expõe o avanço de um fuso de 2mm e outro de 8mm. Os fusos TR8 que estou usando são comumente usados em pequenos roteadores e impressoras 3D, especialmente no eixo Z. Lembrando que ao dominar alguns conceitos que trabalharemos aqui, você poderá projetar qualquer tipo de máquina.

Etapa 1: Recursos usados

• Fuso trapezoidal de 8 mm de diâmetro e passo de 2 mm
• Fuso trapezoidal de 8 mm de diâmetro e 8 mm de passo
• 8x2 fuso castanho flangeado
• 8x8 fuso castanho flangeado
• Rolamentos para fusos de 8 mm de diâmetro
• Guia cilíndrico linear de 10 mm de diâmetro
• Rolamentos de rolos cilíndricos para guias de 10 mm
• Suportes para guias cilíndricas de 10 mm
• Motores NEMA 17
• Acoplamentos de eixo
• Arduino Uno
• Driver DRV8825
• Teclado de matriz 4x4
• Display Nokia 5110
• Diversas peças de plástico
• Parafusos e porcas
• Base de madeira
• Fonte de alimentação externa de 12 V

Etapa 2: Sobre eixos - o que são?

Os fusos são elementos de máquinas, como parafusos. Ou seja, são barras retas formadas por fios de degraus contínuos. Eles são usados em mecanismos que requerem movimento e posicionamento linear. Eles podem exercer altas forças de tração e compressão e transmitir torque. Permitem movimentação com travamento automático. Podem ser construídos com diversos materiais, sendo os mais comuns o alumínio e o aço.

Como as empresas chinesas estão fabricando os fusos trapezoidais, sugiro que você compre esse tipo de produto em vez do conhecido parafuso de porca. Isso se deve ao preço mais atraente e ao arrasto, que considero horrível.

Na foto coloquei o melhor fuso que tem, na minha opinião, que é o fuso de esferas recirculantes. Geralmente é feito de um aço muito duro, e as bolas giram em torno dele, dentro da castanha. Além da precisão que é ótima, destaco também a durabilidade, já que esse tipo de fuso pode reproduzir bilhões de movimentos sem danificar o mecanismo. Uma opção mais barata, que é a que usamos aqui, é o fuso trapezoidal.

Etapa 3: Sobre fusos - roscas simples e esféricas

Os fusos das bolas, na foto à esquerda, possuem canais semicirculares por onde as bolas rolam. Eles são relativamente mais caros e têm baixo atrito em comparação com fusos de parafuso único, levando a um rendimento muito maior (atrito de rolamento).

Os fusos monoroscados do lado direito da imagem costumam ter perfis trapezoidais, já que essa geometria é mais adequada para aplicar forças no sentido axial e transmissão suave do movimento. Eles são relativamente baratos e têm alto atrito em comparação com fusos de esferas recirculantes, levando a um baixo rendimento, ou seja, atrito de deslizamento.

Etapa 4: Sobre eixos - aplicativos

Os fusos podem ser aplicados a qualquer mecanismo onde o movimento linear é necessário. São amplamente utilizados na indústria de máquinas e processos.

Alguns aplicativos incluem:

• Elevadores de carga
• Prensas
• Morangos e tornos
• Equipamento CNC
• Máquinas de embrulhar
• Impressoras 3D
• Equipamento de corte e corte a laser
• Processo industrial
• Sistemas de posicionamento e movimento linear

Etapa 5: Sobre eixos - parâmetros

Existem várias características de um fuso que devem ser levadas em consideração ao projetar um mecanismo. Além de seu diâmetro e passo, é necessário reconhecer sua resistência à compressão, seu momento de inércia (resistência à mudança em seu estado rotacional), material construtivo, a velocidade de rotação a que será submetido, sentido de operação (horizontal ou vertical), a carga aplicada, entre outras.

Mas, com base em mecanismos já construídos, podemos intuir vários desses parâmetros.

Vamos reconhecer algum bem comum. Vamos começar com o STEP.

Etapa 6: Sobre fusos - Etapa (deslocamento e velocidade)

Determina o comprimento percorrido pela porca em cada revolução. Geralmente é em mm / revolução.

Um fuso de 2 mm por rotação causará um deslocamento de 2 mm a cada volta que o fuso realizar. Influenciará a velocidade linear da porca, pois com o aumento da velocidade de rotação, aumentará o número de rotações por unidade de tempo e consequentemente a distância percorrida também.

Se um giro de 2 mm por revolução girar a 60 RPM (uma revolução por segundo), a porca se moverá a 2 mm por segundo.

Etapa 7: Montagem

Na nossa montagem tenho dois motores e o nosso teclado com o display, que parecia uma calculadora, pois fiz uma capa para eles na impressora 3D. Na tela do Nokia, temos as seguintes opções:

F1: Crescente - Fuso vai da posição atual para a posição que eu determinar

F2: Descendente - Virar

F3: Velocidade - Posso alterar a largura de pulso

F4: ESC

Etapa 8: Montagem - Materiais

A - Guias lineares de 10 mm

B - Fusos trapezoidais das etapas 2 e 8 mm

C - Base de Perfuração

D - Rolamentos para fusos

E - Porta-guias

F - Castanhas

G - Rolamentos

H - Acoplamentos

I - motores

J - Várias peças de plástico (cursores, suportes do motor, cunhas, suporte de teclado e tela

Etapa 9: Montagem - Etapa 01

Após a perfuração da base (C), montamos os dois motores (I). Para fixá-los, utilizamos suportes confeccionados na impressora 3D (J). Não aperte nenhum dos parafusos nesta etapa de posicionamento. Isso permitirá os ajustes necessários na etapa de alinhamento.

Etapa 10: Montagem - Etapa 02

Ainda seguindo a perfuração da base (C), posicione os trilhos guia (E) e os mancais (D). Detalhe do calço plástico (J) para ajuste das alturas dos mancais.

Etapa 11: Montagem - Etapa 03

Criamos um cursor usando uma peça impressa para conectar o rolamento (G) à porca (F). Usamos dois cursores, um direito e outro esquerdo. Sua função é indicar a posição em uma escala sempre que quisermos determinar o deslocamento causado pelo spindle.

Etapa 12: Montagem - Etapa 04

Insira a guia (A) e o fuso (B) em seus respectivos mancais (D) e suporte (E), em frente ao motor, a seguir insira a guia e o fuso no mancal (G) e castanha (F) e no ponta do fuso também inserimos o acoplador (H). Levamos os dois até que atinjam seus pontos finais (apoio oposto e motor).

Aperte levemente os parafusos para permitir um ajuste posterior. Repita o procedimento usando a guia e o eixo restantes. Com todos os componentes posicionados, realizamos o alinhamento das peças, finalizando a etapa de montagem mecânica.

Etapa 13: Montagem - Eletrônica

Usando um suporte de plástico impresso, fixamos a tela do Nokia 5110 e um teclado de matriz 4x4. No espaço inferior do estande ficará o Arduino Uno, o motorista DRV8825.

Utilizando a furação disponível na base, fixamos a montagem.

Etapa 14: Esquema Elétrico

O diagrama de fiação é simples. Temos o DRV8825 e os mesmos dois espelhos de 17, ou seja, a mesma etapa que mandamos de um vai para o outro. O que muda é que em um dos motores tenho um fuso de 8 mm e no outro um fuso de 2 mm. Óbvio, então, que o primeiro, com fuso de 8 mm, anda mais rápido. Ainda no diagrama estão o display e o teclado 4x4, que tem que ser matricial.

Etapa 15: Código Fonte

Inclusão de bibliotecas e criação de objetos

Temos aqui um Lib que fiz, que é StepDriver.h. Está preparado para os drivers 8825, 4988 e também TB6600. Crio nesta etapa o objeto DRV8825, o d1.

// Biblioteca responsável por capturar a tecla que foi pressionada no teclado # incluir // Biblioteca responsável pelos graficos do display # incluir // Biblioteca responsável pela comunicacao do display # incluir // Configuração de pinos do Display // pino 6 - Serial clock out (SCLK) // pino 5 - Saída de dados serial (DIN) // pino 4 - Seleção de dados / comando (D / C) // pino 3 - seleção de chip LCD (CS / CE) // pino 2 - reinicialização do LCD (RST) Exibição de Adafruit_PCD8544 = Adafruit_PCD8544 (6, 5, 4, 3, 2); // Biblioteca de motor de passo #include // Instancia o driver DRV8825 DRV8825 d1;

Constantes e variáveis globais

Nesta parte do código eu trato da matriz, que ensinei em outra vídeo aula (LINK KEYBOARD). Ainda assim, estou falando do objeto Keypad, além de distância e velocidade.

byte const LINHAS = 4; // número de linhas do tecladoconst byte COLUNAS = 4; // número de colunas do teclado // define uma matriz com os símbolos que deseja ser lido do teclado char SIMBOLOS [LINHAS] [COLUNAS] = {{'A', '1', '2', '3'}, { 'B', '4', '5', '6'}, {'C', '7', '8', '9'}, {'D', 'c', '0', 'e '}}; byte PINOS_LINHA [LINHAS] = {A2, A3, A4, A5}; // pinos que indicam as linhas do teclado byte PINOS_COLUNA [COLUNAS] = {0, 1, A0, A1}; // pinos que indicam as colunas do teclado // Instância de Teclado, responsável por capturar a tecla pressionada Teclado customKeypad = Teclado (makeKeymap (SIMBOLOS), PINOS_LINHA, PINOS_COLUNA, LINHAS, COLUNAS); // variáveis resposnsáveis por armazenar o valor digitado char customKey; distancia longa sem sinal = 0; velocidade longa sem sinal = 2000;

Função de leitura de teclado

Nesta etapa temos o código referente ao display, que trabalha a impressão crescente e decrescente.

// Funcao responsavel por ler o valor do usuario pelo teclado -------------------------------------- --- unsigned long lerValor () {// Escreve o submenu que coleta os valores no display display.clearDisplay (); display.fillRect (0, 0, 84, 11, 2); display.setCursor (27, 2); display.setTextColor (WHITE); display.print ("VALOR"); display.setTextColor (BLACK); display.fillRect (0, 24, 21, 11, 2); display.setCursor (2, 26); display.setTextColor (WHITE); display.print ("CLR"); display.setTextColor (BLACK); display.setCursor (23, 26); display.print ("LIMPAR"); display.fillRect (0, 36, 21, 11, 2); display.setCursor (5, 38); display.setTextColor (WHITE); display.print ("F4"); display.setTextColor (BLACK); display.setCursor (23, 38); display.print ("VOLTAR"); display.setCursor (2, 14); display.display (); String valor = ""; char tecla = false;

looping esperando a tecla pressionada

Aqui explicamos a programação de Loop, ou seja, onde você insere os valores.

// Loop infinito enquanto nao chamar o return while (1) {tecla = customKeypad.getKey (); if (tecla) {switch (tecla) {// Se teclas de 0 a 9 primeiras pressionadas case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '0': valor + = tecla; display.print (tecla); display.display (); pausa; // Se a tecla CLR foi pressionada case 'c': // Limpa a string valor valor = ""; // Apaga o valor do display display.fillRect (2, 14, 84, 8, 0); display.setCursor (2, 14); display.display (); pausa; // Se a tecla ENT foi pressionada case 'e': // Retorna o valor return valor.toInt (); pausa; // Se a tecla F4 (ESC) for pressionada case 'D': return -1; padrão: break; }} // Limpa o char tecla tecla = false; }}

Função de acionamento do motor

A função "mover" é trabalhada nesta etapa. Pego o número de pulsos e a direção e faço um "para".

// Funcao responsavel por mover o motor -------------------------------------- void mover (unsigned pulsos longos, bool direção) {para (sem sinal longo i = 0; i <pulsos; i ++) {d1.motorMove (direção); }}

configurar ()

Agora movo a tela e a configuração do driver e até coloco a fixação dentro do código-fonte para facilitar. Eu inicializo certos valores e lido com os métodos que geram as configurações.

void setup () {// Configuração do display ---------------------------------------- -------- display.begin (); display.setContrast (50); display.clearDisplay (); display.setTextSize (1); display.setTextColor (BLACK); // Configuração do Driver DRV8825 ----------------------------------------- // pin GND - Habilitar (ENA) // pino 13 - M0 // pino 12 - M1 // pino 11 - M2 // pino 10 - Reinicializar (RST) // pino 9 - Suspensão (SLP) // pino 8 - Etapa (STP) // pino 7 - Direção (DIR) d1.pinConfig (99, 13, 12, 11, 10, 9, 8, 7); d1.sono (BAIXO); d1.reset (); d1.stepPerMm (100); d1.stepPerRound (200); d1.stepConfig (1); d1.motionConfig (50, velocidade, 5000); }

loop () - 1ª parte - Menu de desenho

void loop () {// Escreve o Menu do Programa no display ----------------------------------- display.clearDisplay (); display.fillRect (0, 0, 15, 11, 2); display.setCursor (2, 2); display.setTextColor (WHITE); display.print ("F1"); display.setTextColor (BLACK); display.setCursor (17, 2); display.print ("CRESCENTE"); display.fillRect (0, 12, 15, 11, 2); display.setCursor (2, 14); display.setTextColor (WHITE); display.print ("F2"); display.setTextColor (BLACK); display.setCursor (17, 14); display.print ("DECRESCENTE"); display.fillRect (0, 24, 15, 11, 2); display.setCursor (2, 26); display.setTextColor (WHITE); display.print ("F3"); display.setTextColor (BLACK); display.setCursor (17, 26); display.print ("VELOCIDADE");

loop () - Parte 2 - Menu de desenho

display.fillRect (0, 36, 15, 11, 2); display.setCursor (2, 38); display.setTextColor (WHITE); display.print ("F4"); display.setTextColor (BLACK); display.setCursor (17, 38); display.print ("ESC"); display.display (); bool esc = falso;

loop () - Parte 3 - Executando

// Loop enquanto a tecla F4 (ESC) nao for pressionada while (! Esc) {// captura a tecla pressionada do teclado customKey = customKeypad.getKey (); // caso alguma tecla foi pressionada if (customKey) {// Trata de uma tecla apertada switch (customKey) {// Se tecla F1 foi pressionada case 'A': distancia = lerValor (); // Se a tecla ESC foi pressionada if (distancia == -1) {esc = true; } else {// Escreve a tela "Movendo" no display display.clearDisplay (); display.fillRect (0, 0, 84, 11, 2); display.setCursor (21, 2); display.setTextColor (WHITE); display.print ("MOVENDO"); display.setTextColor (BLACK); display.setCursor (2, 14); display.print (distancia); display.print ("Passos"); display.display ();

loop () - Parte 4 - Executando

// Move o motor mover (distancia, LOW); // Volta ao menu esc = true; } pausa; // Se a tecla F2 foi pressionada caso 'B': distancia = lerValor (); // Se a tecla ESC foi pressionada if (distancia == -1) {esc = true; } else {// Escreve a tela "Movendo" no display display.clearDisplay (); display.fillRect (0, 0, 84, 11, 2); display.setCursor (21, 2); display.setTextColor (WHITE); display.print ("MOVENDO"); display.setTextColor (BLACK); display.setCursor (2, 14); display.print (distancia); display.print ("Passos"); display.display ();

loop () - Parte 5 - Executando

// Move o motor mover (distancia, HIGH); // Volta ao menu esc = true; } pausa; // Se a tecla F3 foi pressionada caso 'C': velocidade = lerValor (); se (velocidade == -1) {esc = verdadeiro; } else {// Escreve a tela "Velocidade" no display display.clearDisplay (); display.fillRect (0, 0, 84, 11, 2); display.setCursor (12, 2); display.setTextColor (WHITE); display.print ("VELOCIDADE"); display.setTextColor (BLACK); display.setCursor (2, 14); display.print (velocidade); display.print (char (229)); display.print ("s");

loop () - Parte 6 - Executando

display.fillRect (31, 24, 21, 11, 2); display.setCursor (33, 26); display.setTextColor (WHITE); display.println ("OK!"); display.setTextColor (BLACK); display.display (); // Configura nova velocidade ao motor d1.motionConfig (50, velocidade, 5000); atraso (2000); // Volta ao menu esc = true; } pausa; // Se a tecla F4 (ESC) foi pressionada no caso 'D': // Se a tecla CLR foi pressionada no caso 'c': // Se a tecla ENT foi pressionada no caso 'e': // Volta ao menu esc = true; padrão: break; }} // Limpa o char customKey customKey = false; }}

Etapa 16: Sobre eixos - configurações de máquina

Em máquinas CNC, como impressoras e roteadores 3D, por exemplo, o programa responsável pelo controle de posicionamento precisa saber como os movimentos ocorrerão em função da quantidade de pulsos dados ao motor de passo.

Se o acionador do motor de passo permite a aplicação de microetapas, esta configuração deve ser levada em consideração no cálculo do deslocamento produzido.

Por exemplo, se um motor de 200 passos por revolução estiver conectado a um driver definido como 1/16, então 16 x 200 pulsos serão necessários para uma única revolução do fuso, ou seja, 3.200 pulsos para cada revolução. Se este fuso tiver um passo de 2 mm por revolução, serão necessários 3.200 pulsos no acionador para que a porca se mova 2 mm.

Na verdade, os controladores de software costumam usar um motivo para especificar essa relação, o "número de pulsos por milímetro" ou "passos / mm".

Etapa 17: Marlin

No Marlin, por exemplo, vemos na seção @section motion:

/ **

* Etapas do eixo padrão por unidade (etapas / mm)

* Substituir com M92

* X, Y, Z, E0 [, E1 [, E2 [, E3 [, E4]

* /

#define DEFAULT_AXIS_STEPS_PER_UNIT {80, 80, 3200, 100}

Neste exemplo, podemos concluir que os eixos X e Y têm uma precisão de 80 pulsos para mover 1 mm, enquanto o Z precisa de 3.200 pulsos e a extrusora E0 precisa de 100.

Etapa 18: GRBL

Abaixo, vemos os comandos de configuração do GRBL. Com o comando $ 100, podemos ajustar o número de pulsos necessários para causar um deslocamento de um milímetro no eixo X.

No exemplo abaixo, podemos ver que o valor atual é 250 pulsos por mm.

Os eixos Y e Z podem ser definidos respectivamente $ 101 e $ 102.