🤖 Arduino • Flex Sensor • 5 Servo

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.

Sensori5 Flex Sensor
Attuatori5 Servo
Movimento5 dita indipendenti
In poche parole: ogni flex sensor misura quanto viene piegato un dito del guanto. Arduino converte la lettura analogica in un angolo compreso tra 0° e 180° e comanda il servomotore associato allo stesso dito della mano robotica.

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

Sensore di flessione flex sensor Arduino

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.

Resistenza: nel circuito è prevista una resistenza da 22 kΩ per ciascun sensore di flessione. I valori reali dipendono dal sensore utilizzato e devono essere verificati durante la calibrazione.

Materiale necessario

🔌 Arduino Uno
🖐️ 5 sensori di flessione
⚙️ 5 servomotori
Ω 5 resistenze da 22 kΩ
🧤 Guanto
🤖 Struttura della mano robotica
🧵 Fili o tiranti per le dita
🔗 Cavetti jumper
🧩 Breadboard
🔋 Alimentazione adeguata per i servo

🧰 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 consigliato

Link 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 Arduino

Link 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.

Kit mano robotica Arduino

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.

Sketch di calibrazione del flex sensor
// 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);
}
Sketch calibrazione sensore flessione Arduino

⬇️ Scarica lo sketch di calibrazione

Schema completo

Schema Arduino mano robotica 5 flex sensor e 5 servo

Schema di collegamento della mano robotica. L’immagine viene mantenuta a 702 px, riducendosi automaticamente sui display più piccoli.

Collegamenti dei cinque servo

DitoServoFlex sensor
PolliceD3A0
IndiceD6A1
MedioD5A2
AnulareD9A3
MignoloD10A4
Alimentazione dei servo: cinque servomotori possono richiedere una corrente molto superiore a quella disponibile dal pin 5 V di Arduino. Per un funzionamento affidabile utilizza un’alimentazione esterna adeguata per i servo e collega la massa dell’alimentatore alla GND di Arduino.

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.

Esempio: mano aperta ≈ 700 → servo 0°. Dito piegato ≈ 400 → servo 180°. Se la meccanica lavora al contrario, basta invertire i due angoli nella mappatura.

Codice Arduino completo commentato

Mano robotica – 5 flex sensor + 5 servo
#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.

Buona pratica: prima di collegare i tiranti alle dita, prova ogni servo singolarmente e determina gli angoli meccanicamente sicuri. Un servo che tenta di superare il limite della struttura può assorbire molta corrente e danneggiare il meccanismo.

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.