Passi per millimetro: cinghie, viti, risoluzione

Un numero, una formula

Un driver per motori passo-passo conta gli impulsi. La macchina si muove in millimetri. Il numero che li converte è il numero di passi per millimetro e ogni altra calibrazione della macchina dipende dal fatto che sia corretto.

La formula non cambia mai:

steps/mm = (full steps per revolution × microstepping) ÷ travel per revolution

Il numeratore è fissato dal motore e dal driver: un motore da 1.8° con stepping a 1/16 dà sempre 200 × 16 = 3200 microstep per giro. Il denominatore è l’unica parte che dipende dalla macchina ed è una domanda di meccanica: quanto si muove l’asse quando l’albero compie un giro?

Cinghie

Per una cinghia dentata, la corsa per giro è semplicemente il numero di denti della puleggia moltiplicato per il passo della cinghia. La cinghia GT2 ha un passo di 2 mm e una puleggia a 20 denti è quella predefinita su quasi ogni macchina hobbistica:

travel  = 20 teeth × 2 mm = 40 mm per revolution
steps/mm = (200 × 16) ÷ 40 = 80

Ecco i 80 passi/mm presenti nella configurazione X e Y di ogni stampante 3D. Non è una costante magica: è una GT2 a 20 denti con stepping a 1/16 e, se monti una puleggia a 16 denti, diventa 100.

Nota che la riga a 30 denti non divide esattamente. 53.333… passi/mm è perfettamente ammesso: il firmware lo memorizza come float e accumula passi frazionari, ma significa che nessuna posizione si trova mai esattamente su un confine di passo, motivo di peso per cui si usano i numeri di denti scelti da tutti gli altri.

Viti trapananti

Per una vite, la corsa per giro è l’avanzamento, che non coincide con il passo. Questo è l’errore più comune dell’intero argomento.

• Il passo è la distanza tra filetti adiacenti.
• L’avanzamento è quanto il dado percorre in un giro.
• Avanzamento = passo × numero di partenze.

Una vite a singola partenza ha un avanzamento pari al passo. Ma la diffusissima vite «T8» ha passo di 2 mm e quattro eliche di filettatura separate avvolte l’una accanto all’altra, quindi un giro fa avanzare il dado di quattro filetti:

lead     = 2 mm pitch × 4 starts = 8 mm per revolution
steps/mm = (200 × 16) ÷ 8 = 400

Ecco l’altro numero che hai visto. Se misuri la spaziatura dei filetti di una T8 con un calibro, ottieni 2 mm, calcoli 1600 passi/mm e ogni movimento risulta quattro volte troppo corto. Conta le partenze di filettatura all’estremità della vite: le quattro eliche separate sono visibili. Oppure ruotala di un giro completo contro un righello.

Scegliere tra i due

La risoluzione non è gratis. Una vite con risoluzione dieci volte superiore a quella di una cinghia richiede anche dieci volte più impulsi per la stessa distanza; quindi, a frequenza massima di passo fissa, è dieci volte più lenta. Questo è il compromesso, ed è netto:

Ecco esattamente perché una stampante 3D usa cinghie per X e Y e una vite per Z. X e Y si muovono in fretta e trasportano quasi nulla. Z si muove lentamente, trasporta il peso del piano o del portale e non deve cedere quando l’alimentazione viene spenta; inoltre, il piccolo angolo di elica di una T8 la rende autobloccante, quindi non arretra sotto carico.

Anche il valore di 40 000 passi/s in quella tabella è un limite reale, non teorico. Un Arduino Uno che genera i passi tramite bit-banging si ferma intorno a 10 000–15 000 al secondo prima che il ciclo non riesca più a stare al passo, il che su una T8 con stepping a 1/16 corrisponde a circa 30 mm/s. Se un asse con vite deve muoversi più in fretta, le risposte sono meno microstep, una scheda più veloce o un timer hardware, non un motore più grande.

Coppia e ciò che la tabella non dice

Cambiare meccanismo modifica il carico visto dal motore, non solo la velocità. Una vite trapanante moltiplica la forza per circa 2π × radius ÷ lead, quindi una T8 trasforma una coppia motore modesta in una notevole forza assiale: è il motivo per cui un asse Z con un motore piccolo può sollevare un piano pesante.

La cinghia fa il contrario. Una puleggia GT2 a 20 denti ha un diametro primitivo di 12.7 mm, quindi la tensione della cinghia è la coppia del motore divisa per 6.4 mm. Un motore che eroga 0.3 N·m produce circa 47 N sulla cinghia, e questo è tutto ciò che ottieni. Se l’asse X perde passi quando incontra qualcosa, il motivo è proprio questo calcolo.

Anche l’inerzia riflessa cambia, nella stessa direzione: più fine è il meccanismo, meno la massa del carrello conta per il motore. È parte del motivo per cui un asse con vite tollera accelerazioni aggressive che un asse con cinghia non tollera. Puoi vedere l’effetto direttamente nel simulatore di motori passo-passo: passa dal meccanismo con cinghia alla vite trapanante tenendo costanti tutti gli altri parametri e osserva che cosa accade all’angolo di ritardo.

Calibra, non fidarti

Il numero calcolato è un punto di partenza, non una risposta. Le cinghie si allungano, le puleggie hanno tolleranze di fabbricazione e le viti sono vendute con descrizioni ottimistiche. Misura:

1. Contrassegna il carrello rispetto a un riferimento fisso: una striscia di nastro e una linea netta tracciata con una matita affilata.
2. Comanda una corsa lunga, 100 mm e non 10 mm. L’errore è una percentuale, quindi una corsa più lunga lo misura con maggiore precisione.
3. Misura ciò che è realmente accaduto con un calibro o un righello di acciaio.
4. Correggi con un rapporto:

new steps/mm = old steps/mm × (commanded ÷ measured)

Comandi 100 mm, ne misuri 98.4 mm e il valore attuale è 80: 80 × 100 ÷ 98.4 = 81.3 steps/mm.

Poi ripeti la misurazione per confermare. Una singola correzione che non converge indica che l’errore non è di scala, e la differenza è diagnostica:

Le ultime due righe intercettano quasi tutti i primi montaggi, ed entrambe dipendono dall’aritmetica, non dalla meccanica.

Assi rotativi: passi per grado

Non tutti gli assi sono lineari. Un tavolo rotante, un estrusore di filamento, l’asse di panoramica di un carrello per telecamere e un giunto robotico pongono la stessa domanda con un denominatore diverso e, per un asse rotativo, il denominatore è di solito un rapporto di riduzione anziché un meccanismo:

steps/degree = (full steps × microstepping × gear ratio) ÷ 360

Un motore da 1.8° a 1/16 con riduzione 5:1 dà (200 × 16 × 5) ÷ 360 = 44.4 steps per degree, pari a una risoluzione di 0.0225°. Vale la pena notare che si tratta dello stesso calcolo di una cinghia, con 360 gradi al posto dei millimetri per giro.

L’estrusore di una stampante 3D è l’eccezione, perché è indicato in passi per millimetro di filamento pur essendo una trasmissione rotativa. Il denominatore è la circonferenza effettiva dell’ingranaggio fresato, non il suo diametro nominale: i denti mordono il filamento, quindi il raggio di presa reale è minore di quello stampato sul componente. Ecco perché nessuno calcola gli E-step e tutti li misurano:

1. Contrassegna il filamento a 120 mm sopra l’ingresso dell’estrusore.
2. Estrudi esattamente 100 mm.
3. Misura di nuovo dall’ingresso al segno. Se leggi 27 mm, hai estruso 93 mm, non 100.
4. new = old × 100 ÷ 93. Con 93 passi/mm, ottieni 100 passi/mm.

Il punto di partenza a 120 mm è deliberato: lascia abbastanza filamento perché il segno non raggiunga mai l’ingresso, anche in caso di forte sovraestrusione.

Passi per millimetro non interi

Dopo la calibrazione, il numero smette di essere tondo: 80 diventa 81.3 e una corsa di 10 mm diventa 813.0 passi. Il firmware gestisce correttamente questo caso, ma il codice scritto a mano di solito no, perché l’implementazione ovvia scarta la frazione a ogni movimento:

// Wrong: truncates on every call. Two hundred 0.1 mm moves land 1.4 mm short.
long stepsFor(float mm) { return (long)(mm * stepsPerMm); }

A 81.3 passi/mm, un movimento di 0.1 mm equivale a 8.13 passi, troncati a 8. Lo 0.13 viene scartato e viene scartato di nuovo al movimento successivo, e a quello dopo ancora. Su centinaia di segmenti brevi, esattamente ciò che compone una curva o un pattern di riempimento, l’errore si accumula fino a diventare visibile.

La correzione consiste nel conservare il resto anziché la posizione:

// Right: carry the fraction forward, so the error never accumulates past one step.
float carry = 0;

long stepsFor(float mm) {
  float exact = mm * stepsPerMm + carry;
  long whole = lround(exact);
  carry = exact - whole;        // always within half a step
  return whole;
}

Ora l’errore massimo in qualsiasi istante è di mezzo passo, 0.006 mm su questo asse, e non cresce. È lo stesso trucco usato dalla rasterizzazione di linee di Bresenham e il motivo per cui il firmware registra la posizione in passi anziché in millimetri: un conteggio intero di passi non può derivare, mentre una posizione float in millimetri può.

Nel firmware

Sia Marlin sia GRBL conservano il numero come parametro impostabile, quindi raramente devi ricompilare:

; Marlin — X, Y, Z, E
M92 X80 Y80 Z400 E93
M500          ; save to EEPROM

; GRBL
$100=80       ; X steps/mm
$101=80       ; Y
$102=400      ; Z

Annota il valore impostato. La versione più frustrante di questo problema è una macchina calibrata correttamente una volta, riflashata e poi tornata silenziosamente ai valori predefiniti del firmware.

Prossimi passi

Il numero precedente indica alla macchina quanto si è spostata. Non dice nulla su dove abbia iniziato e una macchina a controllo aperto non può saperlo all’accensione. A questo serve il riposizionamento rispetto a un finecorsa.