Transporto priemonės greičio detektoriaus grandinė, skirta kelių policijai

Šiame pranešime ketiname sukonstruoti trasą, galinčią išmatuoti bet kurios transporto priemonės greitį keliuose ir greitkeliuose. Siūloma trasa laikoma nejudama toje vietoje, kur įtariama, kad transporto priemonės viršija greitį. Jei kuri nors transporto priemonė viršija leistiną greitį, grandinė nedelsdama įspėja. Mes žiūrėsime kodą, grandinės schemą ir logiką, kaip matuojamas transporto priemonės greitis.

Tikslas

Remiantis 2015 m. Indijos atsitiktinės mirties ataskaita, viršijus greitį viršija 75% kelių eismo įvykių, tai yra didžiulis skaičius. Dauguma kelių policijos bando sulaikyti vairuotojus, kurie pavojingai vairuoja savo transporto priemonę viršydami miesto greitį.

Ne kiekvieną kartą kelių policija gali sustabdyti greitį viršijančią transporto priemonę ir ją apmokestinti. Taigi įtaisas, vadinamas greičio matavimo kamera, yra įrengtas ten, kur įtariama, kad vairuotojai viršija greitį, pavyzdžiui, dažnai į avarijas linkstančių vietų, sankryžų ir kt.

Mes ketiname pastatyti kažką panašaus į greičio matuoklį, tačiau daug supaprastintą, kurį galima įdiegti universiteto miestelyje, pavyzdžiui, mokykloje, kolegijoje ar IT parkuose, arba tiesiog kaip įdomų projektą.

Siūlomą projektą sudaro 16 x 2 skystųjų kristalų ekranas, rodantis kiekvienos transporto priemonės greitį, einančią per du lazerio spindulius, kurie yra išdėstyti lygiai 10 metrų, kad būtų galima išmatuoti transporto priemonės greitį, pertraukiant tuos lazerio spindulius.

Pravažiavus transporto priemonę pypteli signalas, rodantis, kad aptikta transporto priemonė, ir kiekvienos transporto priemonės greitis bus rodomas LCD ekrane. Kai transporto priemonė viršija greitį, garsinis signalas nuolat pypsės, o transporto priemonės greitis bus rodomas ekrane.

PASTABA: Transporto priemonės greitis bus rodomas LCD ekrane, neatsižvelgiant į tai, ar transporto priemonė viršija greitį, ar per mažą greitį.

Dabar pažiūrėkime greičio matavimo grandinės logiką.

Mes visi žinome paprastą formulę, vadinamą greičio - atstumo - laiko formulė.
Greitis = atstumas / laikas.

• greitis metrais per sekundę,
• atstumas metrais,
• Laikas sekundėmis.

Kad žinotume greitį, turime žinoti atstumą, sakant „x“, kurį nuvažiavo transporto priemonė, ir laiką, per kurį reikia įveikti tą atstumą „x“.

Norėdami tai padaryti, mes nustatome du lazerio spindulius ir du LDR 10 metrų atstumu taip:

Mes žinome, kad atstumas yra 10 metrų, kuris yra fiksuotas, dabar turime žinoti laiką lygtyje.

Laiką apskaičiuos „Arduino“, kai transporto priemonė pertraukia „paleidimo lazerį“, prasideda laikmatis, o transporto priemonei nutraukus „pabaigos lazerį“ laikmatis sustoja ir pritaikius reikšmes lygčiai „Arduino“ suras transporto priemonės greitį.

Atkreipkite dėmesį, kad transporto priemonės greitis bus nustatomas tik viena kryptimi, t. Y. Paleidžiant lazerį, kad sustabdytumėte lazerį, jei norite aptikti transporto priemonę kita kryptimi, kita ta pati sąranka turi būti išdėstyta priešinga kryptimi. Taigi, tai idealiai tinka tokiose vietose kaip mokykla, koliažas ir pan., Kur jie turi „IN“ ir „out“ vartus.

Dabar pažiūrėkime schemą:

Ryšys tarp „Arduino“ ir ekrano:

Aukščiau esanti grandinė yra savaime suprantama ir tiesiog prijunkite laidus pagal grandinę. Norėdami reguliuoti ekrano kontrastą, sureguliuokite 10K potenciometrą.

Papildoma laidų informacija:

Pirmiau pateiktą grandinę sudaro „Arduino“, 4 mygtukai, du 10K nuleidžiami rezistoriai (nekeiskite rezistorių vertės), du LDR ir vienas zuzeris. Netrukus bus paaiškinta 4 mygtukų funkcija. Dabar pažiūrėkime, kaip tinkamai pritvirtinti LDR.

LDR turi būti tinkamai uždengtas nuo saulės spindulių, tik lazerio spindulys turėtų atsitrenkti į LDR. Įsitikinkite, kad jūsų lazerio modulis yra pakankamai galingas, kad veiktų šviečiant saulei.
Aukščiau nurodytam tikslui galite naudoti PVC vamzdį ir nudažyti juoda spalva vamzdžio viduje. Nepamirškite uždengti priekinės dalies, naudokite savo kūrybiškumą, kad tai pasiektumėte.

Programos kodas:

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

Dabar pažiūrėkime, kaip valdyti šią grandinę:

• Užbaikite grandinę ir įkelkite kodą.
• Atstumas tarp dviejų lazerių / LDR turėtų būti lygiai 10 metrų, ne mažesnis ar ne didesnis, kitaip greitis bus neteisingai apskaičiuotas (parodyta pirmoje diagramoje).
• Atstumas tarp lazerio ir jūsų pasirinktos LDR skardinės ir aplinkybių.
• Kontūras patikrins, ar lazeris nesutampa su LDR, jei tokių yra, pataisykite tai pagal LCD ekrane rodomą informaciją.
• Iš pradžių grandinė paprašys įvesti greičio ribinę vertę km / h, už kurią grandinė perspėja, paspausdami aukštyn (S1) ir žemyn (S2), galite pakeisti skaičių ekrane ir paspausti rinkinį (S3). vertė bus išsaugota.
• Norėdami pakeisti šį greičio apribojimą, paspauskite mygtuką S4 ir galėsite nustatyti naują greičio apribojimą.
• Dabar važiuokite motociklu 30 km / h greičiu ir pertraukite lazerio spindulius. Grandinė turėtų rodyti skaičių, artimą 30 km / h.
• Jūs baigėte ir jūsų trasa yra pasirengusi tarnauti jūsų miestelio saugumui.

Autoriaus prototipas:

Jei turite klausimų dėl šios kelių policijos transporto priemonės greičio detektoriaus grandinės, nedvejodami klauskite komentarų skiltyje, galite greitai atsakyti.