Circuitul detectorului de viteză al vehiculului pentru poliția rutieră

În acest post vom construi un circuit care poate măsura viteza oricărui vehicul pe drumuri și autostrăzi. Circuitul propus este ținut staționar într-un loc în care se suspectează că vehiculele depășesc viteza. Dacă vreun vehicul depășește limita de viteză, circuitul alertează imediat. Vom analiza codul, schema de circuit și logica modului în care este măsurată viteza vehiculului.

Obiectiv

Viteza excesivă cauzează 75% accidente rutiere, conform raportului de decese accidentale 2015 din India, este un număr imens. Majoritatea poliției rutiere încearcă să-i rețină pe șoferii care conduc vehiculul în mod periculos dincolo de limita de viteză a orașului.

Nu de fiecare dată când poliția rutieră poate opri un vehicul care depășește viteza și îl poate încărca. Așadar, este instalat un dispozitiv numit radar, unde se suspectează că șoferii depășesc viteza, cum ar fi zonele predispuse la accidente frecvente, intersecțiile etc.

Vom construi ceva similar cu camera de viteză, dar într-un mod mult mai simplificat, care poate fi instalat într-un campus, cum ar fi școala, colegiul sau parcurile IT sau doar ca un proiect distractiv.

Proiectul propus constă din afișaj LCD de 16 x 2 pentru a prezenta viteza fiecărui vehicul care trece prin două fascicule laser, care sunt amplasate la distanță de exact 10 metri pentru a măsura viteza vehiculului în timp ce întrerupe acele fascicule laser.

Un semnal sonor va emite un sunet la trecerea unui vehicul, indicând faptul că un vehicul este detectat și viteza fiecărui vehicul va fi afișată pe afișajul LCD. Când un vehicul depășește limita de viteză, soneria va emite un sunet continuu, iar viteza vehiculului va fi afișată pe afișaj.

NOTĂ: Viteza vehiculului va fi afișată pe ecranul LCD, indiferent dacă vehiculul depășește viteza sau sub viteză.

Acum să vedem logica din spatele circuitului pentru măsurarea vitezei.

Știm cu toții o formulă simplă numită formula viteză - distanță - timp.
Viteză = Distanță / Timp.

• Viteza în metru pe secundă,
• Distanța în metri,
• Timp în secunde.

Pentru a cunoaște viteza, trebuie să știm distanța, spunem „x” parcursă de un vehicul și timpul necesar pentru a parcurge acea distanță „x”.

Pentru a face acest lucru, configurăm două raze laser și două LDR-uri cu o distanță de 10 metri în modul următor:

Știm că distanța este de 10 metri, care este fixă, acum trebuie să știm timpul din ecuație.

Timpul va fi calculat de Arduino, când vehiculul întrerupe „laserul de pornire”, începe temporizatorul și când vehiculul întrerupe „laserul final”, temporizatorul se oprește și aplicând valorile ecuației Arduino va găsi viteza vehiculului.

Vă rugăm să rețineți că viteza vehiculului va fi detectată numai într-o singură direcție, adică porniți laserul pentru a opri laserul, pentru a detecta vehiculul în altă direcție, trebuie să fie plasată o altă aceeași configurare în direcția opusă. Deci, acest lucru este ideal pentru locuri cum ar fi școala, colajul etc. unde au porți IN și OUT.

Acum, să vedem schema:

Conexiune între Arduino și afișaj:

Acolo, circuitul de mai sus este auto-explicativ și conectați cablajul conform circuitului. Reglați potențiometrul de 10K pentru reglarea contrastului afișajului.

Detalii suplimentare de cablare:

Circuitul de mai sus este format din Arduino, 4 butoane, două rezistențe de tracțiune de 10K (nu modificați valoarea rezistențelor), două LDR și un buzzer. Funcția celor 4 butoane va fi explicată în scurt timp. Acum să vedem cum să montăm LDR în mod corespunzător.

LDR trebuie să fie acoperit de lumina soarelui în mod corespunzător, doar raza laser ar trebui să lovească LDR. Asigurați-vă că modulul laser este suficient de puternic pentru a lucra într-o strălucire puternică a soarelui.
Puteți utiliza o țeavă din PVC în scopul de mai sus și o vopsiți în negru în interiorul tubului. Nu uitați să acoperiți partea din față, folosiți-vă creativitatea pentru a realiza acest lucru.

Codul programului:

// ----------- Developed by R.GIRISH ---------//
#include
#include
const int rs = 7
const int en = 6
const int d4 = 5
const int d5 = 4
const int d6 = 3
const int d7 = 2
LiquidCrystal lcd(rs, en, d4, d5, d6, d7)
const int up = A0
const int down = A1
const int Set = A2
const int change = A3
const int start = 8
const int End = 9
const int buzzer = 10
const float km_h = 3.6
int distance = 10 // In meters.
int variable = 0
int count = 0
int address = 0
int value = 100
int speed_address = 1
int speed_value = 0
int i = 0
float ms = 0
float Seconds = 0
float Speed = 0
boolean buzz = false
boolean laser = false
boolean x = false
boolean y = false
void setup()
{
pinMode(start, INPUT)
pinMode(End, INPUT)
pinMode(up, INPUT)
pinMode(down, INPUT)
pinMode(Set, INPUT)
pinMode(change, INPUT)
pinMode(buzzer, OUTPUT)
digitalWrite(change, HIGH)
digitalWrite(up, HIGH)
digitalWrite(down, HIGH)
digitalWrite(Set, HIGH)
digitalWrite(buzzer, LOW)
lcd.begin(16, 2)
lcd.clear()
lcd.setCursor(0, 0)
lcd.print(F(' Vehicle Speed'))
lcd.setCursor(0, 1)
lcd.print(F(' detector'))
delay(1500)
if (EEPROM.read(address) != value)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Set Speed Limit')
lcd.setCursor(0, 1)
lcd.print('km/h:')
lcd.setCursor(6, 1)
lcd.print(count)
while (x == false)
{
if (digitalRead(up) == LOW)
{
lcd.setCursor(6, 1)
count = count + 1
lcd.print(count)
delay(200)
}
if (digitalRead(down) == LOW)
{
lcd.setCursor(6, 1)
count = count - 1
lcd.print(count)
delay(200)
}
if (digitalRead(Set) == LOW)
{
speed_value = count
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Speed Limit is')
lcd.setCursor(0, 1)
lcd.print('set to ')
lcd.print(speed_value)
lcd.print(' km/h')
EEPROM.write(speed_address, speed_value)
delay(2000)
x = true
}
}
EEPROM.write(address, value)
}
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Testing Laser')
lcd.setCursor(0, 1)
lcd.print('Alignment....')
delay(1500)
while (laser == false)
{
if (digitalRead(start) == HIGH && digitalRead(End) == HIGH)
{
laser = true
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Laser Alignment')
lcd.setCursor(0, 1)
lcd.print('Status: OK')
delay(1500)
}
while (digitalRead(start) == LOW && digitalRead(End) == LOW)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Both Lasers are')
lcd.setCursor(0, 1)
lcd.print('not Aligned')
delay(1000)
}
while (digitalRead(start) == LOW)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Start Laser not')
lcd.setCursor(0, 1)
lcd.print('Aligned')
delay(1000)
}
while (digitalRead(End) == LOW)
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('End Laser not')
lcd.setCursor(0, 1)
lcd.print('Aligned')
delay(1000)
}
}
lcd.clear()
}
void loop()
{
if (digitalRead(change) == LOW)
{
change_limit()
}
if (digitalRead(start) == LOW)
{
variable = 1
buzz = true
while (variable == 1)
{
ms = ms + 1
delay(1)
if (digitalRead(End) == LOW)
{
variable = 0
}
}
Seconds = ms / 1000
ms = 0
}
if (Speed {
y = true
}
Speed = distance / Seconds
Speed = Speed * km_h
if (isinf(Speed))
{
lcd.setCursor(0, 0)
lcd.print('Speed:0.00')
lcd.print(' km/h ')
}
else
{
lcd.setCursor(0, 0)
lcd.print('Speed:')
lcd.print(Speed)
lcd.print('km/h ')
lcd.setCursor(0, 1)
lcd.print(' ')
if (buzz == true)
{
buzz = false
digitalWrite(buzzer, HIGH)
delay(100)
digitalWrite(buzzer, LOW)
}
if (Speed > EEPROM.read(speed_address))
{
lcd.setCursor(0, 0)
lcd.print('Speed:')
lcd.print(Speed)
lcd.print('km/h ')
lcd.setCursor(0, 1)
lcd.print('Overspeed Alert!')
if (y == true)
{
y = false
for (i = 0 i <45 i++)
{
digitalWrite(buzzer, HIGH)
delay(50)
digitalWrite(buzzer, LOW)
delay(50)
}
}
}
}
}
void change_limit()
{
x = false
count = EEPROM.read(speed_address)
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Set Speed Limit')
lcd.setCursor(0, 1)
lcd.print('km/h:')
lcd.setCursor(6, 1)
lcd.print(count)
while (x == false)
{
if (digitalRead(up) == LOW)
{
lcd.setCursor(6, 1)
count = count + 1
lcd.print(count)
delay(200)
}
if (digitalRead(down) == LOW)
{
lcd.setCursor(6, 1)
count = count - 1
lcd.print(count)
delay(200)
}
if (digitalRead(Set) == LOW)
{
speed_value = count
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Speed Limit is')
lcd.setCursor(0, 1)
lcd.print('set to ')
lcd.print(speed_value)
lcd.print(' km/h')
EEPROM.write(speed_address, speed_value)
delay(2000)
x = true
lcd.clear()
}
}
}
// ----------- Developed by R.GIRISH ---------//

Acum să vedem cum să acționăm acest circuit:

• Completați-vă circuitul și încărcați codul.
• Distanța dintre două lasere / LDR trebuie să fie exact de 10 metri, nu mai puțin sau mai mult, altfel viteza va fi calculată greșit (prezentată în prima diagramă).
• Distanța dintre laser și LDR poate la alegere și circumstanțe.
• Circuitul va verifica dacă există nealiniere laser cu LDR, dacă este cazul, vă rugăm să îl corectați conform informațiilor afișate pe ecranul LCD.
• Inițial circuitul vă va cere să introduceți o valoare limită de viteză în km / h dincolo de care circuitul alertează, apăsând în sus (S1) și în jos (S2) puteți schimba numărul de pe afișaj și apăsați set (S3), acest valoarea va fi salvată.
• Pentru a modifica această limită de viteză, apăsați butonul S4 și puteți seta o nouă limită de viteză.
• Acum, luați o motocicletă cu 30 km / h și întrerupeți fasciculele laser, circuitul ar trebui să vă arate un număr foarte apropiat de 30 km / h.
• Ați terminat și circuitul dvs. este gata să vă servească siguranța campusului.

Prototipul autorului:

Dacă aveți întrebări cu privire la acest circuit de detectare a vitezei vehiculului poliției rutiere, vă rugăm să nu ezitați să întrebați în secțiunea de comentarii, este posibil să primiți un răspuns rapid.