Servo che trema con Arduino: cause e soluzioni (ESP32, Pico)
Il servo trema, gira da solo o Arduino si resetta? Risolvi con alimentazione, GND comune, condensatori, filtri nel codice e PWM corretto su ESP32 e Pico.
Il servo che trema è uno dei guasti più frequenti e più confusi nei progetti Arduino: il servo ronza e vibra dove dovrebbe stare fermo, ruota da solo senza alcun comando oppure, appena si muove, Arduino si resetta e il codice riparte da capo. La buona notizia è che la grande maggioranza di questi sintomi non dipende da un servo rotto, ma da cinque cause di fondo: alimentazione insufficiente, GND comune mancante, condensatore assente, rumore sul segnale o conflitto tra librerie.
In questa guida spieghiamo passo passo perché si verifica ogni causa, come individuarla con il multimetro e come risolverla in modo definitivo. Troverai i calcoli di corrente per i servo più diffusi come SG90, MG90S e MG996R, lo schema di collegamento corretto, il codice Arduino che attenua il tremolio via software, le impostazioni PWM con LEDC su ESP32 e la soluzione MicroPython per Raspberry Pi Pico. Se non conosci ancora il funzionamento di base, dai prima un'occhiata a Che cos'è un servomotore?.

Perché il servo trema? Capire come funziona
Dentro un servo hobbistico ci sono un piccolo motore DC, un riduttore, un potenziometro collegato all'albero di uscita e un circuito di controllo. Arduino invia al servo un impulso ogni 20 millisecondi (50 Hz); la larghezza dell'impulso indica l'angolo richiesto: circa 0,5–1 ms corrispondono a 0 gradi, 1,5 ms a 90 gradi, 2–2,4 ms a 180 gradi. Il circuito di controllo confronta l'impulso con la posizione reale letta dal potenziometro e, se c'è differenza, aziona il motore per correggerla. In questo anello chiuso il servo interpreta ogni minima variazione della larghezza d'impulso come un nuovo comando. Se l'impulso slitta di qualche microsecondo, se la tensione di alimentazione cala o se si sovrappone un disturbo, il servo corregge di continuo: quello è il ronzio che senti e il tremolio che vedi. Servo come l'SG90 hanno una zona morta (deadband) di circa 10 µs; quando la variazione del segnale la supera, il motore si muove.
| Caratteristica | SG90 | MG90S | MG996R |
|---|---|---|---|
| Tensione di lavoro | 4,8–6 V | 4,8–6 V | 4,8–7,2 V |
| Ingranaggi | Plastica | Metallo | Metallo |
| Coppia (4,8 V) | Circa 1,8 kg·cm | Circa 1,8 kg·cm | Circa 9,4 kg·cm |
| Corrente in movimento | 100–250 mA | 150–300 mA | 500–900 mA |
| Corrente di stallo | Circa 650–750 mA | Circa 0,7–1 A | Circa 2,5 A |
| Alimentatore consigliato (un servo) | 5 V 1 A | 5 V 1 A | 6 V 3 A |
Sintomi e cause probabili
| Sintomo | Causa probabile | Prima cosa da fare |
|---|---|---|
| Il servo ronza di continuo e vibra leggermente da fermo | Segnale rumoroso, lettura instabile del potenziometro, battuta contro il fine corsa meccanico | Aggiungi filtro e zona morta nel codice, restringi l'intervallo di angoli a 5–175 gradi |
| Arduino si resetta quando il servo si muove | La tensione di alimentazione crolla (brownout) | Alimenta il servo da una sorgente esterna da 5–6 V |
| Il servo ruota da solo in modo casuale | Manca il GND comune o il filo del segnale è scollegato | Collega il GND dell'alimentatore esterno al GND di Arduino |
| All'accensione il servo scatta di colpo | Comando a 90 gradi al momento dell'attach(), pin di avvio dell'ESP32 | Imposta l'angolo iniziale, su ESP32 scegli un pin sicuro come GPIO 18 |
| Il servo trema solo quando funziona un altro modulo | La libreria disabilita gli interrupt o c'è un conflitto di timer | Individua la libreria in conflitto, se serve usa un driver PCA9685 |
| Il servo si sforza e si scalda in fondo corsa | L'intervallo degli impulsi supera il limite meccanico del servo | Calibra l'intervallo con attach(pin, min, max) |
| Un servo a rotazione continua gira lentamente quando dovrebbe fermarsi | Il punto centrale (circa 1500 µs) si è spostato | Gira il trimmer sul servo o regola con precisione il valore di stop |
Causa 1: alimentazione insufficiente e reset di Arduino
La causa numero uno di tremolio e reset è alimentare il servo dal pin 5V di Arduino. Un SG90 a riposo assorbe solo pochi milliampere, ma nei primi millisecondi di movimento, soprattutto sotto carico o se l'albero si blocca contro un ostacolo, può superare i 650 mA. Quando Arduino Uno è alimentato via USB, la linea 5V è limitata dalla porta USB del computer e dal fusibile autoripristinante da 500 mA presente sulla scheda. Con un assorbimento improvviso, la linea 5V può scendere sotto i 4 V. Anche se la protezione brownout dell'ATmega328P interviene solo a circa 2,7 V, questo calo ha già disturbato il circuito di controllo del servo, i sensori e la comunicazione seriale. Se la tensione crolla abbastanza, il microcontrollore si riavvia, il codice riparte da setup(), il servo torna alla posizione iniziale, assorbe di nuovo corrente e finisci in un ciclo. È l'esempio classico del problema del reset spontaneo di Arduino.
Verificare è facile: collega il multimetro tra 5V e GND e muovi il servo. Se la tensione misurata scende sotto 4,6 V o oscilla a ogni movimento, la causa è l'alimentazione. Per risolvere, alimenta i servo da una sorgente separata e calcola la corrente partendo dalla corrente di stallo: per un braccio robotico con quattro SG90 sono 4 × 0,7 A = 2,8 A, quindi ha senso un alimentatore da almeno 5 V 3 A oppure un convertitore step-down LM2596. Con servo potenti come l'MG996R devi calcolare 2,5 A per servo. Se lavori a batteria, vanno bene 4 pile AA (circa 6 V con alcaline, 4,8 V con NiMH) oppure un pacco Li-ion 2S abbassato a 6 V; con il calcolatore di durata della batteria puoi vedere in anticipo quanto durerà il progetto.
Collegamento corretto: alimentazione esterna e GND comune
| Filo del servo | Arduino Uno | ESP32 | Raspberry Pi Pico | Alimentatore esterno 5–6 V |
|---|---|---|---|---|
| Marrone / nero (GND) | GND | GND | GND | Negativo (-) |
| Rosso (V+) | Non collegato | Non collegato | Non collegato | Positivo (+) |
| Arancione / giallo (segnale) | D9 | GPIO 18 | GP15 | Non collegato |
| GND dell'alimentatore esterno | GND (comune) | GND (comune) | GND (comune) | Negativo (-) |
La riga più critica di questa tabella è l'ultima. Il servo misura l'impulso sul filo del segnale rispetto al proprio GND. Se il negativo dell'alimentatore esterno non è collegato al GND di Arduino, il segnale perde il riferimento; il servo interpreta come impulsi casuali le tensioni disperse sui cavi e i disturbi di rete e comincia a ruotare da solo. Perché la massa comune è indispensabile lo abbiamo spiegato nel dettaglio nell'articolo GND e massa comune. Se lavori su breadboard, il modulo di alimentazione MB102 è una scelta pratica per alimentare la linea dei servo; tuttavia il suo regolatore in pratica è limitato a circa 700–800 mA, quindi va bene al massimo per uno o due piccoli servo.
Aggiungere un condensatore: che valore e dove?
Anche con un alimentatore esterno, a ogni avvio del motore del servo si generano impulsi di corrente di pochi millisecondi. Se i cavi sono sottili e lunghi, questi impulsi creano cali istantanei di tensione; il circuito di controllo diventa instabile in quei cali e inizia il tremolio. La soluzione è aggiungere una riserva di energia locale sulla linea di alimentazione del servo: il più vicino possibile al connettore, tra positivo e negativo, collega un condensatore elettrolitico da 470–1000 µF e in parallelo uno ceramico da 100 nF. L'elettrolitico copre il fabbisogno di corrente elevato e breve, mentre quello ceramico filtra il rumore ad alta frequenza prodotto dalle spazzole del motore. La tensione nominale del condensatore deve essere almeno 1,5–2 volte la tensione di alimentazione; per una linea servo da 5–6 V vanno bene condensatori da 10 V o 16 V. Con più servo, mettere un 470 µF vicino a ciascuno funziona meglio di un solo condensatore grande.
Rumore sul segnale e disposizione dei cavi
- Tieni i cavi corti: cerca di non superare i 50 cm per il filo del segnale. Se devi allungarlo, intreccia i fili di segnale e GND (doppino intrecciato).
- Aggiungi una resistenza in serie: una resistenza da 220–470 Ω tra il pin della scheda e il filo del segnale riduce riflessioni e oscillazioni sulle linee lunghe e protegge inoltre il pin dai cortocircuiti.
- Separa potenza e segnale: non far correre i cavi che portano corrente di motori o relè in parallelo alla linea del segnale; se devono incrociarsi, fallo ad angolo retto.
- Controlla i contatti sulla breadboard: jumper allentati e molle della breadboard affaticate causano interruzioni momentanee; se il tremolio cambia toccando i cavi, la causa è il contatto.
- Rumore del potenziometro: se controlli il servo con un potenziometro, il valore di analogRead oscilla di qualche unità e questa oscillazione si riflette direttamente sull'angolo. Un condensatore da 100 nF tra il cursore e GND e un filtro nel codice risolvono il problema.
- Segnale a 3,3 V: ESP32 e Pico generano impulsi a 3,3 V. La maggior parte dei servo come SG90 e MG996R li riconosce senza problemi; se un servo funziona in modo instabile, puoi usare un convertitore di livello logico.
Evitare il tremolio nel codice: filtro e zona morta
Anche con l'hardware a posto, il software può far tremare il servo. Gli errori più comuni sono questi: chiamare attach() a ogni giro di loop(), passare direttamente a write() il valore grezzo del potenziometro e spingere il servo fino al suo limite fisico (0 o 180 gradi). Nei servo economici il fine corsa meccanico si trova spesso un po' prima di 0 e 180 gradi; il servo non raggiunge l'obiettivo, continua a spingere, ronza e si scalda. Il codice seguente prende tre precauzioni insieme: leviga la lettura con una media esponenziale, mantiene l'angolo tra 5 e 175 gradi e non invia un nuovo comando al servo finché l'angolo non cambia di almeno 2 gradi. Per approfondire i metodi di filtraggio, leggi l'articolo sul filtraggio dei dati dei sensori.
1#include <Servo.h>
2
3const int SERVO_PIN = 9; // servo sinyal pini / servo signal pin
4const int POT_PIN = A0; // potansiyometre orta ucu / potentiometer wiper
5const int DEADBAND = 2; // derece cinsinden ölü bölge / dead band in degrees
6
7Servo servo;
8float filtered = 0; // filtrelenmiş okuma / filtered reading
9int lastAngle = -1; // son gönderilen açı / last angle sent
10
11void setup() {
12 servo.write(90); // attach öncesi başlangıç açısı (AVR) / start angle before attach (AVR)
13 servo.attach(SERVO_PIN); // yalnızca bir kez / only once
14 filtered = analogRead(POT_PIN);
15}
16
17void loop() {
18 int raw = analogRead(POT_PIN);
19 filtered = filtered * 0.9 + raw * 0.1; // üstel ortalama / exponential moving average
20 int angle = map((int)filtered, 0, 1023, 5, 175); // sınırlara dayanma / stay away from end stops
21
22 if (lastAngle < 0 || abs(angle - lastAngle) >= DEADBAND) {
23 servo.write(angle); // yalnızca belirgin değişimde / only on a real change
24 lastAngle = angle;
25 }
26 delay(15);
27}| Riga / comando | A cosa serve |
|---|---|
| servo.write(90) (prima di attach) | Con la libreria Servo standard per AVR fa partire il primo impulso a 90 gradi; riduce lo scatto all'accensione. |
| filtered = filtered * 0.9 + raw * 0.1 | Media mobile esponenziale: sopprime le oscillazioni improvvise e lascia passare le variazioni lente. Più piccolo è il coefficiente 0.1, più forte è il filtro ma più lenta la risposta. |
| map(..., 5, 175) | Fa lavorare il servo senza spingerlo contro i fine corsa meccanici. |
| DEADBAND = 2 | Se l'angolo cambia di meno di 2 gradi non invia un nuovo comando; la zona morta elimina i piccoli tremolii. |
| delay(15) | Dà al servo il tempo di raggiungere la nuova posizione e limita la frequenza di lettura. |
| attach(pin, 500, 2400) | Serve a calibrare l'intervallo degli impulsi sui limiti reali del servo; i valori predefiniti sono 544 e 2400 µs. |
| servo.detach() | Interrompe gli impulsi quando il servo ha raggiunto l'obiettivo; il ronzio sparisce ma il servo perde la coppia di tenuta. |
Conflitti tra librerie e timer
La libreria Servo standard di Arduino Uno genera gli impulsi con il timer hardware Timer1 e gli interrupt. Questo progetto permette di pilotare fino a 12 servo con un solo timer, ma ha due effetti collaterali: non può funzionare insieme a un'altra libreria che usa Timer1 e la precisione degli impulsi dipende dal fatto che gli interrupt vengano eseguiti in tempo. Qualsiasi codice che disabilita gli interrupt per qualche centinaio di microsecondi allunga l'impulso generato in quel momento e il servo ha uno scatto. Se il tremolio inizia solo quando entra in funzione un certo modulo, quasi certamente sei in questa situazione.
- analogWrite sui pin 9 e 10: con la libreria Servo, su Uno il PWM non funziona su questi due pin; sposta il LED o il driver motore collegati a questi pin sui pin 3, 5, 6 o 11.
- Librerie RF a 433 MHz: anche VirtualWire e il driver RH_ASK di RadioHead usano Timer1 per impostazione predefinita; vedrai errori di compilazione o un movimento irregolare del servo. Per i dettagli leggi l'articolo sul modulo RF 433 MHz.
- Strisce NeoPixel: Adafruit NeoPixel e FastLED disabilitano gli interrupt durante l'invio dei dati; su una striscia lunga questo tempo arriva ai millisecondi e il servo scatta a ogni aggiornamento. Se usi insieme WS2812B e servo, aggiorna la striscia meno spesso.
- SoftwareSerial e DHT: entrambi disabilitano brevemente gli interrupt mentre ricevono byte o leggono il sensore; è una causa frequente del tremolio nei bracci servo controllati con un modulo Bluetooth.
- Soluzione definitiva: usare un driver servo PCA9685 che genera gli impulsi con il proprio hardware; così fino a 16 servo ricevono un segnale senza tremolii, qualunque cosa faccia Arduino.
Impostazioni PWM per servo su ESP32
Su ESP32 la libreria Servo standard di Arduino non funziona; si usa invece la libreria ESP32Servo oppure direttamente il PWM LEDC integrato. Poiché LEDC lavora in hardware, non è influenzato dagli interrupt e produce impulsi molto stabili; l'unica condizione è impostare la frequenza a 50 Hz e una risoluzione sufficiente. Con 14 bit di risoluzione il periodo di 20 ms è diviso in 16384 passi; ogni passo vale circa 1,22 µs, una precisione più che sufficiente per un servo. Abbiamo scelto 14 bit perché anche i chip più recenti come ESP32-S3 ed ESP32-C3 supportano questo valore. Poiché le funzioni LEDC sono cambiate nella versione 3.x del core ESP32 Arduino, il codice seguente è scritto in modo da compilare con entrambe le versioni:
1// ESP32 Arduino core 2.x ve 3.x uyumlu / compatible with ESP32 Arduino core 2.x and 3.x
2const int SERVO_PIN = 18; // güvenli bir GPIO / a safe GPIO
3const int PWM_FREQ = 50; // 50 Hz = 20 ms periyot / 20 ms period
4const int PWM_BITS = 14; // ESP32, S3 ve C3 destekler / supported by ESP32, S3 and C3
5const int MIN_US = 500; // 0 derece darbesi / 0 degree pulse
6const int MAX_US = 2400; // 180 derece darbesi / 180 degree pulse
7
8#if ESP_ARDUINO_VERSION_MAJOR < 3
9const int PWM_CHANNEL = 0; // 2.x için LEDC kanalı / LEDC channel for 2.x
10#endif
11
12uint32_t usToDuty(uint32_t us) {
13 return us * ((1UL << PWM_BITS) - 1) / 20000UL; // mikrosaniyeyi duty değerine çevir / convert microseconds to duty
14}
15
16void servoWriteUs(uint32_t us) {
17#if ESP_ARDUINO_VERSION_MAJOR >= 3
18 ledcWrite(SERVO_PIN, usToDuty(us)); // 3.x: pin numarası / pin number
19#else
20 ledcWrite(PWM_CHANNEL, usToDuty(us)); // 2.x: kanal numarası / channel number
21#endif
22}
23
24void servoWriteAngle(int angle) {
25 angle = constrain(angle, 0, 180);
26 servoWriteUs(map(angle, 0, 180, MIN_US, MAX_US));
27}
28
29void setup() {
30#if ESP_ARDUINO_VERSION_MAJOR >= 3
31 ledcAttach(SERVO_PIN, PWM_FREQ, PWM_BITS);
32#else
33 ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_BITS);
34 ledcAttachPin(SERVO_PIN, PWM_CHANNEL);
35#endif
36 servoWriteAngle(90); // başlangıç konumu / start position
37}
38
39void loop() {
40 for (int a = 30; a <= 150; a++) { // yumuşak tarama / smooth sweep
41 servoWriteAngle(a);
42 delay(15);
43 }
44 for (int a = 150; a >= 30; a--) {
45 servoWriteAngle(a);
46 delay(15);
47 }
48}Ci sono altre due insidie specifiche dell'ESP32. La prima sono i pin di avvio: pin come GPIO 0, 2, 12, 14 e 15 e i pin 1 e 3 della porta seriale possono generare brevi impulsi all'avvio; se il servo è su questi pin, scatta a ogni reset. Per i servo GPIO 13, 18, 19, 23, 25, 26, 27, 32 e 33 sono scelte sicure; i pin 34–39 sono solo di ingresso e non possono pilotare un servo. La seconda è la sensibilità all'alimentazione: con il Wi-Fi attivo l'ESP32 assorbe già picchi di corrente oltre i 300 mA e, se anche il servo è alimentato dalla stessa linea, nel monitor seriale vedrai il messaggio "Brownout detector was triggered". La soluzione di questo errore l'abbiamo descritta nell'articolo su ESP32 brownout e Guru Meditation; in breve: alimenta il servo da una sorgente separata e unisci i GND.
Servo su Raspberry Pi Pico (MicroPython)
Ogni pin GPIO di Raspberry Pi Pico può generare PWM hardware; il chip ha 8 slice PWM e 16 canali in totale. In MicroPython, dopo aver impostato la frequenza dell'oggetto PWM a 50 Hz, puoi dare la larghezza dell'impulso direttamente in nanosecondi con la funzione duty_ns(); è molto più sicuro che fare calcoli con percentuali o duty a 16 bit. Il codice seguente controlla il servo su GP15 con il potenziometro su GP26 e applica la stessa logica di filtro e zona morta dell'esempio Arduino. L'uscita 3V3 del Pico non è adatta ad alimentare un servo, né per tensione né per corrente; alimenta il servo da una sorgente esterna da 5 V e rendi comune il GND.
1from machine import Pin, PWM, ADC
2import time
3
4servo = PWM(Pin(15)) # servo sinyali GP15 / servo signal on GP15
5servo.freq(50) # 50 Hz = 20 ms
6pot = ADC(26) # potansiyometre GP26 (ADC0) / potentiometer on GP26 (ADC0)
7
8MIN_US = 500 # 0 derece / 0 degrees
9MAX_US = 2400 # 180 derece / 180 degrees
10DEADBAND = 2 # ölü bölge (derece) / dead band (degrees)
11
12def write_angle(angle):
13 angle = max(5, min(175, angle)) # sınırlara dayanma / stay away from end stops
14 us = MIN_US + (MAX_US - MIN_US) * angle // 180
15 servo.duty_ns(us * 1000) # mikrosaniye -> nanosaniye / microseconds -> nanoseconds
16
17filtered = pot.read_u16()
18last = -100
19write_angle(90) # başlangıç konumu / start position
20
21while True:
22 filtered = filtered * 0.9 + pot.read_u16() * 0.1 # üstel ortalama / exponential moving average
23 angle = int(filtered * 180 / 65535)
24 if abs(angle - last) >= DEADBAND:
25 write_angle(angle)
26 last = angle
27 time.sleep_ms(20)Lista di controllo passo passo
- Scollega il servo dalla scheda e alimentalo solo da una sorgente esterna da 5–6 V; assicurati che la corrente dell'alimentatore copra numero di servo × corrente di stallo.
- Collega il GND dell'alimentatore esterno al GND di Arduino, ESP32 o Pico; questo singolo filo risolve la maggior parte dei problemi di rotazione spontanea.
- Misura la tensione di alimentazione con il multimetro mentre il servo si muove; se scende sotto 4,6 V, usa un alimentatore più potente o cavi più spessi.
- Aggiungi accanto al connettore del servo un condensatore elettrolitico da 470–1000 µF e uno ceramico da 100 nF, controllando la polarità.
- Accorcia il filo del segnale, se serve aggiungi una resistenza in serie da 220–470 Ω e rendi più solidi i contatti sulla breadboard.
- Verifica che nel codice attach() sia chiamato solo in setup(), che l'angolo resti tra 5 e 175 gradi e che siano usati filtro e zona morta.
- Se il servo trema quando funziona un altro modulo, trova il conflitto disattivando le librerie una alla volta; se serve, passa al PCA9685.
- Se continua a tremare, prova a sostituirlo con un altro servo; i servo con potenziometro usurato o ingranaggi rotti tremano in qualsiasi condizione.
Cosa considerare nei progetti con servo
- Braccio robotico: in un braccio robotico con quattro o sei servo non muovere tutti i servo contemporaneamente; distanzia i comandi di 100–200 ms, così i picchi di corrente non si sommano.
- Progetto radar: nei progetti a scansione continua come il radar con Arduino ruota il servo grado per grado e aspetta 15–30 ms a ogni passo; grandi scatti improvvisi significano sia tremolio sia picco di corrente.
- Carichi pesanti: per lavori con carico come una serratura o un supporto per telecamera usa l'MG996R con ingranaggi in metallo al posto dell'SG90 e scegli un alimentatore da almeno 3 A.
- Servo a rotazione continua: se servo a 360 gradi come l'FS90R strisciano nel punto di stop, non è tremolio ma un problema di calibrazione; regola con precisione intorno ai 1500 µs per fermarlo.
- Progetti a batteria: rilasciare il servo con detach() a movimento finito elimina il ronzio e allunga la durata della batteria; è molto efficace se il meccanismo non scivola per il proprio peso.
Il problema del servo che trema sembra complicato a prima vista, ma quasi sempre si risolve nello stesso ordine: prima l'alimentazione, poi il GND comune, quindi il condensatore, il cablaggio e per ultimo il software. Se segui questo ordine, raramente dovrai sostituire il servo. Per i dettagli sul calcolo della potenza puoi consultare anche la guida all'alimentazione di Arduino. Nell'app BlueGrays trovi passo passo gli schemi e i codici di progetti come il controllo del servo con potenziometro, il servo con joystick, il servo con ESP32 e la serratura con RFID, così puoi mettere subito in pratica ciò che hai imparato qui.
Domande frequenti
Perché un servomotore trema?
La causa più comune è una tensione di alimentazione insufficiente o instabile: se il servo è alimentato dal pin 5V di Arduino, la tensione cala con gli assorbimenti improvvisi e il circuito di controllo diventa instabile. Contribuiscono anche GND comune mancante, segnale rumoroso, valori instabili dal potenziometro e servo forzato contro il limite meccanico. Un alimentatore esterno da 5–6 V, il GND comune e un condensatore da 470–1000 µF risolvono la maggior parte dei casi.
Perché il servo gira da solo?
Se il servo ruota senza alcun comando, di solito al segnale manca il riferimento: il GND dell'alimentatore esterno non è collegato al GND di Arduino oppure il filo del segnale è allentato. Il servo scambia per impulsi i disturbi sui cavi. Nei servo a 360 gradi la lenta rotazione dipende dallo spostamento della calibrazione del punto centrale (circa 1500 µs) e si corregge con il trimmer del servo.
Perché Arduino si resetta quando il servo funziona?
Quando parte, il servo può assorbire centinaia di milliampere e nei servo grandi oltre 2 A. Se questa corrente viene presa dalla linea USB o dal regolatore di Arduino, i 5 V crollano e il microcontrollore si riavvia. Alimentando il servo da una sorgente separata e unendo solo i GND, i reset spariscono.
Quanti µF deve avere il condensatore per un servo?
Per un singolo SG90 o MG90S un 470 µF vicino al connettore del servo è un buon punto di partenza, per servo grandi come l'MG996R un elettrolitico da 1000 µF. Aggiungere accanto un ceramico da 100 nF filtra anche il rumore ad alta frequenza. La tensione nominale deve essere almeno 10 V per una linea da 5–6 V e la polarità va collegata correttamente.
Si può alimentare un servo dal pin 5V di Arduino?
Per provare un singolo SG90 senza carico il pin 5V spesso basta, ma non è una soluzione affidabile. La linea USB è limitata a circa 500 mA e, quando il servo si blocca, supera questo valore. Con due o più servo, un servo che porta un carico o un MG996R usa sempre un'alimentazione esterna.
Perché il servo trema o non funziona su ESP32?
Su ESP32 la libreria Servo standard di Arduino non funziona; devi usare la libreria ESP32Servo o il PWM LEDC impostato a 50 Hz. Collegare il servo a pin di avvio come GPIO 0, 2, 12 o 15 provoca scatti al reset, mentre alimentarlo dalla linea dell'ESP32 causa errori di brownout. Un pin sicuro come GPIO 18 e un alimentatore da 5 V separato risolvono il problema.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Utilizzo del servomotore
Il braccio di un piccolo servomotore ruota a turno in tre posizioni: tutto all'inizio, esattamente a metà e tutto alla fine, aspettando due secondi a ogni fermata.

Funzionamento del servomotore con potenziometro
Mentre giri la manopola del potenziometro, il braccio del servomotore ruota insieme a lei: un'estremità della manopola corrisponde a zero gradi, l'altra a mezzo giro.

Servocomando con joystick
Comanda due motori con un joystick, proprio come se girassi una telecamera di sicurezza.

Servomotore ESP32 (controllo tramite potenziometro)
In questo progetto controlliamo un servomotore SG90 tramite un potenziometro. Regoliamo l'angolo del servomotore mappando il valore analogico letto dal potenziometro su un intervallo compreso tra 0 e 180 gradi. La libreria ESP32Servo genera segnali per servomotori sui GPIO adatti dell'ESP32 che possono funzionare come uscite; in questo progetto si utilizza GPIO 18. Si tratta di un metodo di controllo fondamentale per bracci robotici, gimbal per telecamere e meccanismi di porte automatiche.

Serratura RFID ESP32 (RC522 + servomotore + OLED + cicalino + LED)
Costruiamo una serratura smart con ESP32, modulo RFID RC522, servo SG90, display OLED SSD1306, buzzer attivo e 2 LED. Quando passi una tessera, il suo UID viene confrontato con quelle autorizzate definite nel codice; se corrisponde, il servo apre (LED verde + 2 bip brevi) e richiude dopo 5 secondi. Con una tessera sconosciuta si accende il LED rosso, suonano 3 bip rapidi e l'OLED mostra l'UID.

Costruzione del servomotore a 360 gradi dal motore passo-passo
Insegna a un normale motore passo-passo ad andare all'angolo che vuoi, lungo tutto il giro.

Coreografia di servo in cerchio - Animazioni con 32 servomotori
Un progetto di animazione visiva con 32 servomotori disposti in cerchio su un Arduino Mega. I servo sono gestiti in un unico array, collegati ai pin 22–53 del Mega, e mostrano quattro sequenze di movimento: una vibrazione caotica ad angoli casuali, una spazzata sincronizzata, un'onda che gira lungo il cerchio e un ago di bussola che oscilla a destra e a sinistra.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

