Automobilio atbulinės eigos jutiklio grandinė su aliarmu

Šiame įraše mes sukursime automobilio atvirkštinio stovėjimo jutiklio signalizacijos grandinę naudodami „Arduino“, ultragarso jutiklį ir 2,4 GHz siųstuvo-imtuvo modulį. Šis projektas gali būti papildoma jūsų automobilio funkcija, jei jis nesportuoja su įmontuotais parkavimo jutikliais.

Įvadas

Siūlomas projektas turi panašų funkcionalumą, kaip ir tradicinis automobilio parkavimo jutiklis, pvz., Atstumas tarp automobilio ir kliūties LCD ekrane ir garso signalas.

Siūlomas projektas gali būti naudojamas kaip stacionarus parkavimo jutiklis, t. Y. Jutiklis, uždėtas ant jūsų garažo, arba mobilus parkavimo jutiklis, t. Y. Jutiklis, dedamas ant jūsų automobilio galo, jei esate pasirengęs prisiimti nedidelę riziką, kad projektą sujungsite su automobilio elektros sistema.

Tačiau šio projekto motyvacija yra pastatyti stacionarų stovėjimo jutiklį kurį galima sukurti be rizikos.

Automobilių parkavimo jutiklių signalizacijos projektas, kuriame naudojamas „Arduino“, turi dvi dalis: siųstuvą, kurį sudaro ultragarso jutiklis, „arduino“, „buzzer“ ir 2,4 GHz siųstuvo-imtuvo modulis. Ši grandinė išmatuos atstumą tarp automobilio ir kliūties.

Imtuvą sudaro 2,4 GHz siųstuvo-imtuvo modulis, „arduino“ ir 16x2 LCD ekranas.

Imtuvo grandinė bus įdėta į automobilio vidų su 9 V akumuliatoriumi. Imtuvas parodys atstumą tarp automobilio ir kliūties metrais.

Siųstuvas perduos jutiklio duomenis automobilio imtuvui per 2,4 GHz ryšį. Ryšio ryšys nustatomas naudojant NRF24L01 modulį.

Dabar pažiūrėkime NRF24L01 modulio apžvalgą.

NRF24L01 iliustracija:

Šis modulis skirtas sukurti dvikryptį ryšio ryšį tarp dviejų mikrovaldiklių. Jis veikia pagal SPI ryšio protokolą. Jis turi 125 skirtingus kanalus, o jo maksimalus duomenų perdavimo greitis yra 2Mbps. Teorinis maksimalus diapazonas yra 100 metrų.

Smeigtuko konfigūracija:

Jis veikia esant 3,3 V įtampai, todėl 5 voltai Vcc terminale gali jį užmušti. Tačiau jis gali priimti 5 V duomenų signalus iš mikrovaldiklių.

Dabar pereikime prie projekto siųstuvo.

Grandinė yra sujungta su NRF24L01 moduliu, kuriame yra 5 laidai, prijungti prie „Arduino“ skaitmeninių įvesties / išvesties kaiščių, o likusieji du - prie 3,3 V ir įžeminti. Kaištis Nr. 2 yra prijungtas prie tranzistoriaus pagrindo, kuris maitins garsinį signalą.

Ultragarso jutiklio maitinimo gnybtai yra prijungti prie 5 V, o GND ir A0 yra prijungtas prie paleidimo kaiščio, o A1 - prie jutiklio aido kaiščio.

Jutiklio atstumo duomenys per NRF24L01 modulį perduodami imtuvui.

-------------------------------------------------- ----------------------------------------- Prašome atsisiųsti bibliotekos failą iš šios nuorodos: github.com/nRF24/RF24.git----------------------------------------- -------------------------------------------------- ---

Siųstuvo programa:

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

Tai padaro siųstuvą.

Imtuvas:

Imtuvas turi 16x2 LCD ekraną, rodantį atstumo matavimą. Ekrano jungtis pateikiama žemiau:

Norėdami pagerinti kontrastą, sureguliuokite 10K potenciometrą.

Pirmiau pateikta schema yra likusi imtuvo grandinės dalis. Jei nenustatytas 2,4 GHz ryšio ryšys, numatytas „arduino“ nustatymas iš naujo.

Imtuvo grandinė yra automobilio viduje. Tai gali būti maitinimas iš 9 V baterijos. Imtuvas gali būti dedamas į šiukšlių dėžę, dėl kurios jūsų automobilis gali atrodyti gerai. Šiukšlių dėžė gali būti dedama į jūsų automobilį virš prietaisų skydelio ar bet kurios jums patogios vietos.

Imtuvo programa:

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

Tai baigia imtuvą.

Kaip pastatyti jutiklį kaip stacionarų parkavimo jutiklį:

Kaip įdėti jutiklį kaip mobilųjį parkavimo jutiklį:

Mobiliame stovėjimo jutiklyje siųstuvo ultragarso jutiklis dedamas galinėje automobilio pusėje, maitinimas tiekiamas iš automobilio akumuliatoriaus. Jis turėtų būti prijungtas taip, kad išjungus degimą „arduino“ turėtų atsijungti nuo maitinimo šaltinio.

Imtuvas gali būti patalpintas viduje, kaip minėta anksčiau.

Kaip valdyti šį automobilio stovėjimo jutiklio projektą (stacionarus tipas)

• Pirmiausia įjunkite siųstuvą, eikite į savo automobilį ir įjunkite imtuvą. Jei ryšys tarp siųstuvo ir imtuvo užmegztas, jis parodys „Connection: OK“ ir parodys atstumą tarp automobilio ir jutiklio.

• Jei rodoma „Ryšys nenustatytas“, paspauskite imtuvo mygtuką.

• Jei jūsų skardinė yra toli nuo ultragarso jutiklio, gali būti rodoma „Automobilis nėra diapazone“.

• Švelniai važiuokite automobiliu atbulai arba pirmyn į savo aikštelę.

• Kai atstumas tarp automobilio ir jutiklio tampa mažesnis nei 1,0 metras, garsinis signalas pypteli.

• Priartėjus prie jutiklio arčiau, pyptelėjimo dažnis padidėja, kai automobilis pasiekia 1 pėdą arba 0,3 metrą, ekrane raginama sustabdyti automobilį ir jūs turite sustoti.

• Siųstuvas bus nustatytas iš naujo ir automatiškai veiks tuščiąja eiga. Išjunkite imtuvą automobilyje. Jei siųstuvą maitinote akumuliatoriumi, taip pat jį išjunkite.

Kaip valdyti šią automobilio stovėjimo jutiklio signalizacijos grandinę (mobilusis parkavimo jutiklis)

• Panaši anksčiau nurodyta instrukcija, jei imtuve rodoma „Automobilis nėra diapazone“, jūsų automobilis yra toli nuo kliūties.

• Kai išjungiate variklį, siųstuvo grandinė turi išsijungti. Rankiniu būdu išjunkite imtuvo grandinę.

Autoriaus prototipas:

Siųstuvas:

Imtuvas: