Simulatore motore passo-passo: perdita di passi e ritardo

Controlli

Il laboratorio riesegue l’intero movimento a ogni ingresso, così le tracce seguono il cursore mentre lo trascini invece di aspettare la pressione di Start. Non c’è nulla da avviare: il movimento è composto da 30 000 passi di integrazione e finisce prima che tu possa muovere di nuovo il dito.

Il grafico superiore è la posizione: la linea tratteggiata indica dove il driver crede che sia l’asse, quella continua dove si trova realmente il rotore. Il grafico inferiore è l’angolo di ritardo tra loro, con la fascia stabile ±90° evidenziata.

Teoria

Un motore passo-passo non compie passi. Il driver ruota un campo magnetico a incrementi e il rotore lo segue sempre con un certo ritardo; la coppia prodotta è il seno di quell’angolo:

T = T_peak(ω) × sin(δ)

δ è misurato in gradi elettrici. Un motore da 1.8° ha 50 denti del rotore, quindi le sue magnetizzazioni si ripetono 50 volte per rivoluzione e un passo completo corrisponde esattamente a 90 gradi elettrici. Questa conversione è l’unico calcolo dell’intero argomento.

Tra −90° e +90° il motore è una molla: più resta indietro, più viene tirato con forza. Quella regione stabile è il motivo per cui un motore passo-passo a loop aperto funziona, ed è dove deve restare qualsiasi carico stabile. Oltre 90° il seno si inverte, quindi restare ancora più indietro produce meno coppia restauratrice e il rotore si allontana ulteriormente; a 180° la coppia si inverte del tutto e inizia a tirare verso il polo successivo. Il rotore scivola al dente stabile successivo, a un ciclo elettrico, cioè quattro passi completi, di distanza.

Sono due numeri diversi e il laboratorio li tiene separati. 90° è il punto in cui termina l’equilibrio; un breve superamento è sopravvivibile, ed è per questo che un comando a passo completo, un calcio di 90° a ogni passo, non distrugge la macchina. 180° è il punto senza ritorno.

Tre fattori fanno crescere l’angolo di ritardo:

• Carico. A velocità costante sin(δ) = demanded ÷ available. Un carico pari alla metà della coppia disponibile si trova a 30°, lasciando 60° di margine.
• Accelerazione. Avviare il rotore consuma coppia dallo stesso bilancio, quindi il ritardo è peggiore in rampa, non alla velocità finale.
• Velocità, perché T_peak diminuisce quando il motore gira più rapidamente.

L’ultimo è il meno ovvio. Un avvolgimento è un induttore e, più rapidamente gira il motore, più difficile diventa imporre e poi far uscire la corrente: la reattanza aumenta con la frequenza elettrica e la forza controelettromotrice del rotore in rotazione consuma la tensione di alimentazione. Il risultato è una curva di coppia piatta fino alla velocità limite in curva e decrescente oltre, e la velocità limite in curva è determinata dalla tensione di alimentazione.

Da qui nascono le due regole che il laboratorio esiste per rendere ovvie: più ampere significano più coppia, più volt significano più velocità.

Algoritmo

Il rotore viene integrato direttamente. Nulla in questo codice rileva, inserisce o conosce la perdita di passi: essa emerge dalla legge sinusoidale.

// per 20 us tick
const ideal    = sampleProfile(plan, time).position;         // mm the planner wants
const command  = Math.round(ideal * stepsPerMm) / stepsPerMm; // the driver only does whole microsteps
const lag      = rotorTeeth * (commandAngle - theta);         // electrical radians

const { torque } = peakTorque(setup, omega);                  // falls with speed
const friction   = loadTorque * Math.tanh(omega / 0.5);       // smooth Coulomb, one line
const accel      = (torque * Math.sin(lag) - friction - damping * omega) / inertia;

theta += omega * dt + 0.5 * accel * dt * dt;
omega += accel * dt;

Due dettagli contano più di quanto sembrino.

Il comando viene quantizzato sulla griglia del microstep prima che il rotore lo veda. Questa scala è l’eccitazione: con il passo completo ogni comando è un calcio di 90 gradi elettrici su una risonanza molto poco smorzata, ed è esattamente il motivo per cui un motore a passo completo stride e uno con microstepping no.

Il modello dell’avvolgimento fissa il limite di coppia:

const backEmf   = kT * speed;
const impedance = Math.hypot(resistance, rotorTeeth * speed * inductance);
const current   = Math.min(currentLimit, Math.max(0, supplyVolts - backEmf) / impedance);
const torque    = Math.SQRT2 * kT * current;

È un’approssimazione concentrata in regime stazionario di un driver a chopping, non una simulazione fase per fase. Riproduce la forma di una curva di coppia reale e fornisce entrambe le risposte ingegneristiche corrette; è conservativo all’estremità superiore.

La traiettoria comandata proviene dal pianificatore di profili di movimento già presente sul sito, quindi «con una rampa» e «senza» sono lo stesso percorso di codice con un limite di accelerazione diverso: non è scritto alcun modo di fallimento separato.

Esperimenti guidati

Ogni esperimento isola una singola variabile. Non cambiare nient’altro.

1. La rampa è tutta la macchina. Lascia tutto ai valori predefiniti e alterna Frequenza dei passi tra Ramped e Straight to full speed.

Stesso motore, stesso driver, stessa corrente, stesso bersaglio. L’unica differenza è che la frequenza dei passi è stata rampata, e la differenza è l’intero movimento.

2. Trova la pull-in rate. Imposta Straight to full speed, poi aumenta Velocità massima da 100 mm/s a incrementi. Funziona, continua a funzionare, poi a circa 200 mm/s smette completamente di funzionare, senza degrado graduale. Quella soglia è la pull-in rate ed è un numero reale sui motori reali.

3. I volt comprano velocità. Carica il preset 12 V, corsa veloce: il movimento si blocca. Ora aumenta Tensione di alimentazione a 24 e osserva completarsi il movimento, lasciando invariato il limite di corrente. Poi torna a 12 V e prova a salvarlo aumentando Limite di corrente: non puoi. Oltre la velocità limite in curva il driver non raggiungeva mai la corrente impostata.

4. Il microstepping non compra accuratezza. Fissa tutto e porta Microstepping da 1/1 a 1/16, leggendo due aspetti:

Il tracciamento migliora di circa tre volte e poi si ferma. L’errore di carico non cambia affatto. Era 0.044 mm con passo completo ed è 0.044 mm con sedicesimo di passo: la differenza è che 0.044 mm è un quarto di passo completo e tre microstep e mezzo, quindi il microstepping fine fa sembrare lo stesso errore molto peggio nelle unità riportate dal driver.

5. Pull-out. Aumenta lentamente Coppia resistente con una velocità moderata. Osserva l’angolo di ritardo nel grafico inferiore salire verso la linea tratteggiata. Si fermerà a 30°, poi 50°, poi 70° e poi, con un solo piccolo incremento del cursore, la sincronizzazione sparisce. Non esiste una regione di avviso, perché oltre 90° non c’è alcun equilibrio in cui possa assestarsi.

7. Il passo completo è un calcio di 90°. Carica il preset Passo completo e leggi il ritardo di picco: circa 102°. Ogni singolo passo comanda 90° completi e l’inerzia del rotore lo porta oltre. Arriva comunque: non viene perso nulla, ma trascorre l’intero movimento oscillando nella regione in cui un motore caricato non può permettersi di entrare. È contemporaneamente il motivo per cui il passo completo è rumoroso e il motivo per cui lascia così poco margine al carico.

6. Il meccanismo cambia il problema. Passa Meccanismo alla vite senza fine T8 con tutto il resto fisso. La risoluzione passa da 80 a 400 passi/mm e la stessa velocità massima richiede ora cinque volte la frequenza di passi.

Cosa devi osservare

• Il fallimento è una scoglia, non una pendenza. Nulla peggiora. L’angolo di ritardo cresce in modo regolare fino a 90° e poi il movimento è semplicemente sparito. Questa è la differenza definita tra un motore passo-passo e un ciclo chiuso stile servomotore, che rallenta semplicemente sotto carico.
• La macchina non lo sa mai. La linea tratteggiata comandata finisce sempre esattamente sul bersaglio, perché il driver ha contato ogni impulso ricevuto. Solo la linea continua dice la verità e nessuna macchina reale ha quella linea.
• L’errore di carico è sempre presente. Anche in una corsa perfetta il rotore resta decine di micrometri indietro rispetto a dove dice il driver che sia. Non è un guasto: è ciò che impone sin(δ) = load ÷ torque.
• I passi persi sono sempre un multiplo di quattro. Prova a produrre un conteggio che non lo sia.

Passaggio all’hardware

La differenza più importante è l’ultima in un senso diverso: una macchina reale non ti dà il grafico inferiore. Non puoi vedere l’angolo di ritardo, quindi non puoi vedere il margine su cui stai lavorando. Il sostituto pratico è trovare deliberatamente il punto di fallimento: aumenta velocità e accelerazione finché l’asse salta un passo, poi arretra del 30–50 percento e lavora lì.

Parti dalla guida sul cablaggio e sul limite di corrente, calibra i passi per millimetro rispetto a un righello e metti tutto insieme nel robot plotter a penna.

Codice sorgente

La rampa non è opzionale su una macchina reale. La versione bloccante qui sotto è quella che la maggior parte dei primi sketch mostra, ed è quella che ronziona:

// What not to ship: the step rate jumps from zero to full.
void moveBlocking(long steps, unsigned delayUs) {
  for (long i = 0; i < steps; i++) {
    digitalWrite(STEP_PIN, HIGH);
    delayMicroseconds(2);
    digitalWrite(STEP_PIN, LOW);
    delayMicroseconds(delayUs);      // constant => no acceleration at all
  }
}

La versione con rampa, non bloccante. È lo stesso trapezio che il laboratorio pianifica, generato un passo alla volta così che nient’altro sul microcontrollore si ferma:

#include <AccelStepper.h>

const float STEPS_PER_MM = 80.0;          // 20T GT2 pulley at 1/16 stepping
AccelStepper axis(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);

void setup() {
  pinMode(EN_PIN, OUTPUT);
  digitalWrite(EN_PIN, LOW);              // active low: energise

  axis.setMaxSpeed(200 * STEPS_PER_MM);   // 200 mm/s
  axis.setAcceleration(2000 * STEPS_PER_MM);
}

void loop() {
  if (axis.distanceToGo() == 0) {
    axis.moveTo(axis.currentPosition() == 0 ? lround(60 * STEPS_PER_MM) : 0);
  }
  axis.run();                             // returns immediately — call it constantly
  checkEndstops();                        // which is only possible because it does
}

setMaxSpeed e setAcceleration forniscono un profilo trapezoidale e nient’altro: in AccelStepper non c’è un’opzione S-curve. Per un profilo con jerk limitato generi tu il valore di riferimento e lo passi a moveTo su un timer.

Se vuoi sapere se la tua macchina è vicina al limite, il test economico è un test di ripetibilità:

// Drive a long move out and back, N times, then check whether home moved.
// Anything other than a multiple of four full steps is not step loss.
for (int i = 0; i < 20; i++) { moveTo(LONG_MOVE); runToPosition(); moveTo(0); runToPosition(); }
// now re-home and compare the reported position against zero

Ipotesi e differenze hardware

La dinamica del rotore è onesta: la coppia proporzionale a sin(δ) è il modo in cui funziona un motore passo-passo ibrido e il comportamento dello scorrimento è una conseguenza dell’integrazione, non una regola scritta nel codice. Le costanti descrivono un 17HS4401 di classe NEMA 17: 1.8°, 1.7 A, 2.8 Ω, 3.2 mH, 0.44 N·m di coppia di tenuta, con un carrello da 300 g riflesso sull’albero.

Cosa semplifica il modello: l’avvolgimento è raccolto in un’impedenza in regime stazionario e in un termine di forza controelettromotrice, invece di essere simulato fase per fase, quindi la coda lontana della curva di coppia è pessimistica. La coppia di detenzione, il piccolo dentellamento che senti girando a mano un motore passo-passo non alimentato, non è modellata; non lo sono né la risonanza di metà banda, né il comportamento del driver in modalità decay, né alcun effetto termico. Il timing è ideale, quindi il jitter dei passi di un microcontrollore reale non compare.

Nessuno di questi cambia quale regolazione girare. Sono tutte ragioni per verificare una macchina reale invece di fidarsi di un numero riportato in questa pagina.

Schema elettrico

La configurazione fisica modellata è formata da quattro fili dal motore a un driver, due fili dal driver a un microcontrollore e un condensatore che le persone continuano a dimenticare:

Arduino 5V  ──── VDD
Arduino GND ──── GND (logic) ──┬── GND (motor) ──── PSU −
PSU + (12–24 V) ──── VMOT ──┬──┴── 100 µF electrolytic, close to the board
Pin 3 ──── STEP             RESET ──┬── SLEEP
Pin 4 ──── DIR              MS1, MS2, MS3 ──── 5 V   (1/16)
Pin 5 ──── ENABLE (active low)
Coil A ──── 1A, 1B          Coil B ──── 2A, 2B

La pagina del componente A4988 contiene il pinout completo, la tabella Vref per entrambe le varianti di resistenza di sensore e la ragione per cui quel condensatore non è opzionale.