Mano robotica con Arduino, sensori di flessione e servomotori
Costruiamo una mano robotica che replica il movimento delle dita di un guanto usando cinque sensori di flessione e cinque servomotori controllati da Arduino.


Come funziona la mano robotica
Ogni dito del guanto monta un sensore di flessione. Quando il dito si piega, la resistenza del sensore cambia e Arduino rileva una variazione sul relativo ingresso analogico. Le cinque letture vengono quindi trasformate in cinque posizioni per i servomotori.
I servo sono collegati alle dita della mano tramite fili o tiranti. Ruotando, tendono il filo e provocano la chiusura del dito. Quando il servo torna verso la posizione iniziale, il dito può riaprirsi grazie alla struttura meccanica o a elementi elastici.
Il sensore di flessione
Flex sensor utilizzato per rilevare la curvatura delle dita.
Il flex sensor è un componente resistivo la cui resistenza varia quando viene piegato. Per trasformare questa variazione in una tensione leggibile da Arduino viene utilizzato in un partitore resistivo.
Materiale necessario
🧰 Kit Arduino consigliato
Un kit completo è utile per avere breadboard, cavetti, resistenze e molti componenti di base per sperimentare con Arduino.
👉 Guarda il kit Arduino consigliatoLink di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
📘 Vuoi imparare Arduino passo dopo passo?
Nei miei libri trovi spiegazioni, schemi e molti progetti pratici dedicati ad Arduino.
👉 Scopri i miei libri su ArduinoLink di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
Costruire la parte meccanica
La struttura della mano può essere realizzata con stampa 3D oppure utilizzando un kit meccanico già pronto. È importante che ogni dito possa muoversi liberamente e che il filo collegato al servo non incontri attriti eccessivi.
Esempio di struttura meccanica per la mano robotica.
Prima fase: calibrare i flex sensor
Prima di comandare i servo conviene misurare i valori reali prodotti dai sensori. Nel montaggio mostrato, con il dito piegato vengono letti valori indicativamente intorno a 400-450, mentre con la mano aperta si arriva circa a 650-700.
Questi numeri non sono universali: ogni sensore, partitore e montaggio può restituire valori differenti. Per questo la calibrazione va effettuata sulla propria mano.
// Lettura di un sensore di flessione per la calibrazione
const int flexPin = A3;
void setup() {
Serial.begin(9600);
}
void loop() {
int valore = analogRead(flexPin);
Serial.println(valore);
delay(200);
}
⬇️ Scarica lo sketch di calibrazione
Schema completo
Schema di collegamento della mano robotica. L’immagine viene mantenuta a 702 px, riducendosi automaticamente sui display più piccoli.
Collegamenti dei cinque servo
| Dito | Servo | Flex sensor |
|---|---|---|
| Pollice | D3 | A0 |
| Indice | D6 | A1 |
| Medio | D5 | A2 |
| Anulare | D9 | A3 |
| Mignolo | D10 | A4 |
Simulazione Tinkercad
▶️ Apri la simulazione Tinkercad
Da valore analogico ad angolo del servo
Arduino legge ogni flex sensor con analogRead(). Se, ad esempio, la zona utile è compresa tra 400 e 700, dobbiamo trasformare questo intervallo nel campo di movimento del servo compreso tra 0° e 180°.
Invece di affidarsi a una sola costante, è più pratico definire il valore minimo e massimo ottenuti durante la calibrazione e usare map(). In questo modo puoi adattare facilmente il progetto ai tuoi sensori.
Codice Arduino completo commentato
#include <Servo.h>
// ----------------------------------------------------------
// MANO ROBOTICA CON 5 FLEX SENSOR E 5 SERVOMOTORI
// ----------------------------------------------------------
// Servomotori
Servo thumbServo;
Servo indexServo;
Servo middleServo;
Servo ringServo;
Servo pinkyServo;
// Pin dei servo
const int thumbServoPin = 3;
const int indexServoPin = 6;
const int middleServoPin = 5;
const int ringServoPin = 9;
const int pinkyServoPin = 10;
// Pin analogici dei sensori di flessione
const int thumbFlexPin = A0;
const int indexFlexPin = A1;
const int middleFlexPin = A2;
const int ringFlexPin = A3;
const int pinkyFlexPin = A4;
// Valori di calibrazione indicativi.
// Nel montaggio di esempio i flex sensor leggono circa:
// 400-450 con il dito piegato
// 650-700 con il dito disteso.
const int flexMin = 400;
const int flexMax = 700;
// Converte il valore del flex sensor in un angolo 0-180°.
int flexToAngle(int flexValue) {
// Limita il valore alla zona di calibrazione.
flexValue = constrain(flexValue, flexMin, flexMax);
// Mano distesa (valore alto) -> servo vicino a 0°
// Mano piegata (valore basso) -> servo vicino a 180°.
int angle = map(
flexValue,
flexMax,
flexMin,
0,
180
);
return constrain(angle, 0, 180);
}
void setup() {
Serial.begin(9600);
// Collega ogni oggetto Servo al relativo pin.
thumbServo.attach(thumbServoPin);
indexServo.attach(indexServoPin);
middleServo.attach(middleServoPin);
ringServo.attach(ringServoPin);
pinkyServo.attach(pinkyServoPin);
// Posizione iniziale.
thumbServo.write(0);
indexServo.write(0);
middleServo.write(0);
ringServo.write(0);
pinkyServo.write(0);
delay(1500);
}
void loop() {
// Legge i cinque sensori.
int thumbFlex = analogRead(thumbFlexPin);
int indexFlex = analogRead(indexFlexPin);
int middleFlex = analogRead(middleFlexPin);
int ringFlex = analogRead(ringFlexPin);
int pinkyFlex = analogRead(pinkyFlexPin);
// Converte ogni lettura nel relativo angolo.
int thumbAngle = flexToAngle(thumbFlex);
int indexAngle = flexToAngle(indexFlex);
int middleAngle = flexToAngle(middleFlex);
int ringAngle = flexToAngle(ringFlex);
int pinkyAngle = flexToAngle(pinkyFlex);
// Muove le dita della mano robotica.
thumbServo.write(thumbAngle);
indexServo.write(indexAngle);
middleServo.write(middleAngle);
ringServo.write(ringAngle);
pinkyServo.write(pinkyAngle);
// Debug sul Monitor Seriale.
Serial.print("T:");
Serial.print(thumbAngle);
Serial.print(" I:");
Serial.print(indexAngle);
Serial.print(" M:");
Serial.print(middleAngle);
Serial.print(" R:");
Serial.print(ringAngle);
Serial.print(" P:");
Serial.println(pinkyAngle);
delay(20);
}
Come funziona il codice
1. Cinque ingressi analogici
I flex sensor sono collegati ad A0, A1, A2, A3 e A4. Arduino li legge separatamente, ottenendo una misura per ciascun dito.
2. Conversione in angolo
La funzione flexToAngle() limita la lettura all’intervallo di calibrazione e usa map() per convertirla in un angolo da 0° a 180°.
3. Cinque servomotori indipendenti
Ogni angolo viene inviato al servo corrispondente tramite Servo.write(). Pollice, indice, medio, anulare e mignolo possono quindi seguire contemporaneamente il movimento del guanto.
Immagini dello sketch


Scarica lo sketch
⬇️ Scarica sketch_arduino_mano_robotica.ino
Regolare correttamente ogni dito
È normale che i cinque flex sensor non restituiscano esattamente gli stessi valori. Per una mano più precisa conviene definire una coppia minimo/massimo diversa per ciascun dito. Lo stesso vale per i servo: alcuni potrebbero non poter utilizzare l’intera escursione 0-180° senza forzare la meccanica.
Debug rapido
- controlla sul Monitor Seriale i valori di ogni flex sensor;
- calibra minimo e massimo con mano completamente aperta e chiusa;
- verifica la resistenza da 22 kΩ nel partitore di ogni sensore;
- controlla che i servo corrispondano ai pin D3, D6, D5, D9 e D10;
- usa un’alimentazione esterna adeguata per i cinque servomotori;
- collega sempre le masse in comune;
- riduci l’escursione dei servo se la mano forza a fine corsa.
Varianti del progetto
- calibrazione indipendente per ogni dito;
- movimenti più fluidi tramite media mobile delle letture;
- trasmissione wireless del guanto con due ESP32;
- feedback tattile sul guanto;
- sensori di forza sulle dita robotiche;
- mano stampata in 3D personalizzata;
- controllo remoto tramite Bluetooth o Wi-Fi.
Cosa devi ricordare
- Cinque flex sensor misurano il movimento delle cinque dita.
- Cinque servo comandano le dita della mano robotica.
- I sensori utilizzano gli ingressi A0-A4.
- I servo utilizzano D3, D6, D5, D9 e D10.
- I valori dei flex sensor devono essere calibrati sul montaggio reale.
- Per cinque servo è consigliata un’alimentazione separata da Arduino.
Domande frequenti
Perché la mano robotica non segue bene le dita?
La causa più comune è una calibrazione non adatta ai flex sensor utilizzati. Misura separatamente il valore minimo e massimo di ogni dito e regola la mappatura.
Posso alimentare tutti i servo dal pin 5 V di Arduino?
È sconsigliato. Cinque servo possono richiedere correnti elevate, soprattutto durante l’avvio o sotto carico. Usa un’alimentazione esterna adeguata e massa comune.
Perché un dito si muove al contrario?
Puoi invertire la mappatura del relativo sensore oppure modificare gli angoli minimo e massimo del servo.
Posso usare una mano stampata in 3D?
Sì. La parte elettronica non dipende dal materiale della struttura, purché ogni servo riesca a muovere il relativo dito senza sforzi eccessivi.

