Obwód czujnika cofania samochodu z alarmem

W tym poście zamierzamy zbudować obwód alarmowy czujnika cofania samochodu za pomocą arduino, czujnika ultradźwiękowego i modułu nadawczo-odbiorczego 2,4 GHz. Ten projekt może być funkcją dodatkową dla Twojego samochodu, jeśli nie ma on wbudowanych czujników parkowania.

Wprowadzenie

Proponowany projekt ma podobną funkcjonalność jak tradycyjny czujnik parkowania, np. Odległość między samochodem a przeszkodą na wyświetlaczu LCD i dźwiękowy sygnał dźwiękowy.

Proponowany projekt może służyć jako stacjonarny czujnik parkowania tj. Czujnik umieszczony na Twoim garażu lub mobilny czujnik parkowania tj. Czujnik umieszczony z tyłu Twojego samochodu, jeśli jesteś gotowy podjąć niewielkie ryzyko okablowania projektu z instalacją elektryczną samochodu.

Jednak motywacją jest ten projekt zbudować stacjonarny czujnik parkowania które można zbudować bez ryzyka.

Projekt alarmu czujnika parkowania samochodu z wykorzystaniem Arduino składa się z dwóch części, nadajnika składającego się z czujnika ultradźwiękowego, arduino, brzęczyka i modułu nadawczo-odbiorczego 2,4 GHz. Ten obwód będzie mierzył odległość między samochodem a przeszkodą.

Odbiornik składa się z modułu nadawczo-odbiorczego 2,4 GHz, arduino i wyświetlacza LCD 16x2.

Obwód odbiornika zostanie umieszczony wewnątrz samochodu z akumulatorem 9V jako zasilaniem. Odbiornik wyświetli odległość między samochodem a przeszkodą w metrach.

Nadajnik przesyła dane z czujnika do odbiornika w samochodzie za pośrednictwem łącza 2,4 GHz. Łącze komunikacyjne jest nawiązywane za pomocą modułu NRF24L01.

Zobaczmy teraz przegląd modułu NRF24L01.

Ilustracja NRF24L01:

Moduł ten służy do ustanowienia dwukierunkowego łącza komunikacyjnego pomiędzy dwoma mikrokontrolerami. Działa na protokole komunikacyjnym SPI. Ma 125 różnych kanałów i ma maksymalną szybkość transmisji danych 2 Mb / s. Ma teoretyczny maksymalny zasięg 100 metrów.

Konfiguracja pinów:

Działa na 3,3 V, więc 5 V na terminalu Vcc może go zabić. Jednak może przyjmować sygnały danych 5V z mikrokontrolerów.

Przejdźmy teraz do nadajnika projektu.

Układ jest okablowany z modułem NRF24L01 z 5 przewodami podłączonymi do cyfrowych pinów I / O arduino, a pozostałe do 3,3 V i masy. Pin # 2 jest podłączony do bazy tranzystora, który będzie zasilał brzęczyk.

Zaciski zasilania czujnika ultradźwiękowego są podłączone do 5 V i GND, a A0 jest podłączone do styku wyzwalacza, a A1 jest podłączone do styku echa czujnika.

Dane dotyczące odległości czujnika są przesyłane przez moduł NRF24L01 do odbiornika.

-------------------------------------------------- ----------------------------------------- Pobierz plik biblioteki z poniższego linku: github.com/nRF24/RF24.git----------------------------------------- -------------------------------------------------- ---

Program dla nadajnika:

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

Na tym kończy się nadajnik.

Odbiorca:

Odbiornik posiada wyświetlacz LCD 16x2 do wyświetlania pomiaru odległości. Podłączenie wyświetlacza podano poniżej:

Dostosuj potencjometr 10K, aby uzyskać lepszy kontrast widzenia.

Powyższy schemat przedstawia resztę obwodu odbiornika. Dostępny jest przycisk do resetowania arduino w przypadku braku połączenia łącza 2,4 GHz.

Obwód odbiornika umieszczony jest wewnątrz samochodu i może być zasilany z baterii 9V. Odbiornik można umieścić w śmieciowym pudełku, dzięki czemu samochód będzie dobrze wyglądał. Pojemnik na śmieci można umieścić w samochodzie nad zestawem wskaźników lub w dowolnym dogodnym miejscu.

Program dla odbiornika:

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

Na tym kończy się odbiornik.

Jak umieścić czujnik jako stacjonarny czujnik parkowania:

Jak umieścić czujnik jako mobilny czujnik parkowania:

W mobilnym czujniku parkowania ultradźwiękowy czujnik nadajnika jest umieszczony z tyłu samochodu, a zasilanie pochodzi z akumulatora samochodu. Należy go okablować w taki sposób, aby po wyłączeniu zapłonu arduino musiało odłączyć się od zasilania.

Odbiornik może zostać umieszczony wewnątrz, jak wspomniano wcześniej.

Jak obsługiwać ten projekt czujnika parkowania samochodu (typ stacjonarny)

• Najpierw włącz nadajnik, idź do samochodu i włącz odbiornik. Jeśli połączenie między nadajnikiem a odbiornikiem zostanie nawiązane, wyświetli się komunikat „Połączenie: OK” i pokaże odległość między samochodem a czujnikiem.

• Jeśli wyświetli się „Połączenie nie zostało ustanowione”, naciśnij przycisk znajdujący się na odbiorniku.

• Może wyświetlać „Samochód poza zasięgiem”, jeśli puszka jest daleko od czujnika ultradźwiękowego.

• Delikatnie wjedź samochodem do tyłu lub do przodu na miejsce parkingowe.

• Gdy odległość między samochodem a czujnikiem spadnie poniżej 1 metra, rozlegnie się sygnał dźwiękowy.

• W miarę zbliżania się do czujnika częstotliwość sygnału dźwiękowego wzrasta, gdy samochód osiągnie 1 stopę lub 0,3 metra, na wyświetlaczu pojawi się monit o zatrzymanie samochodu i należy się zatrzymać.

• Nadajnik zresetuje się i automatycznie przejdzie w stan spoczynku. Wyłącz odbiornik w samochodzie. Jeśli zasilałeś nadajnik z baterii, wyłącz go.

Jak obsługiwać ten obwód alarmowy czujnika parkowania samochodu (mobilny czujnik parkowania)

• Podobnie jest z poprzednio podaną instrukcją, jeśli na odbiorniku pojawi się komunikat „Samochód poza zasięgiem”, gdy samochód znajduje się daleko od przeszkody.

• Po wyłączeniu silnika obwód nadajnika musi się wyłączyć. Wyłącz ręcznie obwód odbiornika.

Prototyp autora:

Nadajnik:

Odbiorca: