Robot evita ostacoli con Arduino e sensore HC-SR04
Costruiamo un piccolo robot autonomo a due ruote capace di rilevare un ostacolo con il sensore ultrasonico HC-SR04 e cambiare direzione automaticamente.
Come funziona il robot evita ostacoli
Il sensore HC-SR04 misura continuamente la distanza davanti al robot. Finché lo spazio è libero, Arduino mantiene attivi entrambi i motori e il telaio procede in avanti.
Quando la distanza scende sotto la soglia impostata, uno dei due motori viene fermato mentre l’altro continua a girare. Le due ruote non avanzano più alla stessa velocità e il robot sterza, allontanandosi dall’ostacolo.
Esempio di robot autonomo a due ruote con sensore ultrasonico.
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?
Se vuoi approfondire e realizzare progetti più completi, puoi dare un’occhiata anche ai miei libri dedicati ad Arduino. All’interno troverai spiegazioni semplici, schemi chiari e molti progetti pratici pensati per chi parte da zero.
👉 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.
Scegliere il chassis
Per il progetto è sufficiente un piccolo telaio a due ruote con due motoriduttori DC e una ruota libera di appoggio. Il supporto deve lasciare abbastanza spazio per Arduino, batteria, sensore e circuito di pilotaggio.
Pilotare correttamente i motori
Due motori DC non devono essere alimentati direttamente dai pin di Arduino. Nel circuito mostrato vengono utilizzati transistor BC547B come stadio di pilotaggio, ma questa soluzione è adatta soltanto a motori molto piccoli e con corrente compatibile con i transistor impiegati.
Transistor BC547B utilizzato nello stadio di pilotaggio mostrato.
Schema del circuito
Schema del robot evita ostacoli. L’immagine mantiene una larghezza massima di 567 px.
Collegamenti principali
| Elemento | Pin Arduino |
|---|---|
| HC-SR04 ECHO | D2 |
| HC-SR04 TRIG | D3 |
| Motore destro / stadio di pilotaggio | D8 |
| Motore sinistro / stadio di pilotaggio | D9 |
Come HC-SR04 misura la distanza
Arduino genera un impulso di 10 microsecondi sul pin TRIG. HC-SR04 emette una raffica ultrasonica e porta ECHO a livello HIGH per un tempo proporzionale al percorso compiuto dal suono.
La conversione rapida utilizzata nel programma è:
Il risultato è sufficiente per stabilire se davanti al robot c’è spazio libero oppure un ostacolo abbastanza vicino da richiedere una sterzata.
Codice Arduino commentato
// ==========================================================
// ROBOT EVITA OSTACOLI CON ARDUINO E HC-SR04
// Due motori DC + sensore a ultrasuoni
// ==========================================================
// Motore destro
const int MOTORE_DESTRO = 8;
// Motore sinistro
const int MOTORE_SINISTRO = 9;
// Sensore HC-SR04
const int ECHO_PIN = 2;
const int TRIG_PIN = 3;
// Soglia di rilevamento ostacolo in centimetri
const int SOGLIA_OSTACOLO = 25;
void setup() {
Serial.begin(9600);
// Uscite che comandano i due stadi di pilotaggio dei motori
pinMode(MOTORE_DESTRO, OUTPUT);
pinMode(MOTORE_SINISTRO, OUTPUT);
// HC-SR04
pinMode(ECHO_PIN, INPUT);
pinMode(TRIG_PIN, OUTPUT);
// Stato iniziale: motori spenti
digitalWrite(MOTORE_DESTRO, LOW);
digitalWrite(MOTORE_SINISTRO, LOW);
}
void loop() {
// --------------------------------------------------------
// 1. GENERA L'IMPULSO TRIGGER
// --------------------------------------------------------
digitalWrite(TRIG_PIN, LOW);
delayMicroseconds(2);
digitalWrite(TRIG_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);
// --------------------------------------------------------
// 2. MISURA LA DURATA DELL'ECO
// Timeout di 30 ms per evitare attese troppo lunghe
// --------------------------------------------------------
unsigned long durata = pulseIn(ECHO_PIN, HIGH, 30000UL);
// Se non arriva un eco valido, durata vale 0
int distanza = 0;
if (durata > 0) {
// Conversione approssimata microsecondi -> centimetri
distanza = durata / 58;
}
// Mostra il valore sul Monitor Seriale
Serial.print("Distanza: ");
if (distanza == 0) {
Serial.println("fuori portata / eco non valido");
} else {
Serial.print(distanza);
Serial.println(" cm");
}
// --------------------------------------------------------
// 3. LOGICA DI MOVIMENTO
// --------------------------------------------------------
// Ostacolo rilevato entro la soglia:
// mantiene in movimento il motore sinistro
// e ferma quello destro, facendo ruotare il robot.
if (distanza > 0 && distanza < SOGLIA_OSTACOLO) {
digitalWrite(MOTORE_SINISTRO, HIGH);
digitalWrite(MOTORE_DESTRO, LOW);
// Tempo necessario per effettuare la sterzata.
// Va regolato in base a chassis, ruote e motori.
delay(500);
}
else {
// Nessun ostacolo vicino: entrambi i motori avanti
digitalWrite(MOTORE_SINISTRO, HIGH);
digitalWrite(MOTORE_DESTRO, HIGH);
}
// Piccola pausa tra due misure
delay(30);
}
Come funziona il codice
1. Misura della distanza
Arduino invia l’impulso al TRIG e misura la durata di ECHO con pulseIn(). È stato aggiunto un timeout per evitare che una misura mancante possa bloccare il programma troppo a lungo.
2. Robot in marcia
Quando non viene rilevato un ostacolo entro 25 cm, entrambi i motori vengono portati HIGH e il robot procede in avanti.
3. Ostacolo rilevato
Quando la distanza è valida e inferiore alla soglia, il motore destro viene fermato mentre quello sinistro resta attivo. Il robot ruota per circa 500 ms.
4. Valore zero
Una lettura pari a zero viene trattata come eco non valido o fuori portata e non viene interpretata come un ostacolo a distanza zero.
Regolare la soglia di intervento
La distanza di 25 cm è definita dalla costante:
const int SOGLIA_OSTACOLO = 25;
Puoi aumentarla se il robot viaggia velocemente o ha bisogno di più spazio per girare, oppure ridurla se vuoi che si avvicini maggiormente agli oggetti prima di sterzare.
Regolare il tempo di sterzata
Il valore delay(500) determina per quanto tempo il robot mantiene fermo un motore. La rotazione reale dipende da velocità dei motori, diametro delle ruote, batteria, peso e attrito.
Alimentazione
I motori possono generare disturbi e picchi di corrente. Usa un’alimentazione adeguata al telaio e ai motoriduttori e assicurati che la massa dello stadio motori sia riferita correttamente alla GND di Arduino.
Scarica lo sketch
⬇️ Scarica sketch_arduino_robot_evita_ostacoli.ino
Debug rapido
- controlla TRIG su D3 ed ECHO su D2;
- verifica le distanze sul Monitor Seriale a 9600 baud;
- controlla che entrambi i motori girino nello stesso verso quando sono attivi;
- se il robot gira continuamente, verifica HC-SR04 e soglia di distanza;
- se non gira abbastanza, aumenta il tempo di sterzata;
- se un motore è debole, controlla alimentazione e stadio di pilotaggio;
- se Arduino si resetta quando partono i motori, controlla l’alimentazione e la gestione dei disturbi.
Varianti del progetto
- montare HC-SR04 su un servomotore per guardare a destra e sinistra;
- usare un ponte H per poter andare anche in retromarcia;
- regolare la velocità dei motori con PWM;
- aggiungere sensori laterali;
- aggiungere LED o buzzer di segnalazione;
- controllare il robot via Bluetooth o Wi-Fi;
- aggiungere encoder alle ruote per movimenti più precisi.
Cosa devi ricordare
- HC-SR04 controlla la distanza davanti al robot.
- ECHO è collegato a D2 e TRIG a D3.
- I due motori sono comandati tramite D8 e D9.
- Sotto i 25 cm il robot ferma una ruota e sterza.
- I motori non devono essere alimentati direttamente dai pin di Arduino.
- Soglia e tempo di sterzata vanno calibrati sul telaio reale.
Domande frequenti
Perché il robot non evita l’ostacolo?
Controlla che HC-SR04 restituisca una distanza corretta sul Monitor Seriale e verifica che il tempo di sterzata sia sufficiente per far ruotare il telaio.
Posso usare altri transistor?
Sì, ma devi scegliere un componente adatto alla corrente dei motori e verificarne pinout e caratteristiche sul datasheet. Per molti chassis è più pratico usare un driver motore dedicato.
Perché Arduino si riavvia quando partono i motori?
I motori possono provocare una forte caduta di tensione o disturbi sull’alimentazione. Usa una sorgente adatta, uno stadio di pilotaggio corretto e un cablaggio di massa adeguato.
Posso far scegliere al robot se girare a destra o a sinistra?
Sì. Una variante molto comune monta HC-SR04 su un servomotore, misura lo spazio disponibile sui due lati e sceglie la direzione con maggiore distanza libera.

