Arduino Uno con motore mandrino e passo: 19 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Oggi parleremo di un argomento molto importante in meccanica e meccatronica: gli elementi delle macchine. In questo articolo ci occuperemo nello specifico dei mandrini, caratterizzati da alcune interessanti caratteristiche e applicazioni. Tuttavia, dimostreremo alcuni modi per calcolare il movimento causato da un mandrino e presentare un assemblaggio di prova.

Ho fatto il montaggio qui sotto, quindi, che espone l'anticipo di un mandrino di 2mm e di un altro di 8mm. Questi mandrini TR8 che sto usando sono comunemente usati in piccoli router e stampanti 3D, specialmente sull'asse Z. Ricordando che padroneggiando alcuni concetti su cui lavoreremo qui, sarai in grado di progettare qualsiasi tipo di macchina.

Passaggio 1: risorse utilizzate

• Mandrino trapezoidale da 8 mm di diametro e passo 2 mm
• Mandrino trapezoidale di 8 mm di diametro e 8 mm di passo
• 8x2 mandrino flangiato castagno
• 8x8 mandrino flangiato castagno
• Cuscinetti per mandrini diametro 8mm
• Guida cilindrica lineare 10mm di diametro
• Cuscinetti a rulli cilindrici per guide da 10 mm
• Staffe per guide cilindriche da 10mm
• Motori NEMA 17
• Giunti per alberi
• Arduino Uno
• Autista DRV8825
• Tastiera a matrice 4x4
• Visualizza Nokia 5110
• Varie parti in plastica
• Bulloni e dadi
• Base in legno
• Alimentazione esterna 12V

Passaggio 2: informazioni sui mandrini: cosa sono?

I mandrini sono elementi di macchine, come le viti. Cioè, sono barre diritte formate da fili di passaggi continui. Sono utilizzati in meccanismi che richiedono movimento e posizionamento lineari. Possono esercitare elevate forze di trazione e compressione e trasmettere la coppia. Consentono la movimentazione con bloccaggio automatico. Possono essere costruiti con diversi materiali, essendo i più comuni alluminio e acciaio.

Poiché le aziende cinesi producono mandrini trapezoidali, suggerirei di acquistare questo tipo di prodotto invece del noto bullone dado. Ciò è dovuto al prezzo più interessante e alla resistenza, che considero orribile.

Nella foto metto il miglior mandrino che ha, secondo me, cioè il mandrino a ricircolo di sfere. Di solito è fatto di un acciaio molto duro, e le sfere ruotano intorno ad esso, all'interno del castagno. Oltre alla precisione che è grande, sottolineo anche la durata, poiché questo tipo di mandrino può riprodurre miliardi di movimenti senza danneggiare il meccanismo. Un'opzione più economica, che è quella che usiamo qui, è il mandrino trapezoidale.

Passaggio 3: informazioni sui mandrini: filettature singole e sferiche

I perni a sfera, nella foto a sinistra, hanno canali semicircolari dove rotolano le sfere. Sono relativamente più costosi e hanno un basso attrito rispetto ai mandrini monovite, portando ad un rendimento molto più elevato (attrito volvente).

I mandrini a filettatura singola sul lato destro dell'immagine di solito hanno profili trapezoidali, poiché questa geometria è più appropriata per applicare forze nella direzione assiale e una trasmissione regolare del movimento. Sono relativamente economici e hanno un elevato attrito rispetto ai mandrini a ricircolo di sfere, portando ad un basso rendimento, cioè attrito di scorrimento.

Passaggio 4: Informazioni sui mandrini - Applicazioni

I mandrini possono essere applicati a qualsiasi meccanismo in cui è richiesto un movimento lineare. Sono ampiamente utilizzati nell'industria in macchinari e processi.

Alcune applicazioni includono:

• Montacarichi
• presse
• Fragole e torni
• Attrezzature CNC
• Avvolgitrici
• Stampanti 3D
• Attrezzature per taglio e taglio laser
• Processi industriali
• Sistemi di posizionamento e movimento lineare

Passaggio 5: Informazioni sui mandrini - Parametri

Ci sono diverse caratteristiche di un mandrino che devono essere prese in considerazione quando si progetta un meccanismo. Oltre al diametro e al passo, è necessario riconoscerne la resistenza a compressione, il momento d'inerzia (resistenza al cambiamento del suo stato rotazionale), il materiale costruttivo, la velocità di rotazione a cui sarà sottoposto, il senso di marcia (orizzontale o verticale), il carico applicato, tra gli altri.

Ma, sulla base di meccanismi già costruiti, possiamo intuire molti di questi parametri.

Riconosciamo un bene comune. Cominciamo con STEP.

Passaggio 6: Informazioni sui mandrini - Passaggio (cilindrata e velocità)

Determina la lunghezza percorsa dal dado ad ogni giro. Di solito è in mm/giro.

Un mandrino di 2 mm per giro provoca uno spostamento di 2 mm ad ogni giro eseguito dal mandrino. Influirà sulla velocità lineare della chiocciola, poiché all'aumentare della velocità di rotazione aumenterà il numero di giri per unità di tempo e di conseguenza anche la distanza percorsa.

Se un giro di 2 mm per giro gira a 60 giri/min (un giro al secondo), il dado si muoverà a 2 mm al secondo.

Passaggio 7: assemblaggio

Nel nostro assemblaggio, ho due motori e la nostra tastiera con il display, che sembrava una calcolatrice, perché ho realizzato una copertura per loro nella stampante 3D. Sul display Nokia abbiamo le seguenti opzioni:

F1: Crescent - Fuso passa dalla posizione attuale alla posizione che determino

F2: Discendente - Virata

F3: Velocità - Posso cambiare l'ampiezza dell'impulso?

F4: ESC

Passaggio 8: montaggio - Materiali

A - Guide lineari da 10 mm

B - Mandrini trapezoidali passo 2 e 8mm

C - Base di perforazione

D - Cuscinetti per mandrini

E - Portaguide

F - Castagne

G - Cuscinetti

H - Giunti

I - Motori

J - Varie parti in plastica (cursori, staffe motore, cunei, supporto tastiera e display

Passaggio 9: assemblaggio - Passaggio 01

Dopo la foratura della base (C), montiamo i due motori (I). Per fissarli, utilizziamo staffe realizzate nella stampante 3D (J). Non serrare nessuna delle viti in questa fase di posizionamento. Ciò consentirà le regolazioni necessarie nella fase di allineamento.

Passaggio 10: assemblaggio - Passaggio 02

Sempre seguendo la foratura della base (C), posizionare le guide (E) e i cuscinetti (D). Particolare per lo spessore in plastica (J) utilizzato per regolare le altezze dei cuscinetti.

Passaggio 11: montaggio - Passaggio 03

Creiamo un cursore utilizzando una parte stampata per collegare il cuscinetto (G) al dado (F). Abbiamo usato due cursori, uno a destra l'altro a sinistra. La sua funzione è quella di indicare la posizione su una scala ogni volta che si vuole determinare lo spostamento causato dal mandrino.

Passaggio 12: assemblaggio - Passaggio 04

Inserire la guida (A) e l'alberino (B) nei rispettivi cuscinetti (D) e supporto (E), di fronte al motore, quindi inserire la guida e l'alberino nel cuscinetto (G) e castagno (F) e al punta del mandrino inseriamo anche l'accoppiatore (H). Li prendiamo entrambi fino a raggiungere i loro punti finali (supporto opposto e motore).

Stringere leggermente le viti per consentire una regolazione successiva. Ripetere la procedura utilizzando la guida e il mandrino rimanenti. Con tutti i componenti posizionati, eseguiamo l'allineamento delle parti, terminando la fase di assemblaggio meccanico.

Passaggio 13: montaggio - Elettronica

Utilizzando un supporto in plastica stampata, abbiamo fissato il display del Nokia 5110 e una tastiera a matrice 4x4. Nello spazio inferiore dello stand risiederà l'Arduino Uno, il driver DRV8825.

Utilizzando la foratura disponibile nella base, fissiamo l'assemblaggio.

Passaggio 14: schema elettrico

Lo schema elettrico è semplice. Abbiamo il DRV8825 e gli stessi due 17 mirror, cioè lo stesso passaggio che inviamo a uno va all'altro. Quello che cambia è che in uno dei motori ho un mandrino da 8 mm e nell'altro un mandrino da 2 mm. Ovvio, poi, che il primo, con perno da 8mm, va più veloce. Sempre nello schema ci sono il display e la tastiera 4x4, che deve essere a matrice.

Passaggio 15: codice sorgente

Inclusione di librerie e creazione di oggetti

Abbiamo qui un Lib che ho fatto, che è StepDriver.h. È predisposto per i driver 8825, 4988 e anche per i driver TB6600. Creo in questo passaggio l'oggetto DRV8825, il d1.

//Biblioteca responsável por capturar a tecla que foi pressionada no teclado#include //Biblioteca responsável pelos graficos do display #include //Biblioteca responsável pela comunicacao do display #include //Configuracao de pinos do Display // pin 6 - Serial clock out (SCLK) // pin 5 - Uscita dati seriale (DIN) // pin 4 - Selezione dati/comando (D/C) // pin 3 - Selezione chip LCD (CS/CE) // pin 2 - Reset LCD (RST) Visualizzazione Adafruit_PCD8544 = Adafruit_PCD8544(6, 5, 4, 3, 2); //Biblioteca de motor de passo #include //Instancia o driver DRV8825 DRV8825 d1;

Costanti e variabili globali

In questa parte del codice tratto la matrice, che ho insegnato in un'altra video lezione (LINK KEYBOARD). Tuttavia, sto parlando dell'oggetto Tastiera, oltre a distanza e velocità.

const byte 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 //instancia de Keypad, responsável por capturar a tecla pressionada Keypad customKeypad = Keypad(makeKeymap(SIMBOLOS), PINOS_LINHA, PINOS_COLUNA, LINHAS, COLUNAS); //variáveis resposnsáveis por armazenar o valor digitado char customKey; distanza lunga senza segno = 0; velocità lunga senza segno = 2000;

Funzione di lettura della tastiera

In questo passaggio abbiamo il codice riferito al display, che opera la stampa 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(BIANCO); display.print("VALORE"); display.setTextColor(BLACK); display.fillRect(0, 24, 21, 11, 2); display.setCursor(2, 26); display.setTextColor(BIANCO); 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(BIANCO); display.print("F4"); display.setTextColor(BLACK); display.setCursor(23, 38); display.print("VOLTAGGIO"); display.setCursor(2, 14); display.display(); Valore stringa = ""; char tecla = falso;

loop in attesa del tasto premuto

Qui spieghiamo la programmazione Loop, cioè dove si inseriscono i valori.

//Loop infinito enquanto nao chamar o return while (1) { tecla = customKeypad.getKey(); if (tecla) { switch (tecla) { //Se teclas de 0 a 9 forem 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(); rottura; //Se 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(); rottura; //Se tecla ENT foi pressionada case 'e': //Retorna o valor return valor.toInt(); rottura; //Se tecla F4 (ESC) foi pressionada case 'D': return -1; predefinito: pausa; } } //Limpa o char tecla tecla = false; } }

Funzione di azionamento del motore

In questo passaggio si lavora sulla funzione "sposta". Ottengo il numero di impulsi e la direzione e poi faccio un "per".

//Funcao responsavel por mover o motor-----------------------void mover(unsigned long pulsos, bool direcao) { for (unsigned long i = 0; i < pulsos; i++) { d1.motorMove(direcao); } }

impostare ()

Ora sposto il display e la configurazione del driver e inserisco persino il pinning all'interno del codice sorgente per renderlo più semplice. Inizializzo determinati valori e mi occupo dei metodi che generano le impostazioni.

void setup() { //Configuracao do display ---------------------------------------- -------- display.begin(); display.setContrast(50); display.clearDisplay(); display.setTextSize(1); display.setTextColor(BLACK); //Configurazione del driver DRV8825 ----------------------------------------- // pin GND - Enable (ENA) // pin 13 - M0 // pin 12 - M1 // pin 11 - M2 // pin 10 - Reset (RST) // pin 9 - Sleep (SLP) // pin 8 - Step (STP) // pin 7 - Direzione (DIR) d1.pinConfig(99, 13, 12, 11, 10, 9, 8, 7); d1.sleep(BASSO); d1.reset(); d1.passoPerMm(100); d1.stepPerRound(200); d1.stepConfig(1); d1.motionConfig(50, velocità, 5000); }

loop() - prima parte - Menu disegno

void loop() { //Escreve o Menu do Programa no display ----------------------------------- display.clearDisplay(); display.fillRect(0, 0, 15, 11, 2); display.setCursor(2, 2); display.setTextColor(BIANCO); display.print("F1"); display.setTextColor(BLACK); display.setCursor(17, 2); display.print("CRESCE"); display.fillRect(0, 12, 15, 11, 2); display.setCursor(2, 14); display.setTextColor(BIANCO); 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(BIANCO); display.print("F3"); display.setTextColor(BLACK); display.setCursor(17, 26); display.print("VELOCITA'");

loop() - Parte 2 - Menu disegno

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

loop() - Parte 3 - Correre

//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 a tecla apertada switch (customKey) { //Se tecla F1 foi pressionada case 'A': distancia = lerValor(); //Se tecla ESC foi pressionada if (distanza == -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(BIANCO); display.print("MOVENDO"); display.setTextColor(BLACK); display.setCursor(2, 14); display.print(distanza); display.print(" Passos"); display.display();

loop() - Parte 4 - Correre

//Sposta sul motore del motore (distanza, LOW); //Volta il menu esc = true; } rottura; //Se tecla F2 foi pressionada case 'B': distancia = lerValor(); //Se tecla ESC foi pressionada if (distanza == -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(BIANCO); display.print("MOVENDO"); display.setTextColor(BLACK); display.setCursor(2, 14); display.print(distanza); display.print(" Passos"); display.display();

loop () - Parte 5 - Correre

//Sposta sul motore del motore (distanza, HIGH); //Volta il menu esc = true; } rottura; //Se tecla F3 foi pressionada case 'C': velocidade = lerValor(); if (velocidade == -1) { esc = vero; } else { //Escreve a tela "Velocidade" no display display.clearDisplay(); display.fillRect(0, 0, 84, 11, 2); display.setCursor(12, 2); display.setTextColor(BIANCO); display.print("VELOCITA'"); display.setTextColor(BLACK); display.setCursor(2, 14); display.print(velocidade); display.print(char(229)); display.print("s");

loop () - Parte 6 - Correre

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

Passaggio 16: Informazioni sui mandrini - Configurazioni della macchina

Nelle macchine CNC come stampanti 3D e router ad esempio, il programma responsabile del controllo del posizionamento deve sapere come avverranno i movimenti in funzione del numero di impulsi dati al motore passo-passo.

Se il driver del motore passo-passo consente l'applicazione di micropassi, questa configurazione deve essere presa in considerazione nel calcolo dello spostamento prodotto.

Ad esempio, se un motore a 200 passi per giro è collegato a un driver impostato su 1/16, saranno necessari 16 x 200 impulsi per un singolo giro del mandrino, ovvero 3200 impulsi per ogni giro. Se questo mandrino ha un passo di 2 mm per giro, ci vorranno 3200 impulsi nel driver affinché il dado si muova di 2 mm.

In effetti, i controller software usano spesso un motivo per specificare questo rapporto, il "numero di impulsi per millimetro" o "passi/mm".

Passaggio 17: Marlin

In Marlin, ad esempio, vediamo nella sezione @section motion:

/ **

* Passi asse predefiniti per unità (passi/mm)

* Override con M92

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

* /

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

In questo esempio, possiamo concludere che gli assi X e Y hanno una precisione di 80 impulsi per spostarsi di 1 mm, mentre lo Z ha bisogno di 3200 impulsi e l'estrusore E0 ha bisogno di 100.

Passaggio 18: GRBL

Di seguito vediamo i comandi di configurazione di GRBL. Con il comando $ 100, possiamo regolare il numero di impulsi necessari per provocare un offset di un millimetro sull'asse X.

Nell'esempio sotto possiamo vedere che il valore corrente è 250 impulsi per mm.

Gli assi Y e Z possono essere impostati rispettivamente $ 101 e $ 102.