Auto Rückwärtsparksensor Stromkreis mit Alarm

In diesem Beitrag werden wir eine Alarmschaltung für den Rückfahrsensor für Autos mit Arduino, Ultraschallsensor und 2,4-GHz-Transceiver-Modul erstellen. Dieses Projekt kann eine Zusatzfunktion für Ihr Auto sein, wenn es keine eingebauten Parksensoren hat.

Einführung

Das vorgeschlagene Projekt verfügt über ähnliche Funktionen wie herkömmliche Parksensoren, z. B. den Abstand zwischen Fahrzeug und Hindernis auf einem LCD-Display und einen akustischen Signalton.

Das vorgeschlagene Projekt kann als stationärer Parksensor verwendet werden, d. H. Als Sensor in Ihrer Garage oder als mobiler Parksensor, d. H. Als Sensor auf der Rückseite Ihres Autos, wenn Sie bereit sind, ein geringes Risiko einzugehen, das Projekt mit dem elektrischen System des Autos zu verkabeln.

Die Motivation dieses Projekts ist jedoch Bauen Sie einen stationären Parksensor die ohne Risiko gebaut werden kann.

Das Alarmprojekt für Parksensoren mit Arduino besteht aus zwei Teilen, dem Sender, der aus Ultraschallsensor, Arduino, Summer und 2,4-GHz-Transceiver-Modul besteht. Diese Schaltung misst den Abstand zwischen dem Auto und dem Hindernis.

Der Empfänger besteht aus einem 2,4-GHz-Transceiver-Modul, einem Arduino und einem 16x2-LCD-Display.

Die Empfängerschaltung wird mit einer 9-V-Batterie als Stromversorgung im Fahrzeug platziert. Der Empfänger zeigt den Abstand zwischen Fahrzeug und Hindernis in Metern an.

Der Sender überträgt die Sensordaten über eine 2,4-GHz-Verbindung an den Empfänger im Fahrzeug. Die Kommunikationsverbindung wird mit dem Modul NRF24L01 hergestellt.

Lassen Sie uns nun die Übersicht über das NRF24L01-Modul sehen.

Abbildung von NRF24L01:

Dieses Modul dient zum Herstellen einer bidirektionalen Kommunikationsverbindung zwischen zwei Mikrocontrollern. Es funktioniert mit dem SPI-Kommunikationsprotokoll. Es hat 125 verschiedene Kanäle und eine maximale Datenrate von 2 Mbit / s. Es hat eine theoretische maximale Reichweite von 100 Metern.

Pin-Konfiguration:

Es wird mit 3,3 V betrieben, sodass 5 Volt am Vcc-Anschluss es töten können. Es kann jedoch 5-V-Datensignale von Mikrocontrollern akzeptieren.

Fahren wir nun mit dem Sender des Projekts fort.

Die Schaltung ist mit einem NRF24L01-Modul mit 5 Drähten verdrahtet, die mit digitalen E / A-Pins von Arduino und den restlichen beiden mit 3,3 V und Masse verbunden sind. Pin 2 ist mit der Basis des Transistors verbunden, die den Summer mit Strom versorgt.

Die Stromanschlüsse des Ultraschallsensors sind mit 5 V und GND verbunden, und A0 ist mit dem Trigger-Pin und A1 mit dem Echo-Pin des Sensors verbunden.

Die Entfernungsdaten des Sensors werden über das Modul NRF24L01 an den Empfänger übertragen.

-------------------------------------------------- ----------------------------------------- Bitte laden Sie die Bibliotheksdatei über den folgenden Link herunter: github.com/nRF24/RF24.git----------------------------------------- -------------------------------------------------- --- ---.

Programm für Sender:

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

Damit ist der Sender abgeschlossen.

Empfänger:

Der Empfänger verfügt über ein 16x2 LCD-Display zur Anzeige der Entfernungsmessung. Die Displayverbindung ist unten angegeben:

Stellen Sie das 10K-Potentiometer für einen besseren Betrachtungskontrast ein.

Das obige Schema ist der Rest der Empfängerschaltung. Zum Zurücksetzen des Arduino ist ein Druckknopf vorgesehen, falls die 2,4-GHz-Verbindungsverbindung nicht hergestellt wird.

Die Empfängerschaltung befindet sich im Auto und kann über eine 9-V-Batterie mit Strom versorgt werden. Der Empfänger befindet sich möglicherweise in einer Müllbox, damit Ihr Auto gut aussieht. Die Junk-Box kann in Ihrem Auto über dem Kombiinstrument oder an einem beliebigen Ort platziert werden.

Programm für Empfänger:

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

Damit ist der Empfänger fertig.

So platzieren Sie den Sensor als stationären Parksensor:

So platzieren Sie den Sensor als mobilen Parksensor:

Beim mobilen Parksensor befindet sich der Ultraschallsensor des Senders auf der Rückseite des Fahrzeugs. Die Stromversorgung erfolgt über die Fahrzeugbatterie. Es sollte so verdrahtet sein, dass sich das Arduino beim Ausschalten der Zündung von der Versorgung trennen muss.

Der Empfänger kann wie oben erwähnt in den Empfänger gestellt werden.

Bedienung dieses Parksensorprojekts (stationärer Typ)

• Schalten Sie zuerst den Sender ein, gehen Sie zu Ihrem Auto und schalten Sie den Empfänger ein. Wenn die Verbindung zwischen Sender und Empfänger hergestellt ist, wird „Verbindung: OK“ angezeigt und der Abstand zwischen Fahrzeug und Sensor angezeigt.

• Wenn 'Verbindung nicht hergestellt' angezeigt wird, drücken Sie die Taste am Empfänger.

• Möglicherweise wird 'Auto nicht in Reichweite' angezeigt, wenn sich Ihre Dose weit vom Ultraschallsensor entfernt befindet.

• Fahren Sie mit Ihrem Auto vorsichtig rückwärts oder vorwärts zu Ihrem Parkplatz.

• Wenn der Abstand zwischen Fahrzeug und Sensor weniger als 1,0 Meter beträgt, piept der Summer.

• Wenn Sie sich dem Sensor nähern, erhöht sich der Piepton. Sobald das Auto 1 Fuß oder 0,3 Meter erreicht, fordert das Display auf, das Auto anzuhalten, und Sie müssen anhalten.

• Der Sender wird zurückgesetzt und geht automatisch in den Leerlauf. Schalten Sie den Hörer in Ihrem Auto aus. Wenn Sie den Sender mit Batterie betrieben haben, schalten Sie ihn ebenfalls aus.

Bedienung dieser Alarmschaltung für Parksensoren (mobiler Parksensor)

• Es ist eine ähnliche Anweisung wie zuvor angegeben, wenn der Empfänger 'Auto nicht in Reichweite' anzeigt. Ihr Auto ist weit vom Hindernis entfernt.

• Wenn Sie den Motor abstellen, muss der Senderkreis abgestellt werden. Schalten Sie den Empfängerkreis manuell aus.

Prototyp des Autors:

Sender:

Empfänger: