Circuit de capteur de stationnement inversé de voiture avec alarme

Dans cet article, nous allons construire un circuit d'alarme de capteur de stationnement inversé de voiture en utilisant un arduino, un capteur à ultrasons et un module émetteur-récepteur 2,4 GHz. Ce projet peut être une fonctionnalité complémentaire pour votre voiture s'il ne comporte pas de capteurs de stationnement intégrés.

introduction

Le projet proposé a des fonctionnalités similaires à celles du capteur de stationnement de voiture traditionnel, telles que la distance entre la voiture et l'obstacle sur un écran LCD et une alerte sonore.

Le projet proposé peut être utilisé comme capteur de stationnement stationnaire, c'est-à-dire le capteur placé sur votre garage ou capteur de stationnement mobile, c'est-à-dire capteur placé à l'arrière de votre voiture si vous êtes prêt à prendre un petit risque de câblage du projet avec le système électrique de la voiture.

Cependant, la motivation de ce projet est de construire un capteur de stationnement stationnaire qui peut être construit sans risque.

Le projet d'alarme de capteur de stationnement de voiture utilisant Arduino comporte deux parties, l'émetteur qui se compose d'un capteur à ultrasons, d'un arduino, d'un buzzer et d'un module émetteur-récepteur 2,4 GHz. Ce circuit mesurera la distance entre la voiture et l'obstacle.

Le récepteur se compose d'un module émetteur-récepteur 2,4 GHz, d'un arduino et d'un écran LCD 16x2.

Le circuit récepteur sera placé à l'intérieur de la voiture avec une batterie 9V comme alimentation. Le récepteur affichera la distance entre la voiture et l'obstacle en mètres.

L'émetteur transmettra les données du capteur au récepteur à l'intérieur de la voiture via une liaison 2,4 GHz. La liaison de communication est établie à l'aide du module NRF24L01.

Voyons maintenant la présentation du module NRF24L01.

Illustration de NRF24L01:

Ce module est conçu pour établir une liaison de communication bidirectionnelle entre deux microcontrôleurs. Il fonctionne sur le protocole de communication SPI. Il dispose de 125 canaux différents et a un débit de données maximal de 2 Mbps. Il a une portée maximale théorique de 100 mètres.

Configuration des broches:

Il fonctionne sur 3,3 V, donc 5 volts sur la borne Vcc peuvent le tuer. Cependant, il peut accepter des signaux de données 5V provenant de microcontrôleurs.

Passons maintenant à l'émetteur du projet.

Le circuit est câblé avec le module NRF24L01 avec 5 fils connectés aux broches d'E / S numériques d'arduino et le reste des deux à 3,3 V et à la terre. La broche n ° 2 est connectée à la base du transistor qui alimentera le buzzer.

Les bornes d'alimentation du capteur à ultrasons sont connectées à 5V et GND et A0 est connecté à la broche de déclenchement et A1 est connecté à la broche d'écho du capteur.

Les données de distance du capteur sont transmises via le module NRF24L01 au récepteur.

-------------------------------------------------- ----------------------------------------- Veuillez télécharger le fichier de bibliothèque à partir du lien suivant: github.com/nRF24/RF24.git----------------------------------------- -------------------------------------------------- ---

Programme pour l'émetteur:

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

Cela conclut l'émetteur.

Destinataire:

Le récepteur dispose d'un écran LCD 16x2 pour afficher la mesure de distance. La connexion d'affichage est donnée ci-dessous:

Ajustez le potentiomètre 10K pour un meilleur contraste de visualisation.

Le schéma ci-dessus est le reste du circuit récepteur. Un bouton poussoir est fourni pour réinitialiser l'arduino dans le cas où la connexion de liaison 2,4 GHz n'est pas établie.

Le circuit récepteur est placé à l'intérieur de la voiture, il peut être alimenté par une batterie 9V. Le récepteur peut être placé dans une poubelle qui pourrait donner à votre voiture une belle apparence. La boîte à ordures peut être placée dans votre voiture au-dessus du tableau de bord ou de tout endroit pratique que vous souhaitez.

Programme pour le récepteur:

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

Maintenant, cela conclut le récepteur.

Comment placer le capteur comme capteur de stationnement stationnaire:

Comment placer le capteur comme capteur de stationnement mobile:

Dans le capteur de stationnement mobile, le capteur à ultrasons de l'émetteur est placé à l'arrière de la voiture, l'alimentation est fournie par la batterie de la voiture. Il doit être câblé de manière à ce que lorsque vous coupez le contact, l'arduino doit se déconnecter de l'alimentation.

Le récepteur peut être placé de l'intérieur comme mentionné précédemment.

Comment faire fonctionner ce projet de capteur de stationnement de voiture (type stationnaire)

• Allumez d'abord l'émetteur, allez dans votre voiture et allumez le récepteur. Si la connexion entre l'émetteur et le récepteur est établie, il affichera «Connexion: OK» et indiquera la distance entre la voiture et le capteur.

• S'il affiche «Connexion non établie», appuyez sur le bouton-poussoir fourni sur le récepteur.

• Il peut afficher «Voiture hors de portée» si votre canette est loin du capteur à ultrasons.

• Ramenez doucement votre voiture en marche arrière ou en avant jusqu'à votre parking.

• Lorsque la distance entre la voiture et le capteur est inférieure à 1,0 mètre, le buzzer émet un bip.

• Lorsque vous vous approchez du capteur, la fréquence du bip augmente, une fois que la voiture atteint 1 pied ou 0,3 mètre, l'écran vous invite à arrêter la voiture et vous devez vous arrêter.

• L'émetteur se réinitialise et se met automatiquement en veille. Éteignez le récepteur de votre voiture. Si vous avez alimenté l'émetteur par batterie, éteignez-le également.

Comment faire fonctionner ce circuit d'alarme de capteur de stationnement de voiture (capteur de stationnement mobile)

• Il est similaire aux instructions précédentes si le récepteur affiche «Voiture hors de portée», votre voiture est loin de l'obstacle.

• Lorsque vous coupez le moteur, le circuit de l'émetteur doit s'arrêter. Éteignez le circuit récepteur manuellement.

Prototype de l’auteur:

Émetteur:

Destinataire: