Circuit de sensor d’estacionament invers de cotxe amb alarma

En aquesta publicació anem a construir un circuit d’alarma de sensor d’estacionament invers de cotxes mitjançant arduino, sensor ultrasònic i mòdul transceptor de 2,4 GHz. Aquest projecte pot ser una funció complementària per al vostre cotxe si no té cap sensor d’estacionament integrat.

Introducció

El projecte proposat té una funcionalitat similar a la que té el sensor d’aparcament tradicional, com ara la distància entre el vehicle i l’obstacle en una pantalla LCD i l’alerta de so sonor.

El projecte proposat es pot utilitzar com a sensor d’estacionament estacionari, és a dir, el sensor situat al garatge o el sensor d’estacionament mòbil, és a dir, sensor situat a la part posterior del cotxe si esteu preparat per assumir un petit risc de cablejar el projecte amb el sistema elèctric del cotxe.

Tanmateix, la motivació que té aquest projecte construir un sensor d’estacionament estacionari que es pot construir amb risc zero.

El projecte d’alarma del sensor d’aparcament amb Arduino té dues parts, el transmissor que consisteix en un sensor d’ultrasons, un arduino, un brunzidor i un mòdul de transceptor de 2,4 GHz. Aquest circuit mesurarà la distància entre el cotxe i l’obstacle.

El receptor consta de mòdul transceptor de 2,4 GHz, arduino i pantalla LCD de 16x2.

El circuit receptor s’ubicarà a l’interior del cotxe amb bateria de 9V com a font d’alimentació. El receptor mostrarà la distància entre el cotxe i l’obstacle en metres.

El transmissor transmetrà les dades del sensor al receptor dins del cotxe mitjançant un enllaç de 2,4 GHz. L'enllaç de comunicació s'estableix mitjançant el mòdul NRF24L01.

Ara vegem la visió general del mòdul NRF24L01.

Il·lustració de NRF24L01:

Aquest mòdul està dissenyat per establir un enllaç de comunicació bidireccional entre dos microcontroladors. Funciona amb protocol de comunicació SPI. Té 125 canals diferents i una velocitat màxima de dades de 2 Mbps. Té un abast màxim teòric de 100 metres.

Configuració del pin:

Funciona a 3,3 V, de manera que 5 volts al terminal Vcc el poden matar. Tot i això, pot acceptar senyals de dades de 5V procedents de microcontroladors.

Ara passem al transmissor del projecte.

El circuit es connecta amb mòdul NRF24L01 amb 5 cables connectats a pins d'E / S digitals d'arduino i la resta dels dos a 3,3V i a terra. El pin # 2 està connectat a la base del transistor que alimentarà el brunzidor.

Els terminals d’alimentació del sensor ultrasònic estan connectats a 5 V i GND i A0 es connecta al pin de disparador i A1 es connecta al pin de ressò del sensor.

Les dades de distància del sensor es transmeten al receptor mitjançant el mòdul NRF24L01.

-------------------------------------------------- ---------------------------------------- Descarregueu el fitxer de la biblioteca des de l'enllaç següent: github.com/nRF24/RF24.git----------------------------------------- -------------------------------------------------- ---

Programa per a l'emissor:

//----------Program Developed by R.Girish-------------//
#include
#include
RF24 radio(7,8)
const byte address[][6] = {'00001', '00002'}
const int trigger = A0
const int echo = A1
const int buzzer = 2
float distance
float result
long Time
boolean state = false
boolean dummystate = 0
void setup()
{
pinMode(trigger, OUTPUT)
pinMode(buzzer, OUTPUT)
pinMode(echo, INPUT)
radio.begin()
radio.openWritingPipe(address[1])
radio.openReadingPipe(1, address[0])
radio.setChannel(100)
radio.setDataRate(RF24_250KBPS)
radio.setPALevel(RF24_PA_MAX)
radio.startListening()
while(!radio.available())
radio.read(&dummystate, sizeof(dummystate))
radio.stopListening()
if(dummystate == HIGH)
{
for(int j = 0 j <10 j++)
{
const char text[] = 'Connection:OK !!!'
radio.write(&text, sizeof(text))
delay(100)
}
}
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
delay(1000)
}
void(* resetFunc) (void) = 0
void loop()
{
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result > 2.00)
{
const char text[] = 'CAR NOT IN RANGE'
radio.write(&text, sizeof(text))
}
if(result 1.90)
{
const char text[] = 'Distance = 2.0 M'
radio.write(&text, sizeof(text))
}
if(result 1.80)
{
const char text[] = 'Distance = 1.9 M'
radio.write(&text, sizeof(text))
}
if(result 1.70)
{
const char text[] = 'Distance = 1.8 M'
radio.write(&text, sizeof(text))
}
if(result 1.60)
{
const char text[] = 'Distance = 1.7 M'
radio.write(&text, sizeof(text))
}
if(result 1.50)
{
const char text[] = 'Distance = 1.6 M'
radio.write(&text, sizeof(text))
}
if(result 1.40)
{
const char text[] = 'Distance = 1.5 M'
radio.write(&text, sizeof(text))
}
if(result 1.30)
{
const char text[] = 'Distance = 1.4 M'
radio.write(&text, sizeof(text))
}
if(result 1.20)
{
const char text[] = 'Distance = 1.3 M'
radio.write(&text, sizeof(text))
}
if(result 1.10)
{
const char text[] = 'Distance = 1.2 M'
radio.write(&text, sizeof(text))
}
if(result 1.00)
{
const char text[] = 'Distance = 1.1 M'
radio.write(&text, sizeof(text))
}
if(result 0.90)
{
state = true
const char text[] = 'Distance = 1.0 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(700)
digitalWrite(buzzer, LOW)
delay(700)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 1.0)
{
state = false
}
}
}
if(result 0.80)
{
state = true
const char text[] = 'Distance = 0.9 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(600)
digitalWrite(buzzer, LOW)
delay(600)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.90)
{
state = false
}
}
}
if(result 0.70)
{
state = true
const char text[] = 'Distance = 0.8 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(500)
digitalWrite(buzzer, LOW)
delay(500)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.80)
{
state = false
}
}
}
if(result 0.60)
{
state = true
const char text[] = 'Distance = 0.7 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(400)
digitalWrite(buzzer, LOW)
delay(400)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.70)
{
state = false
}
}
}
if(result 0.50)
{
state = true
const char text[] = 'Distance = 0.6 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(300)
digitalWrite(buzzer, LOW)
delay(300)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.60)
{
state = false
}
}
}
if(result 0.40)
{
state = true
const char text[] = 'Distance = 0.5M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(200)
digitalWrite(buzzer, LOW)
delay(200)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.50)
{
state = false
}
}
}
if(result 0.30)
{
state = true
const char text[] = 'Distance = 0.4 M'
radio.write(&text, sizeof(text))
while(state)
{
digitalWrite(buzzer, HIGH)
delay(100)
digitalWrite(buzzer, LOW)
delay(100)
digitalWrite(trigger,HIGH)
delayMicroseconds(10)
digitalWrite(trigger,LOW)
Time = pulseIn(echo,HIGH)
distance = Time*0.034
result = distance/200
if(result 0.40)
{
state = false
}
}
}
if(result <= 0.30)
{
const char text[] = ' STOP!!!'
radio.write(&text, sizeof(text))
digitalWrite(buzzer, HIGH)
delay(3000)
digitalWrite(buzzer, LOW)
resetFunc()
}
delay(200)
}
//----------Program Developed by R.Girish-------------//

Això conclou el transmissor.

Receptor:

El receptor té una pantalla LCD de 16x2 per mostrar la mesura de la distància. A continuació es mostra la connexió de pantalla:

Ajusteu el potenciòmetre de 10K per obtenir un millor contrast de visualització.

L’esquema anterior és la resta del circuit receptor. Es proporciona un botó per restablir l’arduino en cas que no s’estableixi la connexió d’enllaç de 2,4 GHz.

El circuit receptor es col·loca dins del cotxe i pot ser alimentat per una bateria de 9V. El receptor es pot col·locar en una caixa brossa que pot fer que el cotxe tingui bon aspecte. La caixa brossa es pot col·locar al cotxe sobre el quadre d’instruments o qualsevol lloc convenient que desitgeu.

Programa per al receptor:

//--------Program Developed by R.Girish-------//
#include
#include
#include
LiquidCrystal lcd(7, 6, 5, 4, 3, 2)
RF24 radio(9,10)
const byte address[][6] = {'00001', '00002'}
const int dummy = A0
boolean dummystate = 0
void setup()
{
Serial.begin(9600)
lcd.begin(16, 2)
pinMode(dummy , INPUT)
digitalWrite(dummy, HIGH)
radio.begin()
radio.openReadingPipe(1, address[1])
radio.openWritingPipe(address[0])
radio.setChannel(100)
radio.setDataRate(RF24_250KBPS)
radio.setPALevel(RF24_PA_MAX)
radio.stopListening()
dummystate = digitalRead(dummystate)
radio.write(&dummystate, sizeof(dummystate))
delay(10)
radio.startListening()
if(!radio.available())
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Connection not')
lcd.setCursor(0,1)
lcd.print('established')
delay(50)
}
}
void loop()
{
if(radio.available())
{
char text[32] = ''
radio.read(&text, sizeof(text))
lcd.clear()
lcd.setCursor(0,0)
lcd.print(text)
lcd.setCursor(0,1)
lcd.print('----------------')
}
}
//--------Program Developed by R.Girish-------//

Ara, això conclou el receptor.

Com col·locar el sensor com a sensor d’estacionament estacionari:

Com col·locar el sensor com a sensor d'aparcament mòbil:

Al sensor d’estacionament mòbil, el sensor d’ultrasons del transmissor es col·loca a la part posterior del cotxe i l’alimentació la proporciona la bateria del cotxe. S'ha de connectar de manera que, quan apagueu el contacte, l'arduino s'hagi de desconnectar del subministrament.

El receptor pot situar-se dins del que s’ha esmentat anteriorment.

Com operar aquest projecte de sensor d'aparcament (tipus estacionari)

• Enceneu primer el transmissor, aneu al cotxe i engegueu el receptor. Si s'estableix la connexió entre el transmissor i el receptor, es mostrarà 'Connexió: OK' i mostrarà la distància entre el cotxe i el sensor.

• Si apareix 'Connexió no establerta', premeu el botó del receptor.

• És possible que aparegui 'El cotxe no està a l'abast' si la llauna està lluny del sensor d'ultrasons.

• Agafeu suaument el cotxe cap enrere o cap endavant cap a la vostra parcel·la.

• Com que la distància entre el cotxe i el sensor es fa inferior a 1,0 metres, el timbre emet un so.

• A mesura que us acosteu al sensor més a prop, augmenta la freqüència del so, una vegada que el cotxe arriba a 0,3 metre, el display us demanarà que atureu el vehicle i heu d'aturar-lo.

• El transmissor es restablirà i passarà al ralentí automàticament. Apagueu el receptor del cotxe. Si heu alimentat el transmissor per bateria, apagueu-lo també.

Com s'utilitza aquest circuit d'alarma del sensor d'aparcament (sensor d'aparcament mòbil)

• És una instrucció similar prèviament indicada si el receptor mostra 'Cotxe no a l'abast' si el cotxe està lluny de l'obstacle.

• Quan apagueu el motor, el circuit del transmissor s’ha d’apagar. Apagueu el circuit del receptor manualment.

Prototip de l'autor:

Emissor:

Receptor: