Circuito sensore parcheggio retromarcia auto con allarme

In questo post costruiremo un circuito di allarme del sensore di parcheggio retromarcia per auto utilizzando arduino, sensore a ultrasuoni e modulo ricetrasmettitore a 2,4 GHz. Questo progetto può essere una funzionalità aggiuntiva per la tua auto se non dispone di sensori di parcheggio integrati.

introduzione

Il progetto proposto ha funzionalità simili a quelle del tradizionale sensore di parcheggio per auto, come la distanza tra l'auto e l'ostacolo su un display LCD e un segnale acustico.

Il progetto proposto può essere utilizzato come sensore di parcheggio stazionario, ovvero il sensore posizionato sul tuo garage o sensore di parcheggio mobile, ovvero un sensore posizionato sul retro della tua auto se sei pronto a correre un piccolo rischio di cablare il progetto con l'impianto elettrico dell'auto.

Tuttavia, la motivazione a cui è destinato questo progetto costruire un sensore di parcheggio stazionario che può essere costruito senza rischi.

Il progetto di allarme del sensore di parcheggio per auto che utilizza Arduino ha due parti, il trasmettitore che consiste in un sensore a ultrasuoni, arduino, cicalino e modulo ricetrasmettitore a 2,4 GHz. Questo circuito misurerà la distanza tra l'auto e l'ostacolo.

Il ricevitore è composto da un modulo ricetrasmettitore da 2,4 GHz, arduino e display LCD 16x2.

Il circuito del ricevitore sarà posizionato all'interno dell'auto con batteria da 9V come alimentazione. Il ricevitore visualizzerà la distanza tra l'auto e l'ostacolo in metri.

Il trasmettitore trasmetterà i dati del sensore al ricevitore all'interno dell'auto tramite un collegamento a 2,4 GHz. Il collegamento di comunicazione viene stabilito utilizzando il modulo NRF24L01.

Vediamo ora la panoramica del modulo NRF24L01.

Illustrazione di NRF24L01:

Questo modulo è progettato per stabilire un collegamento di comunicazione bidirezionale tra due microcontrollori. Funziona su protocollo di comunicazione SPI. Dispone di 125 canali diversi e ha una velocità dati massima di 2 Mbps. Ha una portata massima teorica di 100 metri.

Configurazione dei pin:

Funziona a 3,3 V, quindi 5 volt sul terminale Vcc possono ucciderlo. Tuttavia, può accettare segnali dati a 5V da microcontrollori.

Ora passiamo al trasmettitore del progetto.

Il circuito è cablato con il modulo NRF24L01 con 5 fili collegati ai pin I / O digitali di arduino e il resto dei due a 3,3 V e massa. Il pin # 2 è collegato alla base del transistor che alimenterà il buzzer.

I terminali di alimentazione del sensore a ultrasuoni sono collegati a 5V e GND e A0 è collegato al pin di attivazione e A1 è collegato al pin di eco del sensore.

I dati sulla distanza del sensore vengono trasmessi tramite il modulo NRF24L01 al ricevitore.

-------------------------------------------------- ----------------------------------------- Scarica il file della libreria dal seguente link: github.com/nRF24/RF24.git----------------------------------------- -------------------------------------------------- ---

Programma per trasmettitore:

//----------Program Developed by R.Girish-------------//
#include
#include
RF24 radio(7,8)
const byte address[][6] = {'00001', '00002'}
const int trigger = A0
const int echo = A1
const int buzzer = 2
float distance
float result
long Time
boolean state = false
boolean dummystate = 0
void setup()
{
pinMode(trigger, OUTPUT)
pinMode(buzzer, OUTPUT)
pinMode(echo, INPUT)
radio.begin()
radio.openWritingPipe(address[1])
radio.openReadingPipe(1, address[0])
radio.setChannel(100)
radio.setDataRate(RF24_250KBPS)
radio.setPALevel(RF24_PA_MAX)
radio.startListening()
while(!radio.available())
radio.read(&dummystate, sizeof(dummystate))
radio.stopListening()
if(dummystate == HIGH)
{
for(int j = 0 j <10 j++)
{
const char text[] = 'Connection:OK !!!'
radio.write(&text, sizeof(text))
delay(100)
}
}
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
delay(1000)
}
void(* resetFunc) (void) = 0
void loop()
{
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result > 2.00)
{
const char text[] = 'CAR NOT IN RANGE'
radio.write(&text, sizeof(text))
}
if(result 1.90)
{
const char text[] = 'Distance = 2.0 M'
radio.write(&text, sizeof(text))
}
if(result 1.80)
{
const char text[] = 'Distance = 1.9 M'
radio.write(&text, sizeof(text))
}
if(result 1.70)
{
const char text[] = 'Distance = 1.8 M'
radio.write(&text, sizeof(text))
}
if(result 1.60)
{
const char text[] = 'Distance = 1.7 M'
radio.write(&text, sizeof(text))
}
if(result 1.50)
{
const char text[] = 'Distance = 1.6 M'
radio.write(&text, sizeof(text))
}
if(result 1.40)
{
const char text[] = 'Distance = 1.5 M'
radio.write(&text, sizeof(text))
}
if(result 1.30)
{
const char text[] = 'Distance = 1.4 M'
radio.write(&text, sizeof(text))
}
if(result 1.20)
{
const char text[] = 'Distance = 1.3 M'
radio.write(&text, sizeof(text))
}
if(result 1.10)
{
const char text[] = 'Distance = 1.2 M'
radio.write(&text, sizeof(text))
}
if(result 1.00)
{
const char text[] = 'Distance = 1.1 M'
radio.write(&text, sizeof(text))
}
if(result 0.90)
{
state = true
const char text[] = 'Distance = 1.0 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(700)
digitalWrite(buzzer, LOW)
delay(700)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 1.0)
{
state = false
}
}
}
if(result 0.80)
{
state = true
const char text[] = 'Distance = 0.9 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(600)
digitalWrite(buzzer, LOW)
delay(600)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.90)
{
state = false
}
}
}
if(result 0.70)
{
state = true
const char text[] = 'Distance = 0.8 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(500)
digitalWrite(buzzer, LOW)
delay(500)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.80)
{
state = false
}
}
}
if(result 0.60)
{
state = true
const char text[] = 'Distance = 0.7 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(400)
digitalWrite(buzzer, LOW)
delay(400)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.70)
{
state = false
}
}
}
if(result 0.50)
{
state = true
const char text[] = 'Distance = 0.6 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(300)
digitalWrite(buzzer, LOW)
delay(300)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.60)
{
state = false
}
}
}
if(result 0.40)
{
state = true
const char text[] = 'Distance = 0.5M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(200)
digitalWrite(buzzer, LOW)
delay(200)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.50)
{
state = false
}
}
}
if(result 0.30)
{
state = true
const char text[] = 'Distance = 0.4 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(100)
digitalWrite(buzzer, LOW)
delay(100)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.40)
{
state = false
}
}
}
if(result <= 0.30)
{
const char text[] = ' STOP!!!'
radio.write(&text, sizeof(text))
digitalWrite(buzzer, HIGH)
delay(3000)
digitalWrite(buzzer, LOW)
resetFunc()
}
delay(200)
}
//----------Program Developed by R.Girish-------------//

Questo conclude il trasmettitore.

Ricevitore:

Il ricevitore ha un display LCD 16x2 per la visualizzazione della misurazione della distanza. Di seguito viene fornita la connessione del display:

Regola il potenziometro 10K per un migliore contrasto visivo.

Lo schema sopra è il resto del circuito del ricevitore. Viene fornito un pulsante per ripristinare l'arduino nel caso in cui non venga stabilita la connessione del collegamento a 2,4 GHz.

Il circuito del ricevitore è posizionato all'interno dell'auto e può essere alimentato da una batteria da 9V. Il ricevitore può essere posizionato in una scatola della spazzatura che potrebbe far sembrare la tua auto bella. La scatola della spazzatura può essere collocata nella tua auto sopra il quadro strumenti o in qualsiasi posto conveniente che desideri.

Programma per ricevitore:

//--------Program Developed by R.Girish-------//
#include
#include
#include
LiquidCrystal lcd(7, 6, 5, 4, 3, 2)
RF24 radio(9,10)
const byte address[][6] = {'00001', '00002'}
const int dummy = A0
boolean dummystate = 0
void setup()
{
Serial.begin(9600)
lcd.begin(16, 2)
pinMode(dummy , INPUT)
digitalWrite(dummy, HIGH)
radio.begin()
radio.openReadingPipe(1, address[1])
radio.openWritingPipe(address[0])
radio.setChannel(100)
radio.setDataRate(RF24_250KBPS)
radio.setPALevel(RF24_PA_MAX)
radio.stopListening()
dummystate = digitalRead(dummystate)
radio.write(&dummystate, sizeof(dummystate))
delay(10)
radio.startListening()
if(!radio.available())
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Connection not')
lcd.setCursor(0,1)
lcd.print('established')
delay(50)
}
}
void loop()
{
if(radio.available())
{
char text[32] = ''
radio.read(&text, sizeof(text))
lcd.clear()
lcd.setCursor(0,0)
lcd.print(text)
lcd.setCursor(0,1)
lcd.print('----------------')
}
}
//--------Program Developed by R.Girish-------//

Ora, questo conclude il ricevitore.

Come posizionare il sensore come sensore di parcheggio stazionario:

Come posizionare il sensore come sensore di parcheggio mobile:

Nel sensore di parcheggio mobile, il sensore a ultrasuoni del trasmettitore è posizionato sul lato posteriore dell'auto, l'alimentazione è fornita dalla batteria dell'auto. Dovrebbe essere cablato in modo tale che quando si spegne l'accensione l'arduino deve scollegarsi dall'alimentazione.

Il ricevitore può essere inserito all'interno del come accennato prima.

Come utilizzare questo progetto di sensori di parcheggio per auto (tipo stazionario)

• Accendi prima il trasmettitore, vai in macchina e accendi il ricevitore. Se viene stabilita la connessione tra trasmettitore e ricevitore, verrà visualizzato 'Connection: OK' e mostra la distanza tra l'auto e il sensore.

• Se viene visualizzato 'Connessione non stabilita', premere il pulsante fornito sul ricevitore.

• Potrebbe visualizzare 'Auto fuori portata' se la lattina è lontana dal sensore a ultrasuoni.

• Porta delicatamente la macchina in retromarcia o in avanti fino al parcheggio.

• Quando la distanza tra l'auto e il sensore diventa inferiore a 1 metro, il cicalino emette un segnale acustico.

• Man mano che ci si avvicina al sensore più vicino, la frequenza del segnale acustico aumenta, una volta che l'auto raggiunge 1 piede o 0,3 metri, il display chiede di fermare l'auto e si deve fermare.

• Il trasmettitore si resetterà e andrà in stand-by automaticamente. Spegni il ricevitore della tua auto. Se hai alimentato il trasmettitore a batteria, spegnilo anche tu.

Come utilizzare questo circuito di allarme del sensore di parcheggio dell'auto (sensore di parcheggio mobile)

• È un'istruzione simile precedentemente dichiarata se il ricevitore visualizza 'Auto fuori portata' la tua auto è lontana dall'ostacolo.

• Quando si spegne il motore, il circuito del trasmettitore deve spegnersi. Spegnere manualmente il circuito del ricevitore.

Prototipo dell'autore:

Trasmettitore:

Ricevitore: