Motore DC, servomotore e motore passo-passo: differenze e usi

La differenza tra motore DC, servomotore e motore passo-passo si riassume in una frase: il motore DC gira in modo continuo e veloce finché lo alimenti, il servomotore va all'angolo che gli chiedi e lì rimane, e il motore passo-passo ruota a piccoli passi che puoi contare. Quindi, se devi far girare una ruota, scegli un motore DC; per aprire un coperchio di 90 gradi, un servo; per spostare un pezzo con la precisione di un decimo di millimetro, un motore passo-passo. In qualsiasi progetto con Arduino, ESP32 o Raspberry Pi Pico in cui qualcosa deve muoversi, incontrerai uno di questi tre.

In questa guida confrontiamo cosa c'è dentro ogni motore, i dati reali di velocità, coppia e precisione di posizionamento di modelli diffusi (motore TT, SG90, MG996R, 28BYJ-48, NEMA 17), quale driver serve a ciascuno (L298N, segnale PWM, ULN2003, A4988), quanta corrente assorbono e quale si usa in quale progetto. Alla fine troverai il codice per Arduino, ESP32 e Pico che comanda tutti e tre insieme, una breve introduzione ai motori brushless (BLDC) e agli ESC e gli errori più comuni.

Risposta breve: i tre motori in una tabella

La riga più importante della tabella è quella della retroazione. Un servo sa dove si trova grazie al potenziometro interno e, quando qualcosa lo spinge, torna nella sua posizione. Un motore passo-passo non sa dove si trova; tu conti soltanto quanti passi ha fatto, e il conteggio è giusto finché il motore non viene sovraccaricato e non perde passi. Un motore DC non ha alcuna idea di quanto abbia girato; se ti serve la posizione, devi aggiungere un encoder sull'albero. Quale motore scegliere dipende in gran parte dal fatto che il tuo progetto abbia bisogno o meno di questa informazione.

Come funziona un motore DC?

Quasi tutti i motori DC dei progetti hobbistici sono motori DC a spazzole. Dentro ci sono magneti fissi e una bobina che ruota (il rotore); le spazzole di carbone e il collettore a lamelle di rame invertono il verso della corrente mentre il rotore gira, così la rotazione non si ferma mai. Ha due fili: dai tensione e gira, inverti i fili e gira al contrario. La tensione determina la velocità, la corrente assorbita determina la coppia. Mentre il motore gira, nelle bobine nasce una tensione opposta chiamata forza controelettromotrice che limita la corrente; quando l'albero si blocca, questa tensione sparisce e la corrente schizza fino alla corrente di stallo.

Un piccolo motore DC senza riduttore gira a migliaia di giri al minuto ma ha pochissima coppia; per questo i robot usano sempre motoriduttori. Il riduttore 1:48 del motore TT porta circa 12.000 giri/min dell'albero motore a 250 giri/min alla ruota e moltiplica la coppia di circa 48 volte (al netto delle perdite degli ingranaggi). La velocità la cambi con il PWM e il verso con un ponte H; trovi i dettagli in Controllo del motore DC con L298N. Il punto debole del motore DC è la posizione: lo stesso valore PWM dà una velocità diversa a seconda della tensione della batteria e del carico, quindi il comando "vai avanti per 2 secondi" copre ogni volta una distanza diversa. Se ti serve una distanza esatta, si aggiunge un encoder alla ruota.

Come funziona un servomotore?

Un servomotore è in realtà un sistema completo chiuso in una piccola scatola: un motore DC, un gruppo di ingranaggi che riduce la velocità e aumenta la coppia, un potenziometro collegato all'albero di uscita e una scheda di controllo. Arduino non invia al servo un angolo, ma un impulso a 50 Hz (ogni 20 ms); la larghezza dell'impulso indica la posizione desiderata. La scheda confronta questo valore con la posizione reale letta dal potenziometro e muove il motore in quella direzione finché la differenza non è zero. Si chiama controllo ad anello chiuso, ed è il motivo per cui il servo fa resistenza quando provi a girarlo a mano.

L'intervallo RC standard è 1–2 ms, ma la maggior parte dei servo economici come l'SG90 richiede circa 0,5–2,4 ms per coprire tutti i 180°, e la libreria Servo di Arduino usa di default l'intervallo 544–2400 µs. La banda morta dell'SG90, cioè la variazione più piccola a cui reagisce, è di circa 10 µs, pari a circa 1°; per questo la precisione pratica di un servo è intorno al grado. Un servo a rotazione continua (FS90R) è un servo con la retroazione disattivata: controlli velocità e verso invece dell'angolo, e l'informazione sulla posizione si perde. Se ti serve più forza, l'MG996R con ingranaggi in metallo è la scelta standard; per le basi, leggi Cos'è un servomotore?

Come funziona un motore passo-passo?

Il motore passo-passo non ha spazzole. Le bobine nel corpo vengono alimentate in un ordine preciso e il rotore magnetico fa ogni volta un singolo passo verso la bobina successiva. I motori ibridi più diffusi fanno 200 passi al giro, cioè 1,8° per passo. Invii un certo numero di impulsi e fa esattamente quei passi; li invii più velocemente e gira più veloce. Finché le bobine sono alimentate, il motore resta bloccato in posizione: questa è la coppia di mantenimento. La differenza fondamentale: il motore passo-passo lavora ad anello aperto. Se il carico supera la sua coppia perde passi, e Arduino non se ne accorge. Ecco perché le stampanti 3D all'avvio portano ogni asse contro un finecorsa (homing).

Incontrerai due tipi di motore passo-passo. I motori unipolari (28BYJ-48, 5 fili) hanno un filo comune alle bobine e si pilotano con un semplice array di transistor come l'ULN2003. Nei motori bipolari (NEMA 17, 4 fili) bisogna invertire il verso della corrente nelle bobine; lo fanno i driver con limitazione di corrente come A4988, DRV8825 o TMC2209. Questi driver gestiscono anche il micropasso: l'A4988 divide ogni passo intero in 16, portando i passi per giro a 3200 e rendendo il movimento molto più silenzioso e fluido. Per i dettagli, vedi 28BYJ-48 e ULN2003 e driver per motori passo-passo A4988.

Velocità, coppia e precisione: il confronto in numeri

La coppia si indica di solito in kg·cm: un motore da 1 kg·cm regge un carico di 1 kg a 1 cm dall'albero, ma solo 0,5 kg a 2 cm (1 kg·cm ≈ 0,098 N·m). Per esempio, un MG996R a 6 V fornisce 11 kg·cm; all'estremità di un braccio di 15 cm regge in teoria 11 / 15 ≈ 0,73 kg. Questo però è il valore massimo nel momento dello stallo, e al carico si aggiunge anche il peso del braccio stesso. Per far durare il motore, una buona regola è restare sotto la metà di quel valore; in pratica, all'estremità di quel braccio puoi portare qualche centinaio di grammi.

Sulla velocità la classifica si ribalta. Il motore DC è di gran lunga il più veloce. Un servo SG90 completa un movimento di 180° in circa 0,3 secondi e non può andare più veloce. Nel motore passo-passo la coppia cala con l'aumentare della velocità, perché la corrente della bobina non fa in tempo a salire del tutto a ogni passo; un 28BYJ-48 comincia a perdere passi oltre circa 15 giri/min. Alimentare un NEMA 17 con A4988 a 24 V anziché a 12 V dà più coppia alle alte velocità, perché il driver limita comunque la corrente. Sulla precisione, invece, vince il passo-passo: un NEMA 17 offre 1,8° a passo intero e, sulla carta, 0,1125° con micropasso 1/16. Una piccola nota: il riduttore interno del 28BYJ-48 non è esattamente 1:64 ma circa 1:63,68, quindi un giro reale è di circa 2038 passi e non 2048; nei progetti che girano di continuo, come gli orologi, questa differenza si accumula.

Quale driver serve a ogni motore?

Un pin di Arduino fornisce al massimo 40 mA, e il limite sicuro è intorno ai 20 mA; anche un piccolo motore TT assorbe circa 7 volte tanto a vuoto e oltre 70 volte tanto in stallo. Inoltre, la bobina di un motore genera un forte picco di tensione inversa nell'istante in cui si interrompe la corrente, che può distruggere un pin non protetto. Per questo tra motore e scheda c'è sempre un driver: la scheda invia solo piccoli segnali di controllo, mentre la corrente del motore passa direttamente dall'alimentatore attraverso il driver. Dentro i driver ci sono transistor e diodi che assorbono la tensione inversa. Per una ventola o una pompa che girano in un solo verso basta un singolo MOSFET.

Consumi: quanta corrente assorbe ogni motore?

I tre motori si comportano in modo molto diverso riguardo alla corrente, e l'alimentazione va scelta di conseguenza. Un motore DC assorbe più corrente all'aumentare del carico; all'avvio e quando una ruota si blocca si avvicina alla corrente di stallo. Dimensiona l'alimentazione su questo picco, non sulla corrente a vuoto. Un servo assorbe pochissimo da fermo, ma a ogni movimento genera picchi di corrente brevi e bruschi: anche un solo SG90 può superare per un attimo 0,5 A, e un MG996R sotto sforzo arriva a 2,5 A. Questi picchi fanno crollare la tensione e riavviano Arduino, oppure causano un errore di brownout sull'ESP32. Nelle bobine di un motore passo-passo, invece, la corrente scorre anche quando è completamente fermo: un 28BYJ-48 assorbe 150–200 mA da fermo e si scalda. Nei progetti a batteria, se non ti serve la coppia di mantenimento, spegnere le bobine (portare a HIGH il pin EN dell'A4988) allunga parecchio l'autonomia.

• Usa un'alimentazione separata: non alimentare i motori dal pin 5V di Arduino. Una porta USB fornisce circa 500 mA e la scheda ne usa già una parte; a parte un singolo servo piccolo, ogni motore ha bisogno della sua fonte.
• Collega le masse: il negativo dell'alimentazione dei motori deve essere collegato al GND della scheda, altrimenti il segnale di controllo non ha un riferimento (vedi massa comune).
• Aggiungi condensatori: metti un elettrolitico da 470–1000 µF sulla linea di alimentazione dei servo, almeno 47 µF sull'ingresso VMOT dell'A4988 e un condensatore ceramico da 100 nF sui morsetti di un motore DC a spazzole. Il primo evita i cali di tensione, l'ultimo riduce i disturbi delle spazzole.
• Scegli l'alimentazione in base alla corrente di picco: per esempio, un braccio robotico con 4 servo richiede un alimentatore da 5–6 V con almeno 3 A, e una macchinina con due motori TT un pacco batterie che regga 2 × 1,5 A. Puoi stimare quanto durerà la batteria con il calcolatore di autonomia della batteria.
• Abbassa la tensione nel modo giusto: se dai 7,4 V di un pacco batterie ti servono 5–6 V per i servo, usa un regolatore switching come l'LM2596; i regolatori lineari come il 7805 scaldano molto con correnti nell'ordine dell'ampere.

Tre motori con un solo Arduino: passo dopo passo

Il modo migliore per vedere la differenza è far funzionare i tre motori uno accanto all'altro. Nel circuito seguente un motore TT è pilotato da un L298N, un SG90 direttamente da un pin e un 28BYJ-48 da una scheda ULN2003. La tabella dei pin vale per tutti e tre gli sketch: Arduino Uno, ESP32 e Raspberry Pi Pico.

1. Togli il jumper ENA dell'L298N; collega ENA, IN1 e IN2 ai pin della tabella e il motore DC ai morsetti OUT1 e OUT2. Porta l'alimentazione del motore (per esempio due celle 18650 in serie, 7,4 V) al morsetto 12V.
2. Collega il filo marrone del servo a GND, quello rosso a un'alimentazione separata da 5–6 V e il filo arancione del segnale a D9.
3. Inserisci il connettore bianco del 28BYJ-48 nella scheda ULN2003, collega IN1–IN4 a D10–D13 e alimenta il morsetto + della scheda a 5 V.
4. Collega tra loro i negativi di tutte le alimentazioni e il GND di Arduino.
5. Carica lo sketch con l'IDE di Arduino; le librerie Servo e Stepper sono incluse nell'IDE, quindi non devi installarle.
6. Accendi le alimentazioni dei motori e osserva come si comportano i tre motori uno dopo l'altro.

1#include <Servo.h>
2#include <Stepper.h>
3
4// DC motor (L298N): ENA=5, IN1=7, IN2=8
5const int ENA = 5;                 // PWM; Servo kütüphanesi 9 ve 10'un PWM'ini kapatır / Servo library disables PWM on 9 and 10
6const int IN1 = 7;
7const int IN2 = 8;
8
9const int SERVO_PIN = 9;           // servo sinyali / servo signal
10Servo servo;
11
12const int STEPS_PER_REV = 2048;    // 28BYJ-48 tam tur / full revolution
13Stepper stepper(STEPS_PER_REV, 10, 12, 11, 13);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
14
15void releaseStepper() {            // bobinleri bırak, boşta akım çekmesin / release coils, no idle current
16  for (int pin = 10; pin <= 13; pin++) {
17    digitalWrite(pin, LOW);
18  }
19}
20
21void setup() {
22  pinMode(ENA, OUTPUT);
23  pinMode(IN1, OUTPUT);
24  pinMode(IN2, OUTPUT);
25  servo.attach(SERVO_PIN);
26  stepper.setSpeed(10);            // devir/dakika, 28BYJ-48 için en fazla ~15 / RPM, max ~15 for 28BYJ-48
27}
28
29void loop() {
30  // 1) DC motor: hız ve yön, konum yok / speed and direction, no position
31  digitalWrite(IN1, HIGH);
32  digitalWrite(IN2, LOW);
33  analogWrite(ENA, 180);           // yaklaşık %70 güç / about 70% power
34  delay(2000);
35  analogWrite(ENA, 0);             // motoru serbest bırak / let the motor coast
36  delay(500);
37
38  // 2) Servo: açı ver, gidip orada kalsın / give an angle, it goes there and holds
39  servo.write(0);
40  delay(600);
41  servo.write(180);
42  delay(600);
43  servo.write(90);
44  delay(600);
45
46  // 3) Step motor: tam çeyrek tur ileri ve geri / exactly a quarter turn forward and back
47  stepper.step(STEPS_PER_REV / 4);   // 512 adım = 90° / 512 steps = 90°
48  delay(500);
49  stepper.step(-STEPS_PER_REV / 4);
50  releaseStepper();
51  delay(1000);
52}

Quando avvii lo sketch, la differenza è evidente: il motore DC gira per due secondi, ma il suo albero si ferma ogni volta in un punto diverso. Il servo scatta a 0°, 180° e 90° e fa resistenza se provi a girarlo a mano. Il motore passo-passo avanza lentamente di esattamente un quarto di giro e torna allo stesso punto; dopo la chiamata a releaseStepper() puoi girare il suo albero a mano senza sforzo. La funzione step() della libreria Stepper blocca il codice fino alla fine del movimento; se vuoi muovere più motori insieme e con accelerazioni morbide, passa alla libreria AccelStepper.

Motore DC, servo e passo-passo con l'ESP32

I pin dell'ESP32 forniscono 3,3 V; gli ingressi di L298N e ULN2003 riconoscono questo livello come HIGH, e anche i servo funzionano con un segnale a 3,3 V. I motori hanno comunque bisogno di un'alimentazione propria. La differenza sta nel servo: la libreria Servo standard di Arduino non supporta l'ESP32. Puoi installare la libreria ESP32Servo oppure, come qui sotto, generare tu il segnale a 50 Hz con l'unità PWM hardware dell'ESP32, LEDC. Poiché usiamo due frequenze diverse, 1 kHz per il motore DC e 50 Hz per il servo, assegniamo i canali a timer separati (canali 0 e 2) con ledcAttachChannel; in alcune versioni del core, i canali vicini condividono lo stesso timer. Il codice è per il core Arduino ESP32 3.x; nelle versioni 2.x si usano invece ledcSetup e ledcAttachPin. La libreria Stepper funziona senza modifiche sull'ESP32; se sei alle prime armi con questa scheda, dai un'occhiata a Cos'è l'ESP32?

1#include <Stepper.h>
2
3// ESP32 Arduino çekirdeği 3.x / ESP32 Arduino core 3.x
4const int ENA = 25;                // L298N hız (PWM) / L298N speed (PWM)
5const int IN1 = 26;
6const int IN2 = 27;
7const int SERVO_PIN = 18;          // servo sinyali / servo signal
8
9const int STEPS_PER_REV = 2048;
10Stepper stepper(STEPS_PER_REV, 19, 22, 21, 23);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
11
12void motor(int speed) {            // -255 … 255
13  digitalWrite(IN1, speed > 0);
14  digitalWrite(IN2, speed < 0);
15  ledcWrite(ENA, abs(speed));
16}
17
18void servoWrite(int angle) {       // 0 … 180
19  int us = map(angle, 0, 180, 500, 2400);              // açı → darbe (µs) / angle → pulse (µs)
20  ledcWrite(SERVO_PIN, (uint32_t)us * 65535 / 20000);  // 20 ms içindeki pay / share of the 20 ms period
21}
22
23void setup() {
24  pinMode(IN1, OUTPUT);
25  pinMode(IN2, OUTPUT);
26  ledcAttachChannel(ENA, 1000, 8, 0);        // kanal 0: 1 kHz, 8 bit (0–255) / channel 0: 1 kHz, 8-bit
27  ledcAttachChannel(SERVO_PIN, 50, 16, 2);   // kanal 2, ayrı zamanlayıcı: 50 Hz, 16 bit / channel 2, separate timer: 50 Hz, 16-bit
28  stepper.setSpeed(10);                      // devir/dakika / RPM
29}
30
31void loop() {
32  motor(200);         delay(2000);   // DC: ileri / forward
33  motor(0);           delay(500);    // DC: dur / stop
34  servoWrite(0);      delay(600);    // servo: 0°
35  servoWrite(180);    delay(600);    // servo: 180°
36  servoWrite(90);     delay(600);    // servo: 90°
37  stepper.step(512);  delay(500);    // step: çeyrek tur / quarter turn
38  stepper.step(-512); delay(1000);
39}

Codice MicroPython per Raspberry Pi Pico

Sul Pico ogni pin GP può generare PWM. In MicroPython imposti la velocità del motore DC tra 0 e 65535 con duty_u16() e la larghezza dell'impulso del servo in nanosecondi con duty_ns(). Il motore passo-passo si fa girare scrivendo in sequenza sui quattro pin la serie di mezzi passi; a mezzo passo, un giro del 28BYJ-48 è di 4096 passi. Se il Pico è una novità per te, parti da Cos'è il Raspberry Pi Pico?

1from machine import Pin, PWM
2import time
3
4# DC motor (L298N): ENA=GP15, IN1=GP14, IN2=GP13
5ena = PWM(Pin(15))
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9
10# Servo: GP16, 50 Hz
11servo = PWM(Pin(16))
12servo.freq(50)
13
14# Step motor (ULN2003): IN1–IN4 = GP2–GP5
15coils = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]
16SEQ = [(1,0,0,0), (1,1,0,0), (0,1,0,0), (0,1,1,0),
17       (0,0,1,0), (0,0,1,1), (0,0,0,1), (1,0,0,1)]   # yarım adım dizisi / half-step sequence
18
19def motor(speed):                    # -100 … 100
20    in1.value(speed > 0)
21    in2.value(speed < 0)
22    ena.duty_u16(int(abs(speed) * 655.35))
23
24def servo_angle(angle):              # 0 … 180
25    us = 500 + angle * 1900 // 180   # 500–2400 µs
26    servo.duty_ns(us * 1000)
27
28phase = 0                            # dizideki konum, çağrılar arasında korunur / position in the sequence, kept between calls
29
30def step(steps, delay_ms=2):         # yarım adımda 4096 adım = 1 tur / 4096 half-steps = 1 turn
31    global phase
32    d = 1 if steps > 0 else -1
33    for _ in range(abs(steps)):
34        phase = (phase + d) % 8
35        for pin, v in zip(coils, SEQ[phase]):
36            pin.value(v)
37        time.sleep_ms(delay_ms)
38    for pin in coils:
39        pin.value(0)                 # bobinleri bırak / release coils
40
41while True:
42    motor(70)                        # DC: %70 ileri / 70% forward
43    time.sleep(2)
44    motor(0)                         # DC: dur / stop
45    time.sleep(0.5)
46    for a in (0, 180, 90):           # servo: üç açı / three angles
47        servo_angle(a)
48        time.sleep(0.6)
49    step(1024)                       # step: çeyrek tur / quarter turn
50    time.sleep(0.5)
51    step(-1024)
52    time.sleep(1)

Quale motore per quale progetto?

In alcuni progetti vanno bene entrambi i motori, e la scelta dipende dai dettagli. In una macchinina robot i motori DC bastano per le ruote, ma se vuoi che percorra esattamente 50 cm devi aggiungere degli encoder oppure muovere le ruote con motori passo-passo. In un braccio robotico i servo sono la strada più semplice; i bracci pesanti e precisi usano motori passo-passo con riduttori nei giunti. In una stampante 3D è facile calcolare quanti passi servono a un asse per ogni millimetro: con un motore da 200 passi, micropasso 1/16 e una puleggia GT2 da 20 denti (passo di 2 mm) si ottiene 200 × 16 / (20 × 2) = 80 passi/mm; con una vite trapezoidale T8 da 8 mm di avanzamento, il valore diventa 200 × 16 / 8 = 400 passi/mm. Nei progetti che fanno una scansione di 0–180°, come un radar o un inseguitore solare, il servo è la soluzione più economica e più semplice.

Breve introduzione ai motori brushless (BLDC) e agli ESC

Nel motore DC senza spazzole (brushless, BLDC) la struttura è capovolta: i magneti sono sulla parte che ruota e le bobine nel corpo fisso. Senza spazzole né collettore non ci sono attriti, scintille né usura; il motore è più efficiente, più silenzioso e dura molto di più. Il prezzo da pagare è che ora il verso della corrente deve cambiarlo un circuito elettronico invece delle spazzole. Per questo i motori BLDC hanno 3 fili e non girano se li colleghi direttamente a una batteria. Nei motori per modellismo la velocità si indica con il valore KV, cioè i giri al minuto a vuoto per ogni volt. Un motore da 1000 KV (per esempio l'A2212) con una LiPo a 3 celle (11,1 V) gira a vuoto a circa 11.100 giri/min. Droni, aerei RC, skateboard e monopattini elettrici, ventole dei computer e dischi rigidi usano tutti motori brushless.

Per collegare un motore BLDC ad Arduino ti serve un ESC (Electronic Speed Controller, regolatore elettronico di velocità). L'ESC trasforma la tensione continua della batteria in impulsi trifase per il motore; gli ESC sensorless stimano la posizione del rotore dalla forza controelettromotrice nella bobina non alimentata. Il bello è che l'ingresso di comando dell'ESC è uguale a quello di un servo: con impulsi a 50 Hz, 1000 µs significa fermo e 2000 µs tutto gas. La corrente dell'ESC (es. 30 A) deve essere superiore alla corrente massima che il motore può assorbire, e la maggior parte degli ESC ha un'uscita BEC che fornisce 5 V. Per sicurezza, all'accensione l'ESC vuole vedere prima il gas al minimo; si chiama armamento (arming), e senza questo segnale non fa girare il motore. Nello sketch qui sotto il filo di segnale dell'ESC va a D9 e il cursore del potenziometro usato come acceleratore va ad A0.

1#include <Servo.h>
2
3Servo esc;                         // ESC bir servo gibi sürülür / an ESC is driven like a servo
4const int POT_PIN = A0;            // gaz potansiyometresi / throttle potentiometer
5
6void setup() {
7  esc.attach(9, 1000, 2000);       // 1000–2000 µs aralığı / 1000–2000 µs range
8  esc.writeMicroseconds(1000);     // en düşük gaz: ESC'yi kur (arming) / minimum throttle: arm the ESC
9  delay(3000);                     // bip seslerini bekle / wait for the beeps
10}
11
12void loop() {
13  int throttle = map(analogRead(POT_PIN), 0, 1023, 1000, 2000);   // pot → gaz / pot → throttle
14  esc.writeMicroseconds(throttle);
15  delay(20);                       // bir servo periyodu / one servo period
16}

Errori frequenti e soluzioni

• Arduino si riavvia quando parte il motore: il motore o il servo è alimentato dal pin 5V della scheda. Usa un'alimentazione separata, collega le masse e aggiungi un condensatore grande sull'alimentazione.
• Il servo trema o fa scatti: l'alimentazione è debole, i fili sono sottili e lunghi oppure la massa non è comune. Collega il servo a un'alimentazione da 5–6 V in grado di fornire almeno 1 A.
• Con un servo, la velocità del motore DC non cambia: sull'Uno ENA è collegato al pin 9 o 10, e la libreria Servo disattiva il PWM su quei pin. Sposta ENA sul 3, 5, 6 o 11.
• Il motore DC non gira con valori PWM bassi, ronza soltanto: la potenza non basta a vincere l'attrito statico. Avvia il motore per un attimo con un valore alto e poi abbassa la velocità, oppure tieni il valore minimo intorno a 80–100. Considera anche la caduta di tensione di circa 2 V dell'L298N.
• Il motore passo-passo vibra ma non gira: l'ordine delle bobine è sbagliato o la velocità è troppo alta. Per il 28BYJ-48 usa l'ordine Stepper(2048, IN1, IN3, IN2, IN4) e resta sotto i 15 giri/min.
• Il motore passo-passo perde passi: il carico è troppo pesante, l'accelerazione troppo brusca o il limite di corrente dell'A4988 troppo basso. Regola Vref con la formula I = Vref / (8 × Rcs), dove Rcs è la resistenza di misura della corrente sulla scheda, e usa un'accelerazione dolce con AccelStepper.
• L'A4988 si è bruciato: il cavo del motore è stato collegato o scollegato con il driver alimentato, Vref era troppo alto oppure mancava il condensatore su VMOT. Collega sempre il motore ad alimentazione spenta.
• L'ESC non fa girare il motore e continua a suonare: all'accensione non ha ricevuto il segnale di gas minimo. Assicurati che setup() invii writeMicroseconds(1000) e aspetti qualche secondo; se serve, calibra l'ESC come indicato nel suo manuale.

In breve, motore DC significa velocità, servo significa angolo e motore passo-passo significa posizione; abbina il motore giusto al driver giusto e metà del progetto è fatta. Partire con un SG90 e un motore TT e poi passare al passo-passo è il modo più semplice per imparare tutti e tre. Nell'app BlueGrays trovi i progetti sull'uso del servomotore, il controllo del servo con un potenziometro, l'uso del motore passo-passo, un servo a 360 gradi ricavato da un motore passo-passo, una macchinina controllata via Bluetooth con L298N e un robot che evita gli ostacoli, ognuno passo dopo passo con schema elettrico e codice.