ट्रैफिक पुलिस के लिए वाहन स्पीड डिटेक्टर सर्किट

ट्रैफिक पुलिस के लिए वाहन स्पीड डिटेक्टर सर्किट

इस पोस्ट में हम एक सर्किट का निर्माण करने जा रहे हैं जो सड़कों और राजमार्गों पर किसी भी वाहन की गति को माप सकता है। प्रस्तावित सर्किट को स्थिर स्थान पर रखा जाता है जहां वाहनों को ओवर-स्पीड होने का संदेह होता है। यदि कोई वाहन गति सीमा से परे चला जाता है, तो सर्किट तुरंत अलर्ट हो जाता है। हम कोड, सर्किट आरेख और तर्क देख रहे होंगे कि वाहन की गति कैसे मापी जाती है।



उद्देश्य

भारत में आकस्मिक मृत्यु रिपोर्ट 2015 के अनुसार 75% से अधिक सड़क दुर्घटनाओं का कारण बनता है, यह एक बड़ी संख्या है। अधिकांश ट्रैफिक पुलिस उन मोटर चालकों को हिरासत में लेने की कोशिश करती है जो खतरनाक रूप से शहर की गति सीमा से परे अपना वाहन चलाते हैं।

हर बार नहीं जब कोई ट्रैफिक पुलिस ओवर स्पीडिंग वाहन को रोककर उन्हें चार्ज कर सकता है इसलिए स्पीड कैमरा नामक एक उपकरण स्थापित किया जाता है, जहां मोटर चालकों को गति पर संदेह होता है जैसे कि अक्सर दुर्घटना संभावित क्षेत्रों, चौराहों आदि पर।





हम गति कैमरा के समान कुछ बनाने जा रहे हैं, लेकिन बहुत सरल तरीके से, जिसे एक परिसर जैसे स्कूल, कॉलेज या आईटी पार्क या सिर्फ एक मजेदार परियोजना के रूप में स्थापित किया जा सकता है।

प्रस्तावित परियोजना में दो लेजर बीम से गुजरने वाले प्रत्येक वाहन की गति को प्रदर्शित करने के लिए 16 x 2 एलसीडी डिस्प्ले है, जो उन लेजर बीमों को बाधित करते हुए वाहन की गति को मापने के लिए बिल्कुल 10 मीटर की दूरी पर रखा गया है।



एक बजर एक बीप होगा जब एक वाहन पारित किया जाता है यह दर्शाता है कि एक वाहन का पता चला है और प्रत्येक वाहन की गति एलसीडी डिस्प्ले पर प्रदर्शित की जाएगी। जब एक वाहन गति सीमा से परे जा रहा है तो बजर लगातार बीप करेगा और प्रदर्शन पर वाहन की गति दिखाई जाएगी।

नोट: वाहन की गति एलसीडी पर प्रदर्शित की जाएगी, भले ही वाहन गति से अधिक या कम गति से चल रहा हो।

अब गति को मापने के लिए सर्किट के पीछे के तर्क को देखें।

हम सभी गति - दूरी - समय सूत्र नामक एक सरल सूत्र को जानते हैं।
गति = दूरी / समय।

• मीटर प्रति सेकंड में गति,
• मीटर में दूरी,
• सेकंड में समय।

गति जानने के लिए, हमें उस दूरी को जानना होगा 'x' जिस वाहन से यात्रा की गई है और उस दूरी को 'x' कवर करने में लगने वाला समय।

ऐसा करने के लिए हम दो लेजर बीम और दो LDRs निम्नलिखित फैशन में 10 मीटर की दूरी पर स्थापित कर रहे हैं:

यातायात वाहन की गति को मापें

हम जानते हैं कि दूरी 10 मीटर है जो तय हो गई है, अब हमें समीकरण में समय जानना होगा।

Arduino द्वारा समय की गणना की जाएगी, जब वाहन 'स्टार्ट लेजर' को बाधित करता है, टाइमर शुरू होता है और जब वाहन 'अंत लेजर' को बाधित करता है तो टाइमर बंद हो जाता है और मान को समीकरण पर लागू करने से Arduino वाहन की गति का पता लगाएगा।

कृपया ध्यान दें कि वाहन की गति का केवल एक दिशा में पता लगाया जाएगा अर्थात् लेजर को रोकने के लिए लेजर शुरू करें, वाहन का दूसरी दिशा में पता लगाने के लिए एक ही समान दिशा में दूसरी दिशा में सेटअप करना होगा। तो, यह स्कूल, कोलाज आदि जैसी जगहों के लिए आदर्श है, जहां उनके पास IN और OUT द्वार हैं।

अब योजनाबद्ध आरेख देखें:

Arduino और प्रदर्शन के बीच कनेक्शन:

एलसीडी वाहन की गति प्रदर्शन

ऊपर सर्किट स्व-व्याख्यात्मक है और बस सर्किट के अनुसार तारों को कनेक्ट करें। डिस्प्ले कंट्रास्ट को एडजस्ट करने के लिए 10K पोटेंशियोमीटर को एडजस्ट करें।

अतिरिक्त तारों का विवरण:

गति वाहन की दूरी माप तारों की स्थापना

उपरोक्त सर्किट में Arduino, 4 पुश बटन, दो 10K पुल डाउन रेसिस्टर्स (प्रतिरोधों का मूल्य नहीं बदलेंगे), दो LDRs और एक बज़र शामिल हैं। 4 पुश बटन का कार्य शीघ्र ही समझाया जाएगा। अब देखते हैं कि LDR को ठीक से कैसे माउंट किया जाए।

वाहन की गति का पता लगाने के लिए LDR माउटिंग

एलडीआर को मुझे सूरज की रोशनी से अच्छी तरह से कवर करना चाहिए, केवल लेजर बीम को एलडीआर को हड़ताल करना चाहिए। सुनिश्चित करें कि आपका लेजर मॉड्यूल चमकदार सूरज चमक में काम करने के लिए पर्याप्त शक्तिशाली है।
आप उपरोक्त उद्देश्य के लिए एक पीवीसी पाइप का उपयोग कर सकते हैं और इसे ट्यूब के अंदर काले रंग से पेंट कर सकते हैं। सामने वाले हिस्से को कवर करना न भूलें, इसे पूरा करने के लिए अपनी रचनात्मकता का उपयोग करें।

कार्यक्रम कोड:

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

अब देखते हैं कि इस सर्किट को कैसे संचालित किया जाए:

• आप सर्किट पूरा करें और कोड अपलोड करें।
• दो लेज़रों / एलडीआर के बीच की दूरी ठीक 10 मीटर होनी चाहिए, कोई कम या अधिक नहीं, अन्यथा गति को मिसकल्कुलेट किया जाएगा (पहले आरेख में दिखाया गया है)।
• लेज़र और LDR के बीच की दूरी आपकी पसंद और परिस्थितियों की हो सकती है।
• सर्किट एलडीआर के साथ लेजर मिसलिग्न्मेंट के लिए जांच करेगा, अगर कोई कृपया इसे एलसीडी पर प्रदर्शित जानकारी के अनुसार सही करे।
• शुरू में सर्किट आपको किमी / घंटा में गति सीमा मान दर्ज करने के लिए कहेगा जिसके आगे सर्किट अलर्ट, ऊपर (S1) और नीचे (S2) दबाकर आप डिस्प्ले पर नंबर बदल सकते हैं और सेट (S3) दबा सकते हैं, यह मान बच जाएगा।
• इस गति सीमा को बदलने के लिए, बटन S4 दबाएं और आप एक नई गति सीमा निर्धारित कर सकते हैं।
• अब 30 किमी / घंटा पर मोटर बाइक ड्राइव लें और लेजर बीम को बाधित करें, सर्किट आपको 30 किमी / घंटा के करीब नंबर दिखाना चाहिए।
• आप कर रहे हैं और आपका सर्किट आपके परिसर की सुरक्षा के लिए तैयार है।

लेखक का प्रोटोटाइप:

वाहन की गति का पता लगाने के प्रोटोटाइप

यदि इस ट्रैफ़िक पुलिस वाहन गति डिटेक्टर सर्किट के बारे में आपके कोई प्रश्न हैं, तो कृपया टिप्पणी अनुभाग में पूछने के लिए स्वतंत्र महसूस करें, आपको त्वरित उत्तर मिल सकता है।




की एक जोड़ी: पीर सेंसर डेटशीट, पिनआउट विनिर्देशों, कार्य करना अगला: रिमोट कंट्रोल परीक्षक सर्किट