Circuito di rilevamento della velocità del veicolo per la polizia stradale

In questo post costruiremo un circuito in grado di misurare la velocità di qualsiasi veicolo su strade e autostrade. Il circuito proposto è mantenuto fermo in un punto in cui si sospetta che i veicoli superino la velocità. Se un veicolo supera il limite di velocità, il circuito avvisa immediatamente. Guarderemo il codice, lo schema del circuito e la logica di come viene misurata la velocità del veicolo.

Obbiettivo

L'eccesso di velocità causa il 75% di incidenti stradali secondo il rapporto sulla morte accidentale del 2015 in India, un numero enorme. La maggior parte della polizia stradale cerca di trattenere gli automobilisti che guidano pericolosamente il loro veicolo oltre il limite di velocità della città.

Non tutte le volte una polizia stradale può fermare un veicolo in eccesso di velocità e caricarlo. Quindi un dispositivo chiamato autovelox viene installato dove si sospetta che gli automobilisti superino la velocità come aree soggette a incidenti frequenti, incroci ecc.

Costruiremo qualcosa di simile agli autovelox, ma in modo molto semplificato, che può essere installato all'interno di un campus come una scuola, un college o un parco IT o semplicemente come un progetto divertente.

Il progetto proposto consiste in un display LCD 16 x 2 per mostrare la velocità di ciascun veicolo che passa attraverso due raggi laser che sono posti a distanza di 10 metri esatti per misurare la velocità del veicolo interrompendo quei raggi laser.

Un cicalino emetterà un segnale acustico al passaggio di un veicolo indicando che un veicolo è stato rilevato e la velocità di ciascun veicolo verrà visualizzata sul display LCD. Quando un veicolo supera il limite di velocità, il cicalino emetterà un segnale acustico continuo e la velocità del veicolo verrà visualizzata sul display.

NOTA: la velocità del veicolo verrà visualizzata sul display LCD indipendentemente dal fatto che il veicolo stia superando o diminuendo la velocità.

Ora vediamo la logica dietro il circuito per misurare la velocità.

Conosciamo tutti una semplice formula chiamata velocità - distanza - formula tempo.
Velocità = distanza / tempo.

• Velocità in metri al secondo,
• Distanza in metri,
• Tempo in secondi.

Per conoscere la velocità, dobbiamo conoscere la distanza diciamo 'x' percorsa da un veicolo e il tempo impiegato per coprire quella distanza 'x'.

Per fare questo stiamo impostando due raggi laser e due LDR con una distanza di 10 metri nel modo seguente:

Sappiamo che la distanza è di 10 metri che è fissa, ora dobbiamo conoscere il tempo nell'equazione.

Il tempo verrà calcolato da Arduino, quando il veicolo interrompe lo “start laser”, parte il timer e quando il veicolo interrompe il “end laser” il timer si ferma e applicando i valori all'equazione Arduino troverà la velocità del veicolo.

Si noti che la velocità del veicolo verrà rilevata solo in una direzione, ovvero avviare il laser per arrestare il laser, per rilevare il veicolo in un'altra direzione, è necessario posizionare un'altra stessa configurazione nella direzione opposta. Quindi, questo è l'ideale per luoghi come scuola, collage ecc. Dove hanno porte IN e OUT.

Ora vediamo il diagramma schematico:

Connessione tra Arduino e display:

Il circuito sopra è autoesplicativo e basta collegare il cablaggio come per il circuito. Regolare il potenziometro 10K per regolare il contrasto del display.

Dettagli di cablaggio aggiuntivi:

Il circuito sopra è costituito da Arduino, 4 pulsanti, due resistori pull down da 10K (non modificare il valore dei resistori), due LDR e un cicalino. La funzione dei 4 pulsanti verrà spiegata brevemente. Ora vediamo come montare correttamente l'LDR.

L'LDR deve essere adeguatamente coperto dalla luce solare, solo il raggio laser dovrebbe colpire l'LDR. Assicurati che il tuo modulo laser sia abbastanza potente da funzionare con un sole splendente.
Puoi usare un tubo in PVC per lo scopo sopra e dipingerlo di nero all'interno del tubo, non dimenticare di coprire la parte anteriore, usa la tua creatività per farlo.

Codice programma:

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

Ora vediamo come far funzionare questo circuito:

• Completa il circuito e carica il codice.
• La distanza tra due laser / LDR dovrebbe essere esattamente di 10 metri, né inferiore né superiore, altrimenti la velocità sarà calcolata male (mostrato nel primo diagramma).
• La distanza tra il laser e l'LDR può essere scelta e circostanze.
• Il circuito controllerà il disallineamento del laser con LDR, se presente, correggerlo secondo le informazioni visualizzate sul display LCD.
• Inizialmente il circuito chiederà di inserire un valore limite di velocità in km / h oltre il quale il circuito avvisa, premendo su (S1) e giù (S2) è possibile modificare il numero sul display e premere set (S3), questo il valore verrà salvato.
• Per modificare questo limite di velocità, premere il pulsante S4 e si può impostare un nuovo limite di velocità.
• Ora fai un giro in moto a 30 km / he interrompi i raggi laser, il circuito dovrebbe mostrarti un numero molto vicino a 30 km / h.
• Hai finito e il tuo circuito è pronto per servire la sicurezza del tuo campus.

Prototipo dell'autore:

In caso di domande su questo circuito di rilevamento della velocità dei veicoli della polizia stradale, non esitate a chiedere nella sezione commenti, potresti ottenere una risposta rapida.