Guide · 12 min di lettura

Progetti con servomotori Arduino: 15 idee con SG90 e MG996R

Progetti con servomotori Arduino: radar, braccio robotico, serratura, inseguitore solare, dispenser; scegliere SG90, MG90S o MG996R, alimentazione e PCA9685.

I progetti con servomotori sono il modo più semplice per far muovere davvero qualcosa con Arduino: con un solo filo indichi un angolo, il servo ci va e resta fermo lì. In questa guida abbiamo raccolto 15 progetti con servomotori e Arduino, dal radar a ultrasuoni al braccio robotico, passando per la serratura RFID, l'inseguitore solare e il dispenser automatico di crocchette. Per ogni progetto troverai in un'unica tabella quale servo scegliere, quanti ne servono, se conviene pilotarli direttamente da Arduino o con un driver PCA9685 e come alimentarli.

Prima dei progetti vedremo le differenze tra SG90, MG90S e MG996R, come scegliere l'alimentatore in base al numero di servo e quanti servo possono pilotare insieme un Arduino Uno, un ESP32 e un Raspberry Pi Pico. Poi arrivano modelli di codice già compilati e pronti all'uso per il radar, il braccio robotico e l'inseguitore solare. Se i servo sono una novità per te, ti consigliamo di leggere prima Cos'è un servomotore?.

Micro servo SG90 con il suo cavo a tre colori
Micro servo SG90: 9 grammi, circa 1,8 kg·cm di coppia; filo marrone GND, rosso positivo e arancione segnale.

Quale servo: SG90, MG90S o MG996R?

Il primo valore da guardare quando scegli un servo è la coppia: si esprime in kg·cm e indica quanti chili il servo può tenere a 1 cm dall'asse. Più il braccio è lungo, meno carico solleva, nella stessa proporzione; un SG90 da 1,8 kg·cm regge appena 300 grammi all'estremità di un braccio di 6 cm, e non in modo continuo. Il secondo aspetto è il materiale degli ingranaggi: quelli in plastica saltano sotto sforzo, quelli in metallo reggono gli urti. Il terzo è la corrente: un servo grande vuole un alimentatore grande. In pratica l'SG90 va bene per coperchi leggeri e per orientare sensori, l'MG90S per piccoli meccanismi usati spesso o sotto carico e l'MG996R per la spalla di un braccio robotico e i coperchi pesanti.

ModelloCoppiaIngranaggiCorrente di stalloAlimentazione consigliataProgetto tipico
SG901,8 kg·cm (4,8 V)Plastica650-750 mA5 VRadar, pan-tilt, coperchio piccolo
MG90S1,8-2,2 kg·cmMetallo0,7-1 A5-6 VSerratura, pinza, robot ragno
MG996R9,4-11 kg·cmMetallo, doppio cuscinetto2,5 A (6 V)6 V, 3 A per servoSpalla del braccio robotico, tenda, coperchio pesante
FS90R (360°)1,5 kg·cmPlasticafino a 800 mA5 VRuote, piatto girevole
Servomotore MG996R con ingranaggi metallici e squadrette
MG996R: ingranaggi metallici e fino a 11 kg·cm di coppia; ideale per bracci robotici e meccanismi pesanti, ma vuole sempre un'alimentazione esterna.

Tabella di alimentazione: quanti servo, quanta corrente?

Nei progetti con i servo la maggior parte dei problemi non nasce dal codice ma dall'alimentazione. Nell'istante in cui parte, il servo assorbe un breve picco di corrente; se il pin 5V di Arduino, alimentato dall'USB, non ce la fa, la tensione cala, la scheda si riavvia e il servo trema. La regola è semplice: un solo SG90 poco caricato può funzionare dal pin 5V di Arduino; per tutto il resto alimenta i servo con un alimentatore esterno da 5-6 V, collega il suo negativo al GND di Arduino e aggiungi un condensatore da 470-1000 µF sulla linea dei servo. Per dimensionare l'alimentatore somma le correnti di lavoro dei servo e tieni almeno il 50% di margine.

ConfigurazioneCorrente in movimento (circa)Alimentatore consigliato
1 × SG90, carico leggero100-250 mABasta il pin 5V di Arduino
2 × SG90 o MG90S0,3-0,6 AEsterno 5 V, 2 A
4 × MG90S (piccolo braccio robotico)0,6-1,2 AEsterno 5 V, 3 A
1 × MG996R0,5-0,9 A (2,5 A in stallo)6 V, 3 A
6 × MG996R (braccio robotico grande)3-5,4 AAlimentatore switching 6 V, 10 A
12 × MG90S (robot ragno)1,8-3,6 A5-6 V, 5 A, oppure LiPo 2S con BEC da 5 A
Non alimentare mai più servo, e nemmeno un solo MG996R, dal pin 5V di Arduino, e non provare a farli andare con una batteria da 9 V: quelle piccole batterie non erogano la corrente di un servo e la scheda continua a riavviarsi. Quando usi un alimentatore esterno, non dimenticare di collegare insieme i GND; senza massa comune il segnale non ha riferimento e il servo si muove a caso.

Pilotare i servo direttamente o con un PCA9685?

Pilotare pochi servo direttamente dai pin del microcontrollore è la soluzione più semplice. La libreria Servo di Arduino Uno usa il Timer1 per generare gli impulsi fino a 12 servo, ma nel frattempo analogWrite smette di funzionare sui pin 9 e 10. L'ESP32 dedica a ogni servo un canale PWM hardware e il Pico ha 16 canali PWM. Quando superi i 5 o 6 servo, quando gli impulsi iniziano a tremolare o quando ti servono i pin per altro, entra in gioco il driver PCA9685: pilota 16 servo con soli due pin I2C e, dato che genera gli impulsi con il proprio clock, toglie lavoro al microcontrollore. La configurazione è spiegata in dettaglio nella guida al driver per servo PCA9685.

PiattaformaLibreriaServo direttiAttenzione
Arduino Uno / NanoServo (inclusa)Fino a 12Usa il Timer1: analogWrite non funziona su D9 e D10
Arduino MegaServo (inclusa)Fino a 48Con tanti servo serve comunque l'alimentazione esterna
ESP32ESP32ServoFino a 16GPIO 18, 19, 21, 22, 23, 25, 26, 27 sicuri; 34-39 solo ingresso
Raspberry Pi Picomachine.PWM (MicroPython)Fino a 16Due pin della stessa slice PWM condividono la frequenza; a 50 Hz non conta
PCA9685 (con qualsiasi scheda)Adafruit PWM Servo Driver16 per scheda, fino a 62 schede in cascataL'alimentazione dei servo entra dal morsetto V+ della scheda

15 progetti con servomotori: servo, quantità e metodo di pilotaggio

#ProgettoServoQuantitàPilotaggioLivello
1Controllo dell'angolo con potenziometroSG901DirettoPrincipiante
2Radar a ultrasuoniSG901DirettoPrincipiante
3Coperchio automatico del cestinoMG90S1DirettoPrincipiante
4Dispenser automatico di crocchetteMG90S o MG996R1DirettoIntermedio
5Serratura con tessera RFID o codiceMG90S1DirettoIntermedio
6Termometro a lancetta con servoSG901DirettoPrincipiante
7Testa girevole del robot che evita gli ostacoliSG901DirettoIntermedio
8Supporto pan-tilt per telecamera con joystickSG902DirettoPrincipiante
9Inseguitore solareMG90S2DirettoIntermedio
10Sbarra del passaggio a livello (plastico)SG902DirettoPrincipiante
11Apri-tenda o apri-sportello via Wi-FiMG996R1Diretto (ESP32)Intermedio
12Piattaforma autolivellante con MPU6050MG90S2DirettoAvanzato
13Braccio robotico da scrivania a 4 assiMG90S o SG904Diretto o PCA9685Intermedio
14Braccio robotico a 6 assiMG996R e MG90S6PCA9685Avanzato
15Robot ragno quadrupedeMG90S12PCA9685Avanzato

Progetti con un servo (1-7)

  • 1. Controllo dell'angolo con potenziometro: il "ciao mondo" dei servo. Converti il valore 0-1023 del potenziometro in 0-180 gradi con map() e lo scrivi sul servo. Codice e collegamenti sono in Cos'è un servomotore?; da qui in poi userai la stessa logica in tutti i progetti.
  • 2. Radar a ultrasuoni: un sensore di distanza HC-SR04 viene incollato su un SG90, il servo spazza tra 15 e 165 gradi e la distanza di ogni angolo viene inviata sulla porta seriale. Sul computer, un programma Processing trasforma questi dati nel classico schermo radar verde. I dettagli sono nel progetto radar con Arduino, il codice è più sotto.
  • 3. Coperchio automatico del cestino: un HC-SR04 sul davanti rileva una mano a meno di 20 cm, il servo apre il coperchio e lo richiude dopo qualche secondo. Se il coperchio è pesante, usa un MG90S con ingranaggi metallici al posto dell'SG90; vedi il cestino intelligente.
  • 4. Dispenser automatico di crocchette: a orari fissi il servo apre per qualche secondo lo sportello sotto il serbatoio del cibo. L'ora arriva da un modulo RTC, la porzione dipende da quanto resta aperto lo sportello. I dispenser a coclea richiedono più coppia, quindi conviene un MG996R o un servo a 360 gradi; vedi il dispenser automatico.
  • 5. Serratura con tessera RFID o codice: quando si avvicina la tessera RFID giusta o si inserisce il codice corretto sul tastierino, il servo tira il chiavistello. Dato che il chiavistello ha attrito, un MG90S con ingranaggi metallici dura molto di più.
  • 6. Termometro a lancetta con servo: fissi una lancetta alla squadretta e dietro metti un cartoncino con una scala da 0 a 40 °C; la temperatura misurata dal DHT11 viene convertita in angolo con map(). La stessa idea funziona come indicatore di umidità, livello sonoro o numero di iscritti.
  • 7. Testa girevole del robot che evita gli ostacoli: quando il robot si ferma, l'HC-SR04 montato sul servo guarda a sinistra e a destra, e il robot gira dal lato più libero. Questa semplice aggiunta lo rende molto più furbo di un robot con sensore fisso; vedi il robot che evita gli ostacoli.

Progetti con due servo (8-12)

  • 8. Supporto pan-tilt per telecamera con joystick: due SG90 sono montati uno sopra l'altro: quello sotto ruota in orizzontale (pan), quello sopra in verticale (tilt). Gli assi X e Y di un modulo joystick vengono assegnati ai due servo; sopra puoi montare una piccola telecamera, un laser o un sensore.
  • 9. Inseguitore solare: quattro LDR misurano da che lato arriva più luce e due servo orientano il pannello in orizzontale e in verticale verso la direzione più luminosa. Il vento sforza il braccio del pannello, quindi conviene usare MG90S. I dettagli sono nell'inseguitore solare, il codice per ESP32 è più sotto.
  • 10. Sbarra del passaggio a livello: per un plastico ferroviario o un progetto scolastico, due SG90 abbassano e alzano le sbarre, i LED rossi lampeggiano alternati e un buzzer dà l'avviso. L'arrivo del treno lo rileva un sensore a infrarossi o un reed; rallentare il servo dà un effetto molto realistico.
  • 11. Apri-tenda o apri-sportello via Wi-Fi: un ESP32 fa girare un piccolo web server e, toccando il pulsante sul telefono, un MG996R tira la corda della tenda o muove una griglia di ventilazione. Trattandosi di un MG996R, l'alimentatore esterno da 6 V è obbligatorio.
  • 12. Piattaforma autolivellante con MPU6050: l'accelerometro MPU6050 misura l'inclinazione della piattaforma e due servo la correggono in senso opposto per mantenere la superficie orizzontale. Ne viene fuori un semplice gimbal che tiene fermo un bicchiere d'acqua o una piccola telecamera; per reagire in fretta servono MG90S e un buon filtro.

Progetti con molti servo: braccio robotico e robot ragno (13-15)

  • 13. Braccio robotico da scrivania a 4 assi: quattro servo muovono base, spalla, gomito e pinza. Per piccoli bracci in acrilico o stampati in 3D bastano degli MG90S e tutti e quattro si possono pilotare direttamente da Arduino Uno; i servo vanno alimentati da un alimentatore esterno da 5 V 3 A. Puoi aggiungere il controllo manuale con potenziometri, il joystick o movimenti registrati e riprodotti; vedi il braccio robotico con Arduino.
  • 14. Braccio robotico a 6 assi: nei bracci metallici più grandi si usano MG996R per base, spalla e gomito e MG90S per polso e pinza. Pilotare i sei servo con un PCA9685 semplifica il cablaggio; un alimentatore da 6 V 10 A e un codice che muove i servo uno dopo l'altro invece che tutti insieme riducono i picchi di corrente. Per il carico sulla spalla guarda la tabella di coppia dell'MG996R.
  • 15. Robot ragno quadrupede: con tre articolazioni per zampa servono 12 servo, e con questi numeri il PCA9685 è quasi obbligatorio. Il peso conta, quindi si preferiscono gli MG90S, e il robot è alimentato da una batteria LiPo 2S con un BEC da 5 A. La camminata si ottiene con una tabella di pose che cambia in sequenza gli angoli di ogni zampa; il modello del braccio robotico qui sotto è un ottimo punto di partenza.
Nei robot con le ruote si usa un servo a rotazione continua a 360 gradi al posto di uno normale: invece dell'angolo si controllano velocità e verso. I dettagli sono nella guida al servo a 360 gradi FS90R. Per progetti dimostrativi si possono muovere in sincronia perfino 32 servo con due PCA9685; il progetto di coreografia di servo in cerchio di BlueGrays fa proprio questo.

Collegamento comune: Arduino Uno, ESP32 e Pico

Filo del servoArduino UnoESP32Raspberry Pi PicoAlimentatore esterno 5-6 V
Marrone / nero (GND)GNDGNDGNDNegativo (-)
Rosso (V+)5V (solo un SG90)Non collegatoNon collegatoPositivo (+)
Arancione / giallo (segnale)D9GPIO 18GP15Non collegato
GND dell'alimentatoreGND (comune)GND (comune)GND (comune)Negativo (-)

Codice del progetto 2: radar a ultrasuoni con Arduino

Il servo va su D9, il TRIG dell'HC-SR04 su D10 e l'ECHO su D11. Il servo si ferma ogni 2 gradi, aspetta 30 ms e misura la distanza; il risultato esce sulla porta seriale nel formato "angolo,distanza". Lo schermo radar di Processing o il Plotter seriale dell'IDE Arduino leggono direttamente questo formato. Il timeout di 30 ms passato a pulseIn corrisponde a circa 5 metri; se l'eco non torna, viene scritto -1. Il calcolo della distanza è spiegato nella guida all'HC-SR04.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const int SERVO_PIN = 9;     // servo sinyali / servo signal
4const int TRIG_PIN = 10;     // HC-SR04 TRIG
5const int ECHO_PIN = 11;     // HC-SR04 ECHO
6
7Servo radar;
8
9int readDistanceCm() {
10  digitalWrite(TRIG_PIN, LOW);
11  delayMicroseconds(2);
12  digitalWrite(TRIG_PIN, HIGH);                        // 10 µs tetik darbesi / 10 µs trigger pulse
13  delayMicroseconds(10);
14  digitalWrite(TRIG_PIN, LOW);
15  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL); // en fazla 30 ms (~5 m) / max 30 ms (~5 m)
16  if (us == 0) return -1;                              // yankı yok / no echo
17  return us * 0.0343 / 2;                              // µs -> cm
18}
19
20void scanTo(int angle) {
21  radar.write(angle);
22  delay(30);                                           // servo yerine otursun / let the servo settle
23  int d = readDistanceCm();
24  Serial.print(angle);                                 // "açı,mesafe" satırı / "angle,distance" line
25  Serial.print(',');
26  Serial.println(d);
27}
28
29void setup() {
30  Serial.begin(9600);
31  pinMode(TRIG_PIN, OUTPUT);
32  pinMode(ECHO_PIN, INPUT);
33  radar.attach(SERVO_PIN);
34}
35
36void loop() {
37  for (int a = 15; a <= 165; a += 2) scanTo(a);       // soldan sağa / left to right
38  for (int a = 165; a >= 15; a -= 2) scanTo(a);       // sağdan sola / right to left
39}

Codice del progetto 13: braccio robotico con più servo senza delay

In un braccio robotico tutte le articolazioni devono muoversi insieme e in modo fluido. Se scrivi direttamente l'angolo finale di ogni servo con write(), i servo ci saltano alla massima velocità, il braccio traballa e i picchi di corrente crescono. Il modello qui sotto avvicina ogni articolazione al suo obiettivo un grado alla volta con millis(); l'array STEP_MS stabilisce la velocità di ciascuna. Aggiungendo righe alla tabella POSES scrivi la tua sequenza di movimenti, e la stessa struttura va bene anche per pan-tilt, sbarra o robot ragno.

C++ (Arduino IDE)
1#include <Servo.h>
2
3// 4 eksenli robot kol: taban, omuz, dirsek, kıskaç / 4-axis robot arm: base, shoulder, elbow, gripper
4const byte JOINTS = 4;
5const byte PINS[JOINTS] = {3, 5, 6, 9};
6const unsigned int STEP_MS[JOINTS] = {15, 20, 20, 8};   // 1 derece için bekleme (ms) / wait per degree (ms)
7
8// Hareket sırası: her satır bir poz / move sequence: each row is a pose
9const int POSES[][JOINTS] = {
10  {90, 90, 90, 30},     // başlangıç / home
11  {40, 120, 60, 30},    // nesneye uzan / reach the object
12  {40, 120, 60, 90},    // kıskacı kapat / close the gripper
13  {140, 80, 100, 90},   // taşı / carry
14  {140, 80, 100, 30}    // bırak / release
15};
16const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
17
18Servo servos[JOINTS];
19int current[JOINTS], target[JOINTS];
20unsigned long lastStep[JOINTS];
21byte pose = 0;
22
23// Servoyu hedefe 1 derece yaklaştırır, delay kullanmaz / moves a servo 1 degree closer, no delay
24bool updateJoint(byte i) {
25  if (current[i] == target[i]) return true;            // hedefte / at target
26  if (millis() - lastStep[i] < STEP_MS[i]) return false;
27  lastStep[i] = millis();
28  current[i] += (target[i] > current[i]) ? 1 : -1;
29  servos[i].write(current[i]);
30  return current[i] == target[i];
31}
32
33void setup() {
34  for (byte i = 0; i < JOINTS; i++) {
35    current[i] = target[i] = POSES[0][i];
36    servos[i].write(current[i]);                       // attach öncesi başlangıç açısı / start angle before attach
37    servos[i].attach(PINS[i]);
38  }
39  delay(1000);
40}
41
42void loop() {
43  bool allDone = true;
44  for (byte i = 0; i < JOINTS; i++) {
45    if (!updateJoint(i)) allDone = false;              // hepsi aynı anda hareket eder / all move together
46  }
47  if (allDone) {                                       // poz tamam, sıradakine geç / pose reached, next one
48    delay(500);
49    pose = (pose + 1) % POSE_COUNT;
50    for (byte i = 0; i < JOINTS; i++) target[i] = POSES[pose][i];
51  }
52}

Chiamare write() prima di attach() evita che all'accensione il servo salti prima a 90 gradi e poi vada alla posa iniziale. I servo sono su D3, D5, D6 e D9; dato che la libreria Servo può usare qualsiasi pin digitale, non serve che il pin abbia il segno PWM. Se Arduino si riavvia mentre il braccio si muove, il problema non è il codice ma l'alimentazione; segui la lista di controllo della guida al servo che trema.

Codice del progetto 9: inseguitore solare con ESP32

Sull'ESP32 la libreria Servo di Arduino non funziona; al suo posto devi installare la libreria ESP32Servo, che gira con lo stesso codice sia sui core 2.x sia sui 3.x. Ciascuna delle quattro LDR va tra 3V3 e un pin analogico, e da quel pin una resistenza da 10 kΩ verso GND; con più luce la lettura aumenta. Abbiamo collegato le LDR ai pin dell'ADC1 (32-35), perché i pin dell'ADC2 non si possono leggere con il Wi-Fi acceso. Se il pannello gira dalla parte sbagliata, il tuo montaggio del servo è diverso: basta scambiare l'1 e il -1 nel codice. Come una LDR misura la luce è spiegato in sensore di luce LDR.

C++ (Arduino IDE)
1#include <ESP32Servo.h>
2
3const int PAN_PIN = 18;      // yatay servo / horizontal servo
4const int TILT_PIN = 19;     // dikey servo / vertical servo
5// LDR'ler ADC1 pinlerinde (Wi-Fi ile çakışmaz) / LDRs on ADC1 pins (no Wi-Fi conflict)
6const int LDR_TL = 32, LDR_TR = 33, LDR_BL = 34, LDR_BR = 35;
7const int TOLERANCE = 80;    // bu farkın altında hareket etme / ignore smaller differences
8
9Servo pan, tilt;
10int panAngle = 90, tiltAngle = 45;
11
12void setup() {
13  analogReadResolution(12);                 // 0-4095
14  pan.setPeriodHertz(50);                   // standart servo 50 Hz / standard servo 50 Hz
15  tilt.setPeriodHertz(50);
16  pan.attach(PAN_PIN, 500, 2400);           // darbe aralığı (µs) / pulse range (µs)
17  tilt.attach(TILT_PIN, 500, 2400);
18  pan.write(panAngle);
19  tilt.write(tiltAngle);
20}
21
22void loop() {
23  int tl = analogRead(LDR_TL), tr = analogRead(LDR_TR);
24  int bl = analogRead(LDR_BL), br = analogRead(LDR_BR);
25  int top = (tl + tr) / 2, bottom = (bl + br) / 2;
26  int left = (tl + bl) / 2, right = (tr + br) / 2;
27
28  // Daha aydınlık tarafa 1 derece dön / turn 1 degree toward the brighter side
29  if (abs(left - right) > TOLERANCE) panAngle += (left > right) ? 1 : -1;
30  if (abs(top - bottom) > TOLERANCE) tiltAngle += (top > bottom) ? 1 : -1;
31  panAngle = constrain(panAngle, 5, 175);
32  tiltAngle = constrain(tiltAngle, 10, 90);
33
34  pan.write(panAngle);
35  tilt.write(tiltAngle);
36  delay(25);
37}

Servo con Raspberry Pi Pico (MicroPython)

Il Pico non ha bisogno di librerie aggiuntive: con machine.PWM generi un segnale a 50 Hz e imposti la larghezza dell'impulso in nanosecondi. La funzione set_angle() qui sotto converte 0-180 gradi nell'intervallo 500-2400 µs; se il servo ronza agli estremi, restringi questi limiti. I pin del Pico escono a 3,3 V e SG90, MG90S e MG996R funzionano senza problemi con questo livello di segnale, ma l'alimentazione del servo deve comunque arrivare da VBUS (5 V dell'USB) o da un alimentatore esterno. Applicando la stessa funzione a una lista di oggetti PWM puoi portare sul Pico tutti i progetti visti sopra.

MicroPython
1from machine import Pin, PWM
2import time
3
4servo = PWM(Pin(15))         # GP15 sinyal / GP15 signal
5servo.freq(50)               # 50 Hz = 20 ms periyot / 20 ms period
6
7def set_angle(angle, min_us=500, max_us=2400):
8    angle = max(0, min(180, angle))                 # 0-180 arası sınırla / clamp to 0-180
9    us = min_us + (max_us - min_us) * angle / 180   # açı -> darbe (µs) / angle -> pulse (µs)
10    servo.duty_ns(int(us * 1000))                   # µs -> ns
11
12while True:
13    for a in range(0, 181, 2):                      # 0 -> 180 derece / degrees
14        set_angle(a)
15        time.sleep_ms(15)
16    for a in range(180, -1, -2):                    # 180 -> 0 derece / degrees
17        set_angle(a)
18        time.sleep_ms(15)

Errori comuni nei progetti con servomotori

  • Arduino si riavvia quando il servo si muove: i servo sono alimentati dal pin 5V che arriva dall'USB. Usa un alimentatore esterno, GND comune e un condensatore da 470-1000 µF.
  • Il servo ronza e si scalda agli estremi: a 0 o 180 gradi spinge contro il fine corsa meccanico. Riduci l'intervallo a 5-175 gradi o calibra i limiti dell'impulso in attach().
  • Il servo trema: alimentazione debole, cavi lunghi e sottili o rumore sul potenziometro. Usa cavi più spessi, filtra la lettura e aggiungi una zona morta che ignori le piccole variazioni.
  • analogWrite non funziona su D9 e D10: su Arduino Uno la libreria Servo usa il Timer1. Sposta il PWM di LED o motori su D3, D5, D6 o D11.
  • Il braccio non solleva il carico: la coppia si divide per la lunghezza del braccio. Accorcia il braccio, alleggerisci il carico o passa alla taglia di servo superiore (da SG90 a MG90S, da MG90S a MG996R).
  • Gli ingranaggi in plastica si sono rotti: il meccanismo blocca il servo o il braccio è stato girato a mano con forza. Dove c'è sforzo continuo usa servo con ingranaggi metallici e non girare la squadretta a mano.
Prima di chiudere il progetto in una scatola, avvia il codice senza squadretta montata e, con il comando a 90 gradi attivo, inserisci la squadretta in modo che stia al centro. Così il meccanismo ha la stessa corsa nelle due direzioni e il servo non sbatte contro il fine corsa alla prima prova.

Una volta capito come funzionano, i servomotori aprono la porta a progetti infiniti; le stesse poche righe di codice muovono un radar come un braccio robotico. Se vuoi realizzare passo passo alcuni di questi progetti, nell'app BlueGrays trovi il controllo del servo con potenziometro, il servo con joystick, il servo con ESP32, la serratura RFID con servo, il robot che evita gli ostacoli e la coreografia di 32 servo in cerchio, ognuno con schema dei collegamenti e codice.

Domande frequenti

Cosa si può fare con un servomotore?

Tutto ciò che deve raggiungere un angolo e restarci: radar, braccio robotico, serratura, inseguitore solare, dispenser di crocchette, supporto pan-tilt per telecamera e robot che camminano sono gli esempi più popolari. Con i servo a 360 gradi si costruiscono anche piccoli robot con le ruote.

Quanti servo si possono collegare ad Arduino?

La libreria Servo pilota direttamente fino a 12 servo su Arduino Uno e fino a 48 sul Mega. Il vero limite di solito lo mette l'alimentatore, non il numero di pin. Oltre 5 o 6 servo un driver PCA9685 riduce cavi e tremolii; una scheda ne pilota 16, più schede in cascata centinaia.

Meglio comprare un SG90 o un MG996R?

Per coperchi leggeri, orientare sensori e piccoli bracci basta un SG90. Carichi pesanti, la spalla di un braccio robotico o meccanismi sotto sforzo continuo richiedono l'MG996R con ingranaggi metallici e fino a 11 kg·cm, che però vuole un alimentatore esterno capace di dare 3 A per servo.

Si può alimentare un servo dal pin 5V di Arduino?

Solo un SG90 con poco carico. Se colleghi più servo o uno grande, i picchi di corrente fanno calare la tensione e Arduino si riavvia. Usa un alimentatore esterno da 5-6 V e collega il suo GND al GND di Arduino.

Perché il mio servomotore trema?

La causa più comune è un'alimentazione insufficiente, seguita dalla mancanza di GND comune, da letture rumorose del potenziometro e dal servo che spinge contro il fine corsa. Alimentatore esterno, condensatore, lettura filtrata e un intervallo ridotto come 5-175 gradi risolvono la maggior parte dei casi.

Come si controlla un servo con l'ESP32?

Sull'ESP32 si usa la libreria ESP32Servo invece della libreria Servo standard; attach(pin, 500, 2400) e write(angolo) funzionano come su Arduino. Scegli pin che possono fare da uscita, come GPIO 18, 19 o 25, e alimenta il servo a 5 V, non dal pin a 3,3 V dell'ESP32.

Vedi tutti i progetti
Utilizzo del servomotore
AR-35Principiante
Premium

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.

4.7(48)
67
Funzionamento del servomotore con potenziometro
AR-36Principiante
Premium

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.

4.6(37)
53
Servocomando con joystick
AR-60Intermedio
Premium

Servocomando con joystick

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

4.7(42)
58
Servomotore ESP32 (controllo tramite potenziometro)
ES-16Intermedio
Premium

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.

4.3(29)
42
Serratura RFID ESP32 (RC522 + servomotore + OLED + cicalino + LED)
ES-35Avanzato
Premium

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.

4.8(9)
16
Coreografia di servo in cerchio - Animazioni con 32 servomotori
AR-97Avanzato
Premium

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.

4.5(40)
62
Robot che evita gli ostacoli
AR-81Avanzato
Premium

Robot che evita gli ostacoli

Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.

5.0(38)
49