Jármű sebességérzékelő áramköre a közlekedési rendőrség számára

Ebben a bejegyzésben egy kört fogunk építeni, amely képes mérni bármely jármű sebességét utakon és autópályákon. A javasolt körforgást egy helyen tartják, ahol a járművek gyanúja szerint túllépnek. Ha bármely jármű túllépi a megengedett sebességet, az áramkör azonnal riaszt. Megvizsgáljuk a kódot, a kapcsolási rajzot és a logikát, hogyan mérjük a jármű sebességét.

Célkitűzés

Az indiai 2015-ös baleseti halálesetek szerint a túl gyorshajtás 75% -át okozza a közúti balesetek száma, ez óriási szám. A legtöbb közlekedési rendőrség megpróbálja visszatartani azokat az autósokat, akik veszélyes módon vezetik járművüket a városi sebességhatár felett.

Nem minden alkalommal, amikor a közlekedési rendőrök megállíthatnak egy túllépő járművet és felszámolhatják őket. Tehát egy sebességmérő kamerának nevezett eszközt telepítenek, ahol az autósok gyanúja szerint túllépnek, például gyakori balesetveszélyes területek, kereszteződések stb.

Valami hasonlót fogunk építeni a sebességmérő kamerához, de sokkal leegyszerűsítve, amely telepíthető egy egyetemre, például iskolába, főiskolára vagy informatikai parkokba, vagy csak szórakoztató projektként.

A javasolt projekt 16 x 2 LCD kijelzőből áll, amely bemutatja az egyes járművek sebességét, amelyek áthaladnak két lézersugáron, amelyeket pontosan 10 méter távolságra helyeznek el a jármű sebességének mérésére, miközben megszakítják ezeket a lézersugarakat.

A jármű elhaladásakor sípoló hangjelzéssel jelzi, hogy a jármű észlelhető, és az egyes járművek sebessége megjelenik az LCD kijelzőn. Amikor egy jármű meghaladja a sebességhatárt, a hangjelző folyamatosan sípol, és a jármű sebessége megjelenik a kijelzőn.

MEGJEGYZÉS: A jármű sebessége megjelenik az LCD-n, függetlenül attól, hogy a jármű meghaladja-e a sebességet.

Most nézzük meg a sebesség mérésének áramkörének logikáját.

Mindannyian ismerünk egy egyszerű képletet, amelyet sebesség - távolság - idő képletnek hívunk.
Sebesség = Távolság / Idő.

• Sebesség méterben másodpercenként,
• távolság méterben,
• Idő másodpercben.

A sebesség megismeréséhez ismernünk kell a jármű által megtett „x” távolságot és az „x” távolság megtételéhez szükséges időt.

Ehhez két lézersugarat és két 10 méteres távolságú LDR-t állítunk fel a következő módon:

Tudjuk, hogy a távolság 10 méter, ami rögzített, most már tudnunk kell az időt az egyenletben.

Az időt Arduino fogja kiszámítani, amikor a jármű megszakítja a „start lézert”, az időzítő elindul, és amikor a jármű megszakítja a „vég lézert”, az időzítő leáll, és az értékeket alkalmazva az Arduino egyenletre megtalálja a jármű sebességét.

Felhívjuk figyelmét, hogy a jármű sebességét csak egy irányban érzékeli, azaz indítsa el a lézert a lézer leállításához, a jármű másik irányban történő észleléséhez egy másik beállítást kell elhelyezni az ellenkező irányba. Tehát ez ideális olyan helyekre, mint iskola, kollázs stb., Ahol IN és OUT kapuk vannak.

Most nézzük meg a sematikus ábrát:

Kapcsolat az Arduino és a kijelző között:

A fenti áramkör magától értetődő, és csak csatlakoztassa a vezetékeket az áramkör szerint. A kijelző kontrasztjának beállításához állítsa be a 10K potenciométert.

További kábelezési részletek:

A fenti áramkör áll Arduino-ból, 4 nyomógombból, két 10K lehúzható ellenállásból (ne változtassa meg az ellenállások értékét), két LDR-ből és egy hangjelzőből. Négy nyomógomb funkcióját röviden elmagyarázzuk. Most nézzük meg, hogyan lehet megfelelően felszerelni az LDR-t.

Az LDR-t rendesen el kell takarni a napfénytől, csak a lézersugárnak kell megütnie az LDR-t. Győződjön meg arról, hogy a lézermodul elég erős ahhoz, hogy ragyogó napsütésben dolgozzon.
A fenti célra PVC csövet használhat, és a cső belsejében feketére festheti. Ne felejtse el eltakarni az elülső részt, használja ezt kreativitásával.

Program kód:

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

Most nézzük meg, hogyan kell működtetni ezt az áramkört:

• Végezze el az áramkört, és töltse fel a kódot.
• Két lézer / LDR távolságának pontosan 10 méternek kell lennie, nem kevesebb vagy nem több, ellenkező esetben a sebesség téves lesz (az első diagram mutatja).
• A választott lézer és az LDR doboz közötti távolság és az Ön körülményei.
• Az áramkör ellenőrzi az LDR-rel való lézeres eltéréseket, ha van ilyen, kérjük, javítsa ki az LCD-n megjelenő információk szerint.
• Kezdetben az áramkör arra kéri Önt, hogy adja meg a sebességhatár értékét km / h-ban, amelyen túl az áramkör figyelmeztet. A felfelé (S1) és a lefelé (S2) megnyomásával megváltoztathatja a kijelzőn megjelenő számot, és megnyomhatja a set (S3) gombot, érték el lesz mentve.
• A sebességkorlátozás megváltoztatásához nyomja meg az S4 gombot, és új sebességkorlátozást állíthat be.
• Most vegyen motorkerékpár-meghajtót 30 km / h sebességgel, és szakítsa meg a lézersugarakat. Az áramkörnek a 30 km / h-hoz közeli számot kell mutatnia.
• Elkészült, és a pályája készen áll az egyetemi biztonság szolgálatára.

A szerző prototípusa:

Ha bármilyen kérdése van ezzel a közlekedési rendőrségi jármű sebességérzékelő áramkörével kapcsolatban, kérjük, nyugodtan tegye fel a megjegyzés rovatban, így gyors választ kaphat.