🤖 Arduino • HC-SR04 • Robot

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.

SensoreHC-SR04
Motori2 DC
Soglia25 cm
In poche parole: il robot avanza con entrambi i motori attivi. Se HC-SR04 rileva un ostacolo a meno di 25 cm, Arduino ferma una ruota per circa mezzo secondo: il robot ruota e può proseguire lungo una nuova direzione.

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.

Robot Arduino evita ostacoli con HC-SR04

Esempio di robot autonomo a due ruote con sensore ultrasonico.

Materiale necessario

🔌 Arduino Uno
🚗 Chassis a 2 ruote
⚙️ 2 motori DC
📡 Sensore HC-SR04
🔌 2 stadi di pilotaggio per i motori
🔋 Alimentazione per robot e motori
🔗 Cavetti di collegamento
🧩 Breadboard per la prototipazione

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

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 Arduino

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

Transistor BC547B utilizzato nello stadio di pilotaggio mostrato.

Prima di collegare i motori: controlla il datasheet del transistor e misura o verifica la corrente richiesta dai tuoi motoriduttori. Il pinout può cambiare tra componenti e package differenti: identifica sempre Base, Collettore ed Emettitore dal datasheet del componente realmente utilizzato.
Per un robot più affidabile: se i motori assorbono una corrente significativa è preferibile utilizzare un vero driver per motori o un ponte H dimensionato correttamente. Questo permette inoltre di gestire meglio velocità e inversione di marcia.

Schema del circuito

Schema robot Arduino evita ostacoli con HC-SR04

Schema del robot evita ostacoli. L’immagine mantiene una larghezza massima di 567 px.

Collegamenti principali

ElementoPin Arduino
HC-SR04 ECHOD2
HC-SR04 TRIGD3
Motore destro / stadio di pilotaggioD8
Motore sinistro / stadio di pilotaggioD9

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 è:

distanza in cm ≈ durata dell’impulso / 58

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 – HC-SR04 + 2 motori
// ==========================================================
// 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:

Soglia ostacolo
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.

Calibrazione pratica: prova 250, 500 e 750 ms e scegli il valore che permette al robot di cambiare direzione senza girare troppo né troppo poco.

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.

Batteria da 9 V rettangolare: può essere poco adatta a robot con motori che richiedono correnti elevate. Se il robot perde forza, Arduino si riavvia o la tensione crolla, usa un pacco batterie più adatto alle caratteristiche dei motori e del circuito.

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.