Driver A4988 e NEMA 17 con Arduino: Vref, microstep e codice

Pilotare un NEMA 17 con l'A4988 è il modo più economico per portare nel tuo progetto il movimento preciso usato da stampanti 3D, frese CNC e incisori laser. L'A4988 è un driver per motori passo-passo bipolari prodotto da Allegro e venduto su un modulo grande quanto un polpastrello: ogni impulso STEP inviato da Arduino fa avanzare il motore di un passo, il pin DIR sceglie il verso di rotazione e il driver mantiene la corrente nelle bobine al valore che imposti tu. In altre parole, per far girare il motore bastano due pin e un alimentatore tra 8 e 35 V.

In questa guida imparerai come funziona l'A4988, come trovare le bobine di un NEMA 17 con il multimetro, come collegarlo e perché serve un condensatore da 100 µF sull'alimentazione. Poi passeremo al passaggio più critico, la regolazione della corrente con la Vref, con la formula e la misura con il multimetro passo dopo passo. Troverai anche il microstep con i pin MS1–MS3, un primo sketch senza libreria, l'accelerazione morbida con AccelStepper, la CNC Shield, il codice per ESP32 e Raspberry Pi Pico, il calore e il dissipatore, il confronto con DRV8825 e TMC2208 e le soluzioni al classico problema "il motore vibra ma non gira".

Che cos'è l'A4988 e come funziona?

All'interno dell'A4988 ci sono due ponti H completi (uno per bobina), un traslatore (translator) e un circuito di controllo della corrente. Il traslatore converte ogni transizione LOW→HIGH sul pin STEP nella giusta sequenza di corrente per le bobine, così non devi calcolare l'ordine delle bobine nel codice. Il controllo della corrente funziona a chopper: il driver misura di continuo la corrente di ogni bobina tramite una piccola resistenza di misura (Rs) e spegne l'uscita per un istante quando la corrente raggiunge il limite impostato. Per questo la corrente nella bobina resta a un valore sicuro anche se alimenti il motore ben sopra la sua tensione nominale, per esempio a 12 o 24 V. Il chip ha anche protezioni contro sovratemperatura, sottotensione, cortocircuito del carico e cortocircuito verso massa.

Motore passo-passo NEMA 17: caratteristiche e come trovare le bobine

NEMA 17 non è un modello di motore ma uno standard di dimensioni per motori con una flangia da 42 × 42 mm; l'interno dipende dalla lunghezza del corpo e dal produttore. Il 17HS4401, il modello più diffuso nei progetti hobbistici, fa 200 passi per giro (1,8°), ha una corrente nominale di 1,7 A per fase, una resistenza di bobina di circa 1,5 Ω e una coppia di tenuta di circa 40 N·cm. La tensione sull'etichetta è solo 1,7 A × 1,5 Ω ≈ 2,6 V, ma non lasciarti ingannare: poiché l'A4988 limita da solo la corrente, il motore si alimenta a 12–24 V. Una tensione più alta fa salire più in fretta la corrente nella bobina a ogni passo, così il motore perde meno coppia ad alta velocità. Se ti incuriosisce la differenza con i piccoli motori unipolari come il 28BYJ-48, leggi 28BYJ-48 e ULN2003.

I 4 fili del motore appartengono a due bobine indipendenti, e prima di collegarlo all'A4988 devi sapere quali due fili formano la stessa bobina. In molti modelli nero e verde sono una bobina e rosso e blu l'altra, ma i colori cambiano da produttore a produttore, quindi il metodo più affidabile è misurare:

1. Imposta il multimetro sulla misura di resistenza (Ω); se non sai come fare, dai un'occhiata alla guida al multimetro.
2. Tieni fermo un filo e misuralo uno per uno con gli altri tre. Il filo che segna 1–4 Ω è l'altro capo della stessa bobina; con gli altri due il display indica circuito aperto (OL).
3. I due fili rimasti sono la seconda bobina e devono dare la stessa resistenza. Con la resistenza misurata e la corrente nominale puoi verificare la tensione di targa con il calcolatore della legge di Ohm.
4. Non hai un multimetro? Unisci le estremità di due fili e gira l'albero a mano: se diventa nettamente più duro da girare, quei due fili sono della stessa bobina.
5. Collega una bobina ai pin 1A–1B dell'A4988 e l'altra a 2A–2B. Se il motore gira al contrario di come vuoi, basta scambiare i due fili di una sola bobina.

Pinout dell'A4988 e schema di collegamento

Perché il condensatore da 100 µF è indispensabile?

Le schede A4988 montano solo piccoli condensatori ceramici. Insieme all'induttanza dei cavi di alimentazione, questi condensatori a bassa ESR provocano picchi di tensione all'accensione o quando il motore assorbe corrente all'improvviso. Questi picchi possono superare il limite di 35 V del chip anche con un'alimentazione di soli 12 V e danneggiare il driver in modo permanente. La soluzione è semplice: metti tra VMOT e GND, il più vicino possibile alla scheda, un condensatore elettrolitico di almeno 47 µF, meglio se da 100 µF. La sua tensione di lavoro deve essere ben superiore a quella di alimentazione: 25 V per 12 V, 35 V o 50 V per 24 V. Gli elettrolitici sono polarizzati; il reoforo lungo (+) va su VMOT e quello corto (–), indicato dalla striscia sul corpo, va su GND. Per i tipi di condensatore consulta Cos'è un condensatore? e per scegliere l'alimentatore giusto l'articolo sull'alimentazione di Arduino.

Regolare la corrente con la Vref: la formula

Il piccolo potenziometro (trimmer) dell'A4988 regola la Vref (tensione di riferimento), che determina la corrente massima del motore. Il driver confronta questa tensione con quella sulle due resistenze di misura (Rs) della scheda, e la corrente di picco nella bobina si ricava con: I = Vref / (8 × Rs). Per trovare la Vref da impostare basta invertire la formula: Vref = I × 8 × Rs. Per conoscere Rs, leggi la sigla sulle due piccole resistenze SMD accanto al chip: R100 significa 0,1 Ω, R068 0,068 Ω e R050 0,05 Ω. Se fai fatica a decifrare le sigle, usa il calcolatore dei codici delle resistenze SMD o l'articolo sui codici delle resistenze SMD.

Quale corrente scegliere? La corrente sull'etichetta del motore (1,7 A per il 17HS4401) è un tetto da non superare mai. Senza dissipatore l'A4988 regge senza problemi circa 1 A, quindi 0,8–1 A è un buon punto di partenza. Sulle schede comuni con resistenze R100 corrisponde a una Vref di 0,64–0,80 V. Se il motore perde passi sotto carico, aumenta la corrente a step di 0,1 A; oltre 1,2 A aggiungi un dissipatore e una ventola sul chip. Una corrente più alta del necessario scalda driver e motore molto più di quanto renda il motore davvero più forte.

Misurare la Vref con il multimetro: passo dopo passo

1. Con tutto spento, scollega il motore dal driver. Per misurare la Vref il motore non serve.
2. Alimenta i pin VDD e GND dell'A4988 con la tensione logica (bastano i 5V di Arduino). La Vref deriva da questa tensione, quindi senza VDD non si può misurare; lasciare collegato VMOT non crea problemi.
3. Imposta il multimetro su tensione continua (portata 2 V o 20 V). Appoggia il puntale nero su GND e quello rosso sulla parte metallica superiore del potenziometro; alcune schede hanno invece un piccolo punto di misura marcato VREF.
4. Gira pochissimo il potenziometro con un piccolo cacciavite di plastica o ceramica e osserva il valore. Sulla maggior parte delle schede il senso orario aumenta la Vref, ma può variare; alcuni potenziometri ricominciano da capo dopo un giro completo, quindi procedi a piccoli passi.
5. Raggiunto il valore calcolato, togli l'alimentazione, collega il motore e solo dopo riaccendi.
6. Fai girare il motore per qualche minuto e controlla la temperatura del chip. Se non riesci a tenere il dito sopra nemmeno per qualche secondo, abbassa un po' la Vref o aggiungi un dissipatore.

Microstep con MS1, MS2 e MS3

Il microstep (microstepping) consiste nel variare gradualmente la corrente nelle due bobine per dividere ogni passo intero in parti più piccole. L'A4988 sceglie una di cinque modalità in base ai livelli logici sui pin MS1–MS3. Questi pin hanno resistenze di pull-down interne, quindi se li lasci tutti e tre scollegati il motore lavora a passo intero.

Il vero vantaggio del microstep è una rotazione fluida e silenziosa: a passo intero il motore dà uno scatto a ogni passo ed entra in risonanza a certe velocità, mentre a 1/16 il movimento è quasi continuo. Non aspettarti però che la precisione aumenti davvero di 16 volte. La coppia che fa avanzare un singolo microstep è solo sin(90° / 16) ≈ 10% della coppia di tenuta; se attrito o carico superano questa piccola forza, il motore resta indietro di qualche microstep. Per calcolare la velocità usa: passi/s = giri/min × 200 × microstep / 60. Per esempio, 60 giri/min a 1/16 richiedono 3200 impulsi STEP al secondo. Se vuoi cambiare modalità via software puoi collegare anche i pin MS ad Arduino; nella maggior parte dei progetti, però, basta fissare una modalità con dei fili.

Primo sketch: rotazione con STEP e DIR senza libreria

Lo sketch qui sotto fa girare il motore di un giro in avanti e uno indietro senza alcuna libreria, solo inviando impulsi al pin STEP. Supponiamo che tu abbia collegato MS1–MS3 ai 5V, quindi il motore lavora a 1/16 e un giro corrisponde a 3200 passi.

1// A4988 + NEMA 17, kütüphanesiz / without a library
2const int STEP_PIN = 2;            // CNC Shield X ekseniyle aynı / same as CNC Shield X axis
3const int DIR_PIN  = 5;
4const int EN_PIN   = 8;            // aktif LOW / active LOW
5
6const long STEPS_PER_REV = 200L * 16;   // 1,8° motor, 1/16 mikro adım = 3200 / 1.8° motor, 1/16 microstep
7
8void setup() {
9  pinMode(STEP_PIN, OUTPUT);
10  pinMode(DIR_PIN, OUTPUT);
11  pinMode(EN_PIN, OUTPUT);
12  digitalWrite(EN_PIN, LOW);       // sürücüyü aç / enable the driver
13}
14
15void rotate(long steps, unsigned int pauseUs) {
16  digitalWrite(DIR_PIN, steps > 0 ? HIGH : LOW);   // yön / direction
17  delayMicroseconds(5);                           // DIR, STEP'ten önce otursun / let DIR settle before STEP
18  for (long i = 0; i < labs(steps); i++) {
19    digitalWrite(STEP_PIN, HIGH);
20    delayMicroseconds(5);                         // darbe en az 1 µs / pulse at least 1 µs
21    digitalWrite(STEP_PIN, LOW);
22    delayMicroseconds(pauseUs);                   // küçüldükçe hız artar / smaller = faster
23  }
24}
25
26void loop() {
27  rotate(STEPS_PER_REV, 500);      // 1 tur ileri, ~1,6 sn / one turn forward, ~1.6 s
28  delay(1000);
29  rotate(-STEPS_PER_REV, 500);     // 1 tur geri / one turn back
30  delay(1000);
31}

In questo codice contano tre tempi. L'A4988 richiede che la fase HIGH e quella LOW dell'impulso STEP durino almeno 1 µs; 5 µs è un valore sicuro. Dopo aver cambiato DIR bisogna attendere almeno 200 ns prima del primo impulso STEP; il codice attende 5 µs. La velocità dipende dalla pausa tra gli impulsi: con 500 µs di pausa un passo dura circa 0,51 ms e un giro (3200 passi) circa 1,6 secondi, cioè circa 36 giri/min. Questo codice ha due punti deboli: il motore parte di colpo alla massima velocità e Arduino non può fare nient'altro mentre il ciclo è in corso. Se porti subito la pausa a 100 µs, molto probabilmente il motore non riuscirà a partire e si limiterà a ronzare.

Accelerazione e decelerazione con AccelStepper

Non puoi portare un motore passo-passo da fermo ad alta velocità in un istante: rotore e carico non riescono a seguire un cambiamento così brusco, il motore perde il sincronismo e salta passi. La soluzione è aumentare la velocità con una rampa e ridurla avvicinandosi alla destinazione. AccelStepper, che puoi installare dal Gestore librerie, lo fa senza bloccare: chiami run() di continuo dentro loop() e la libreria esegue un passo ogni volta che è il momento. Così puoi leggere pulsanti, aggiornare un display o misurare sensori mentre il motore gira; trovi questo approccio spiegato nel dettaglio in millis() e delay(). Su un Uno, AccelStepper raggiunge in modo affidabile qualche migliaio di passi al secondo (la documentazione indica circa 4000 passi/s a 16 MHz); per questo l'esempio usa 2000 passi/s, circa 37 giri/min a 1/16.

1#include <AccelStepper.h>
2
3const int STEP_PIN = 2;
4const int DIR_PIN  = 5;
5const int EN_PIN   = 8;
6const long STEPS_PER_REV = 200L * 16;            // 1/16 mikro adımda 1 tur / one turn at 1/16 microstep
7
8AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
9
10void setup() {
11  stepper.setEnablePin(EN_PIN);
12  stepper.setPinsInverted(false, false, true);   // EN aktif LOW / EN is active LOW
13  stepper.enableOutputs();
14  stepper.setMaxSpeed(2000);                     // adım/sn, Uno için güvenli / steps per second, safe on Uno
15  stepper.setAcceleration(1500);                 // adım/sn² / steps per second²
16  stepper.moveTo(STEPS_PER_REV * 3);             // 3 tur ileri / three turns forward
17}
18
19void loop() {
20  if (stepper.distanceToGo() == 0) {             // hedefe varıldı / target reached
21    delay(500);
22    stepper.moveTo(stepper.currentPosition() == 0 ? STEPS_PER_REV * 3 : 0);   // git-gel / back and forth
23  }
24  stepper.run();                                 // her döngüde çağır, bekletmez / call every loop, non-blocking
25}

Più motori con la CNC Shield V3

Se devi pilotare più di un NEMA 17, il modo più semplice per evitare il groviglio di cavi è la CNC Shield V3 per Arduino. Questa scheda si innesta sull'Uno e ha quattro alloggiamenti per A4988 (X, Y, Z e A), jumper per il microstep sotto ogni driver, connettori per i motori, ingressi per i finecorsa e un morsetto di alimentazione; con tutti e tre i jumper inseriti l'A4988 lavora a 1/16. Nella tabella dei collegamenti abbiamo scelto apposta D2, D5 e D8 per STEP, DIR ed EN: sono i pin dell'asse X della shield, quindi gli sketch precedenti funzionano sulla shield senza modifiche. Se carichi GRBL sull'Uno, la shield diventa un controller CNC o laser che riceve G-code dal computer. In GRBL inserisci i passi per millimetro di ogni asse nelle impostazioni $100, $101 e $102: con una puleggia GT2 da 20 denti e microstep a 1/16 il valore è 200 × 16 / (20 × 2) = 80 passi/mm, con una vite trapezoidale T8 con passo di 8 mm è 200 × 16 / 8 = 400 passi/mm.

Usare l'A4988 con l'ESP32

I pin dell'ESP32 forniscono 3,3 V. L'A4988 riconosce con certezza un ingresso come HIGH solo se supera il 70% di VDD; con VDD a 5 V questa soglia è 3,5 V, quindi un segnale a 3,3 V resta sotto. Per questo con ESP32 e Pico collega il pin VDD dell'A4988 al 3V3: il driver funziona senza problemi tra 3 e 5,5 V e non ti serve un convertitore di livello logico. Visto che VDD è cambiata, ricordati di misurare di nuovo la Vref. Lo sketch qui sotto porta il motore, con accelerazione, all'angolo che scrivi nel Monitor seriale (per esempio 90 o -45). Dato che l'ESP32 è molto più veloce, qui AccelStepper arriva senza sforzo a 6000 passi al secondo; per velocità maggiori guarda la libreria FastAccelStepper, che usa i timer hardware. Se l'ESP32 è una novità per te, parti da Cos'è l'ESP32?.

1#include <AccelStepper.h>
2
3// ESP32: STEP=25, DIR=26, EN=27, A4988 VDD → 3V3
4const int STEP_PIN = 25;
5const int DIR_PIN  = 26;
6const int EN_PIN   = 27;
7const float STEPS_PER_DEG = 200.0 * 16 / 360.0;  // 1/16'da derece başına 8,89 adım / 8.89 steps per degree at 1/16
8
9AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
10
11void setup() {
12  Serial.begin(115200);
13  stepper.setEnablePin(EN_PIN);
14  stepper.setPinsInverted(false, false, true);   // EN aktif LOW / EN is active LOW
15  stepper.enableOutputs();
16  stepper.setMaxSpeed(6000);                     // adım/sn / steps per second
17  stepper.setAcceleration(4000);                 // adım/sn² / steps per second²
18  Serial.println("Aci yaz, ornek 90 / type an angle, e.g. 90");
19}
20
21void loop() {
22  if (Serial.available()) {
23    float angle = Serial.parseFloat();           // Seri Monitör'den açı / angle from the Serial Monitor
24    while (Serial.available()) Serial.read();    // satır sonunu at / drop the line ending
25    stepper.moveTo(lround(angle * STEPS_PER_DEG));
26    Serial.printf("Hedef / target: %.1f\n", angle);
27  }
28  stepper.run();                                 // bekletmeden adım at / step without blocking
29}

A4988 con Raspberry Pi Pico e MicroPython

Anche sul Pico colleghi il pin VDD dell'A4988 al pin 3V3 (OUT). Invece di una libreria per l'accelerazione, in MicroPython puoi scrivere una semplice rampa lineare come quella qui sotto: la funzione move() varia gradualmente la pausa tra gli impulsi da 2000 µs a 400 µs nei primi e negli ultimi 600 passi e in mezzo va alla massima velocità. Il ciclo di MicroPython aggiunge qualche decina di microsecondi a ogni passo, quindi la velocità reale è un po' più bassa di quella calcolata. Se ti servono decine di migliaia di passi al secondo o più motori insieme, i blocchi PIO del Pico possono generare gli impulsi senza impegnare affatto la CPU. Per installare MicroPython sul Pico, leggi Cos'è il Raspberry Pi Pico?.

1from machine import Pin
2import time
3
4step = Pin(2, Pin.OUT)              # STEP → GP2
5direction = Pin(3, Pin.OUT)         # DIR → GP3
6enable = Pin(4, Pin.OUT, value=0)   # EN → GP4, 0 = sürücü açık / 0 = driver enabled
7
8STEPS_PER_REV = 200 * 16            # 1/16 mikro adım / 1/16 microstep
9
10def move(steps, max_sps=2500, ramp_steps=600):
11    direction.value(1 if steps > 0 else 0)    # yön / direction
12    time.sleep_us(5)
13    n = abs(steps)
14    ramp = min(ramp_steps, n // 2)            # hızlanma ve yavaşlama adımı / accel and decel steps
15    fast = 1000000 // max_sps                 # en kısa bekleme, µs / shortest pause, µs
16    slow = 2000                               # 500 adım/sn ile başla / start at 500 steps/s
17    for i in range(n):
18        k = min(i, n - 1 - i)                 # başa ya da sona uzaklık / distance to start or end
19        pause = slow - (slow - fast) * k // ramp if k < ramp else fast
20        step.value(1)
21        time.sleep_us(3)                      # STEP darbesi / STEP pulse
22        step.value(0)
23        time.sleep_us(pause)
24
25while True:
26    move(STEPS_PER_REV)             # 1 tur ileri / one turn forward
27    time.sleep(1)
28    move(-STEPS_PER_REV // 2)       # yarım tur geri / half a turn back
29    time.sleep(1)

Calore, dissipatore e protezione termica

È normale che l'A4988 si scaldi, perché la corrente delle bobine passa nei MOSFET all'interno del chip. Il percorso della corrente di ogni bobina ha in genere una resistenza totale di 0,64 Ω, e la potenza dissipata cresce con il quadrato della corrente: circa P ≈ I² × 0,64 Ω. A 1 A sono circa 0,65 W, a 1,5 A circa 1,45 W; scaldandosi, il chip aumenta anche la propria resistenza e il valore reale sale ancora. Per una scheda grande quanto un polpastrello è molto calore. Quando il chip arriva a 165 °C, la protezione termica spegne le uscite e le riattiva dopo che si è raffreddato di circa 15 °C. Un motore che gira per qualche secondo, si ferma e poi riparte da solo è il segno tipico di questa protezione.

• Monta un dissipatore: Incolla sul chip un piccolo dissipatore in alluminio con nastro termico; assicurati che non tocchi i pin o il potenziometro.
• Garantisci un flusso d'aria: Oltre 1,2 A o in una scatola chiusa, una piccola ventola moltiplica l'effetto del dissipatore.
• Regola la corrente in base alle necessità: Se il motore non perde passi sotto carico, abbassa un po' la Vref; ridurre la corrente del 20% riduce il calore di circa il 36%.
• Spegni le bobine da fermo: Se non ti serve la coppia di tenuta, a fine movimento porta il pin EN a HIGH o chiama disableOutputs(); driver e motore si raffreddano.
• Controlla anche la temperatura del motore: I motori passo-passo assorbono corrente anche da fermi, quindi diventano tiepidi o persino caldi. Se il corpo supera i 60 °C, abbassa la corrente; a questa temperatura i pezzi in PLA di una stampante 3D iniziano ad ammorbidirsi.
• Passa a un driver più potente: Se il tuo motore richiede più di 1,5 A, un driver come il DRV8825 o il TMC2209 è più adatto.

Differenze tra A4988, DRV8825 e TMC2208

Tutti e tre i driver usano lo stesso formato "StepStick" a 16 pin e spesso si possono scambiare su una CNC Shield, ma ci sono differenze da tenere d'occhio. Il potenziometro del DRV8825 è in un'altra posizione e la formula è diversa; il pin che sull'A4988 è VDD sul DRV8825 è l'uscita FAULT. Con lo stesso codice il TMC2208 fa girare il motore nel verso opposto rispetto all'A4988: devi invertire DIR nel codice o ruotare di 180° il connettore del motore. Le sue impostazioni avanzate si fanno via UART e, se vuoi l'azzeramento senza sensori (StallGuard), guarda il TMC2209. In breve, per imparare e per progetti a basso costo l'A4988 resta il punto di partenza più sensato; scegli il TMC2208 se conta il rumore e il DRV8825 se ti serve più corrente. Per un confronto generale tra i tipi di motore, leggi differenze tra motore DC, servo e passo-passo.

Il motore vibra ma non gira: errori comuni e soluzioni

Idee di progetto con A4988 e NEMA 17

• Slider per fotocamera: Sposta la fotocamera su un binario millimetro dopo millimetro con cinghia e puleggia GT2 per girare video in time-lapse.
• Plotter a penna: Muovi una penna su due assi con CNC Shield e GRBL per trasferire su carta i disegni del computer; per alzare e abbassare la penna basta un servomotore.
• Piatto rotante: Ruota un oggetto ad angoli uguali per foto di prodotto o scansione 3D; dato che un giro a 1/16 è di 3200 passi, tra ciascuna delle 36 foto fai circa 89 passi.
• Inseguitore solare: Costruisci un sistema che orienti un pannello verso il sole per tutto il giorno; l'idea completa è nell'articolo sull'inseguitore solare.
• Base per braccio robotico: Ruota la base di un braccio pesante con un NEMA 17 e degli ingranaggi invece che con un servo; per gli altri giunti leggi l'articolo sul braccio robotico.
• Posizionamento manuale: Muovi il motore velocemente con un joystick e con precisione, passo dopo passo, con un encoder rotativo.
• Tenda automatica o coperchio scorrevole: All'avvio trova il punto zero con un finecorsa, salvalo con setCurrentPosition(0) e porta la tenda nella posizione che vuoi.

Riassumendo, pilotare un NEMA 17 con l'A4988 significa abbinare correttamente le bobine, mettere 100 µF sull'alimentazione, calcolare la Vref con la formula e regolarla con il multimetro, scegliere il microstep e muovere il motore con l'accelerazione. Una volta imparate queste basi, ti sarà chiaro anche come funzionano macchine come stampanti 3D e CNC. Nell'app BlueGrays trovi progetti di movimento come l'uso di un motore passo-passo e la trasformazione di un motore passo-passo in un servo a 360 gradi, passo dopo passo, con schemi elettrici e codice.