Sensori di parcheggio
Descrizione
Questo progetto è un sistema di sensori di parcheggio anteriori e posteriori basato su una scheda Arduino, due sensori di distanza a ultrasuoni, un buzzer e tre LED di segnalazione. Un sensore a ultrasuoni monitora l'area davanti al veicolo, mentre l'altro monitora l'area dietro. L'Arduino misura continuamente entrambe le distanze, le confronta e reagisce all'ostacolo più vicino. A seconda di quanto l'ostacolo è vicino, il sistema attiva un LED verde, giallo o rosso insieme a un buzzer che emette segnali acustici a velocità differenti. Questo progetto rappresenta un'eccellente introduzione alla misurazione delle distanze tramite ultrasuoni, ai sistemi di assistenza al parcheggio, agli avvisi acustici, agli indicatori visivi e alle applicazioni di sicurezza basate su Arduino. Può essere utilizzato come base per sensori di parcheggio per automobili, sistemi di rilevamento ostacoli per robot, sistemi di assistenza alla retromarcia, dispositivi di sicurezza per garage o altre applicazioni di allerta basate sulla distanza.
Componenti necessari:
- 1x Arduino UNO
- 2x Sensore ad ultra suoni HC-SR04
- 3x LED (di colori differenti)
- 1x Buzzer
- Cavi jumper (breadboard opzionale)
Schema:
Codice:
// https://nemiatools.com
// Sensore frontale
const int F_trigPin = 4; // Pin trigger frontale
const int F_echoPin = 5; // Pin echo frontale
// Sensore posteriore
const int B_trigPin = 6; // Pin trigger posteriore
const int B_echoPin = 7; // Pin echo posteriore
const int buzzer = 10; // Pin uscita buzzer
const int green = 11; // Pin LED verde
const int yellow = 12; // Pin LED giallo
const int red = 13; // Pin LED rosso
const int BUZZER_FREQ = 120; // Frequenza buzzer
void setup() {
Serial.begin(9600); // Avvia seriale
pinMode(F_trigPin, OUTPUT); // Imposta trigger frontale
pinMode(F_echoPin, INPUT); // Imposta echo frontale
pinMode(B_trigPin, OUTPUT); // Imposta trigger posteriore
pinMode(B_echoPin, INPUT); // Imposta echo posteriore
pinMode(buzzer, OUTPUT); // Imposta uscita buzzer
pinMode(green, OUTPUT); // Imposta uscita verde
pinMode(yellow, OUTPUT); // Imposta uscita gialla
pinMode(red, OUTPUT); // Imposta uscita rossa
noTone(buzzer); // Ferma buzzer
}
float distance(int trigPin, int echoPin) { // Misura distanza
digitalWrite(trigPin, LOW); // Pulisce trigger
delayMicroseconds(2); // Breve attesa
digitalWrite(trigPin, HIGH); // Invia trigger
delayMicroseconds(10); // Impulso trigger
digitalWrite(trigPin, LOW); // Termina trigger
long pulse_duration = pulseIn(echoPin, HIGH, 30000); // Legge impulso echo
if (pulse_duration == 0) { // Nessun eco rilevato
return 999.0; // Restituisce valore lontano
}
return pulse_duration * 0.0343 / 2.0; // Converte in cm
}
void allOff() { // Spegne tutto
noTone(buzzer); // Ferma buzzer
digitalWrite(green, LOW); // Spegne verde
digitalWrite(yellow, LOW); // Spegne giallo
digitalWrite(red, LOW); // Spegne rosso
}
void warnFar() { // Avviso distanza lontana
tone(buzzer, BUZZER_FREQ); // Avvia buzzer
digitalWrite(green, HIGH); // Accende verde
delay(100); // Beep breve
noTone(buzzer); // Ferma buzzer
digitalWrite(green, LOW); // Spegne verde
delay(300); // Pausa lunga
}
void warnClose() { // Avviso distanza vicina
tone(buzzer, BUZZER_FREQ); // Avvia buzzer
digitalWrite(yellow, HIGH); // Accende giallo
delay(100); // Beep breve
noTone(buzzer); // Ferma buzzer
digitalWrite(yellow, LOW); // Spegne giallo
delay(200); // Pausa media
}
void warnVeryClose() { // Avviso distanza molto vicina
tone(buzzer, BUZZER_FREQ); // Avvia buzzer
digitalWrite(red, HIGH); // Accende rosso
delay(100); // Beep breve
noTone(buzzer); // Ferma buzzer
digitalWrite(red, LOW); // Spegne rosso
delay(100); // Pausa breve
}
void loop() {
float F_distance = distance(F_trigPin, F_echoPin); // Legge distanza frontale
delay(20); // Piccolo ritardo
float B_distance = distance(B_trigPin, B_echoPin); // Legge distanza posteriore
delay(20); // Piccolo ritardo
Serial.print("Front distance: "); // Stampa etichetta frontale
Serial.print(F_distance); // Stampa valore frontale
Serial.println(" cm"); // Stampa unità
Serial.print("Rear distance: "); // Stampa etichetta posteriore
Serial.print(B_distance); // Stampa valore posteriore
Serial.println(" cm"); // Stampa unità
Serial.println("--------------------"); // Stampa separatore
float minDistance = min(F_distance, B_distance); // Trova oggetto più vicino
if (minDistance <= 15) { // Controllo molto vicino
warnVeryClose(); // Avviso rosso
}
else if (minDistance <= 30) { // Controllo vicino
warnClose(); // Avviso giallo
}
else if (minDistance <= 50) { // Controllo lontano
warnFar(); // Avviso verde
}
else { // Nessun pericolo
allOff(); // Disabilita uscite
delay(100); // Breve inattività
}
}Come funziona:
Questo progetto funziona come un semplice sensore di parcheggio anteriore e posteriore. L'Arduino utilizza due sensori a ultrasuoni per misurare la distanza dagli ostacoli: un sensore è posizionato nella parte anteriore e uno nella parte posteriore.
Le righe const int F_trigPin = 4; e const int F_echoPin = 5; definiscono i pin trigger ed echo del sensore anteriore. Le righe const int B_trigPin = 6; e const int B_echoPin = 7; definiscono i pin trigger ed echo del sensore posteriore.
Il pin trigger invia un breve impulso ultrasonico, mentre il pin echo riceve il segnale riflesso. Misurando il tempo impiegato dal segnale per tornare indietro, l'Arduino può calcolare la distanza dall'ostacolo.
Le righe const int buzzer = 10;, const int green = 11;, const int yellow = 12; e const int red = 13; definiscono i pin di uscita utilizzati per gli avvisi sonori e visivi.
All'interno della funzione setup(), i pin trigger dei sensori vengono configurati come uscite, i pin echo come ingressi e il buzzer e i LED come uscite. La riga noTone(buzzer); mantiene il buzzer silenzioso all'avvio del sistema.
La parte più importante del codice è la funzione float distance(int trigPin, int echoPin). Questa funzione invia un impulso di 10 microsecondi al sensore a ultrasuoni utilizzando digitalWrite(trigPin, HIGH); e delayMicroseconds(10);.
Successivamente, la riga long pulse_duration = pulseIn(echoPin, HIGH, 30000); misura il tempo impiegato dall'onda ultrasonica per raggiungere l'ostacolo e tornare indietro. Se non viene ricevuto alcun segnale, il codice restituisce 999.0, indicando che non è stato rilevato alcun ostacolo vicino.
La riga return pulse_duration * 0.0343 / 2.0; converte il tempo misurato in centimetri. Il valore 0.0343 rappresenta la velocità approssimativa del suono in centimetri per microsecondo. La divisione per 2.0 è necessaria perché il suono percorre due volte la distanza: dal sensore all'ostacolo e poi di nuovo al sensore.
Nel loop(), l'Arduino legge la distanza anteriore con float F_distance = distance(F_trigPin, F_echoPin); e la distanza posteriore con float B_distance = distance(B_trigPin, B_echoPin);. Le istruzioni del Monitor Seriale servono solamente a visualizzare questi valori durante i test.
La riga float minDistance = min(F_distance, B_distance); seleziona l'ostacolo più vicino tra quello rilevato dal sensore anteriore e quello rilevato dal sensore posteriore. Questo è il valore utilizzato per decidere quale livello di avviso attivare.
Se l'ostacolo più vicino è molto vicino, la condizione if (minDistance <= 15) richiama warnVeryClose();. Questa funzione accende il LED rosso e fa emettere al buzzer segnali acustici più rapidi.
Se l'ostacolo si trova a una distanza intermedia, la condizione else if (minDistance <= 30) richiama warnClose();. Questa funzione accende il LED giallo e genera un segnale acustico a velocità media.
Se l'ostacolo è più lontano ma ancora all'interno della zona di avviso, la condizione else if (minDistance <= 50) richiama warnFar();. Questa funzione accende il LED verde e genera un segnale acustico più lento.
Se l'ostacolo si trova a una distanza superiore a 50 cm, la funzione allOff(); spegne il buzzer e tutti i LED.
Nel complesso, più l'ostacolo si avvicina, più urgente diventa l'avviso: il verde indica che l'ostacolo è lontano, il giallo indica che è vicino e il rosso indica che è molto vicino.
Per ottenere risultati migliori, i due sensori a ultrasuoni dovrebbero essere posizionati in modo da non interferire tra loro. Si consiglia inoltre di utilizzare un'alimentazione stabile a 5V.