Circuit senzor parcare inversă auto cu alarmă

În acest post vom construi un circuit de alarmă al senzorului de parcare inversă al mașinii folosind arduino, senzor cu ultrasunete și modul de emisie-recepție de 2,4 GHz. Acest proiect poate fi o caracteristică suplimentară pentru mașina dvs. dacă nu are un senzor de parcare încorporat.

Introducere

Proiectul propus are o funcționalitate similară cu cea a senzorului tradițional de parcare, cum ar fi distanța dintre mașină și obstacol pe un afișaj LCD și alarma sonoră.

Proiectul propus poate fi utilizat ca senzor de parcare staționar, adică senzorul plasat în garaj sau senzor de parcare mobil, adică senzor plasat pe spatele mașinii dvs., dacă sunteți gata să vă asumați un risc mic de a conecta proiectul cu sistemul electric al mașinii.

Totuși, motivația pe care o are acest proiect construiți un senzor de parcare staționar care poate fi construit cu risc zero.

Proiectul de alarmă a senzorului de parcare care utilizează Arduino are două părți, transmițătorul care constă din senzor cu ultrasunete, arduino, buzzer și modul transceiver de 2,4 GHz. Acest circuit va măsura distanța dintre mașină și obstacol.

Receptorul este format din modul de emisie-recepție de 2,4 GHz, arduino și afișaj LCD de 16x2.

Circuitul receptorului va fi plasat în interiorul mașinii cu baterie de 9V ca sursă de alimentare. Receptorul va afișa distanța dintre mașină și obstacol în metri.

Transmițătorul va transmite datele senzorului către receptorul din interiorul mașinii prin intermediul legăturii de 2,4 GHz. Legătura de comunicare este stabilită utilizând modulul NRF24L01.

Acum să vedem prezentarea generală a modulului NRF24L01.

Ilustrația NRF24L01:

Acest modul este conceput pentru a stabili o legătură de comunicare bidirecțională între două microcontrolere. Funcționează pe protocolul de comunicare SPI. Are 125 de canale diferite și are o rată de date maximă de 2 Mbps. Are o rază maximă teoretică de 100 de metri.

Configurarea pinului:

Funcționează pe 3,3 V, deci 5 volți pe terminalul Vcc îl pot ucide. Cu toate acestea, poate accepta semnale de date de 5V de la microcontrolere.

Acum să trecem la emițătorul proiectului.

Circuitul este cablat cu modulul NRF24L01 cu 5 fire conectate la pinii I / O digitale de arduino și restul celor doi la 3,3V și la masă. Pinul 2 este conectat la baza tranzistorului care va alimenta buzzerul.

Terminalele de alimentare ale senzorului cu ultrasunete sunt conectate la 5V și GND, iar A0 este conectat la pinul de declanșare și A1 este conectat la pinul de ecou al senzorului.

Datele la distanță ale senzorului sunt transmise prin receptor prin modulul NRF24L01.

-------------------------------------------------- ----------------------------------------- Vă rugăm să descărcați fișierul bibliotecii de pe următorul link: github.com/nRF24/RF24.git----------------------------------------- -------------------------------------------------- ---

Program pentru emițător:

//----------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-------------//

Asta încheie emițătorul.

Receptor:

Receptorul are ecran LCD 16x2 pentru afișarea măsurării distanței. Conexiunea de afișare este dată mai jos:

Reglați potențiometrul de 10K pentru un contrast de vizualizare mai bun.

Schema de mai sus este restul circuitului receptorului. Este furnizat un buton pentru resetarea arduino-ului în cazul în care conexiunea de legătură de 2,4 GHz nu este stabilită.

Circuitul receptorului este plasat în interiorul mașinii și poate fi alimentat de la o baterie de 9V. Receptorul poate fi plasat într-o cutie de gunoi care ar putea face ca mașina dvs. să arate bine. Cutia de gunoi poate fi plasată în mașina dvs. deasupra grupului de instrumente sau în orice loc convenabil doriți.

Program pentru receptor:

//--------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-------//

Acum, asta încheie receptorul.

Cum să plasați senzorul ca senzor de parcare staționar:

Cum să plasați senzorul ca senzor de parcare mobil:

În senzorul de parcare mobil, senzorul cu ultrasunete al emițătorului este plasat în partea din spate a mașinii, puterea este furnizată de la bateria mașinii. Ar trebui să fie conectat în așa fel încât, atunci când opriți contactul, arduino să se deconecteze de la sursă.

Receptorul poate fi plasat în interiorul celor menționate anterior.

Cum se operează acest proiect senzor parcare auto (tip staționar)

• Porniți mai întâi transmițătorul, mergeți la mașină și porniți receptorul. Dacă conexiunea dintre emițător și receptor este stabilită, va apărea „Conexiune: OK” și va arăta distanța dintre mașină și senzor.

• Dacă se afișează „Conexiune nu este stabilită”, apăsați butonul furnizat pe receptor.

• Poate afișa „Mașina nu se află în raza de acțiune” dacă cutia dvs. este departe de senzorul cu ultrasunete.

• Luați ușor mașina înapoi sau înainte spre parcare.

• Pe măsură ce distanța dintre mașină și senzor devine mai mică de 1,0 metri, soneria emite un bip.

• Pe măsură ce vă apropiați de senzor mai aproape, rata de semnal sonor crește, odată ce mașina atinge 1 picior sau 0,3 metri, afișajul va solicita oprirea mașinii și trebuie să vă opriți.

• Transmițătorul se va reseta și va trece automat la ralanti. Opriți receptorul din mașină. Dacă ați alimentat transmițătorul prin baterie, opriți-l și pe acesta.

Cum se operează acest circuit de alarmă pentru senzorul de parcare (senzor de parcare mobil)

• Instrucțiuni similare menționate anterior dacă receptorul afișează „Mașină care nu se află în raza de acțiune” mașina dvs. este departe de obstacol.

• Când opriți motorul, circuitul emițătorului trebuie să se oprească. Opriți manual circuitul receptorului.

Prototipul autorului:

Transmiţător:

Receptor: