Circuito do sensor de estacionamento reverso do carro com alarme

Neste post, vamos construir um circuito de alarme de sensor de estacionamento reverso de carro usando arduino, sensor ultrassônico e módulo transceptor de 2,4 GHz. Este projeto pode ser um recurso adicional para o seu carro se ele não tiver sensores de estacionamento integrados.

Introdução

O projeto proposto tem funcionalidade semelhante à do sensor de estacionamento tradicional, como distância entre o carro e o obstáculo em um display LCD e alerta sonoro de bipe.

O projeto proposto pode ser usado como sensor de estacionamento estacionário, ou seja, o sensor colocado em sua garagem ou sensor de estacionamento móvel, ou seja, sensor colocado na parte de trás do seu carro, se você estiver pronto para assumir um pequeno risco de conectar o projeto ao sistema elétrico do carro.

No entanto, a motivação deste projeto é construir um sensor de estacionamento estacionário que pode ser construída com risco zero.

O projeto de alarme do sensor de estacionamento do carro usando Arduino tem duas partes, o transmissor que consiste em sensor ultrassônico, arduino, buzzer e módulo transceptor de 2,4 GHz. Este circuito medirá a distância entre o carro e o obstáculo.

O receptor consiste em módulo transceptor de 2,4 GHz, arduino e display LCD 16x2.

O circuito receptor será colocado dentro do carro com bateria de 9V como fonte de alimentação. O receptor exibirá a distância entre o carro e o obstáculo em metros.

O transmissor transmitirá os dados do sensor para o receptor dentro do carro via link de 2,4 GHz. O link de comunicação é estabelecido através do módulo NRF24L01.

Agora vamos ver a visão geral do módulo NRF24L01.

Ilustração de NRF24L01:

Este módulo foi projetado para estabelecer um link de comunicação bidirecional entre dois microcontroladores. Funciona no protocolo de comunicação SPI. Possui 125 canais diferentes e taxa de dados máxima de 2 Mbps. Possui alcance máximo teórico de 100 metros.

Configuração do pino:

Ele opera em 3,3 V, portanto, 5 volt no terminal Vcc podem eliminá-lo. No entanto, ele pode aceitar sinais de dados de 5 V de microcontroladores.

Agora vamos passar para o transmissor do projeto.

O circuito é conectado com o módulo NRF24L01 com 5 fios conectados aos pinos de E / S digital do Arduino e o restante dos dois para 3,3V e aterramento. O pino # 2 é conectado à base do transistor que alimentará a campainha.

Os terminais de energia do sensor ultrassônico são conectados a 5V e GND e A0 são conectados ao pino de disparo e A1 é conectado ao pino de eco do sensor.

Os dados de distância do sensor são transmitidos via módulo NRF24L01 para o receptor.

-------------------------------------------------- ----------------------------------------- Faça download do arquivo da biblioteca no link a seguir: github.com/nRF24/RF24.git----------------------------------------- -------------------------------------------------- ---

Programa para transmissor:

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

Isso conclui o transmissor.

Destinatário:

O receptor possui display LCD 16x2 para exibir a medição da distância. A conexão do display é fornecida abaixo:

Ajuste o potenciômetro de 10K para melhor contraste de visualização.

O esquema acima é o resto do circuito receptor. Um botão de pressão é fornecido para redefinir o arduino caso a conexão do link de 2,4 GHz não seja estabelecida.

O circuito receptor é colocado dentro do carro e pode ser alimentado por uma bateria de 9V. O receptor pode ser colocado em uma caixa de sucata, o que pode deixar seu carro com bom aspecto. A caixa de sucata pode ser colocada em seu carro acima do painel de instrumentos ou em qualquer lugar conveniente que você desejar.

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

Agora, isso conclui o receptor.

Como colocar o sensor como sensor de estacionamento estacionário:

Como posicionar o sensor como sensor de estacionamento móvel:

No sensor de estacionamento móvel, o sensor ultrassônico do transmissor é colocado na parte traseira do carro, a energia é fornecida pela bateria do carro. Ele deve ser conectado de forma que, ao desligar a ignição, o arduino seja desconectado da alimentação.

O receptor pode ser colocado dentro do como mencionado antes.

Como operar este projeto de sensor de estacionamento (tipo estacionário)

• Ligue o transmissor primeiro, vá até o carro e ligue o receptor. Se a conexão entre o transmissor e o receptor for estabelecida, ele exibirá “Conexão: OK” e mostrará a distância entre o carro e o sensor.

• Se aparecer “Conexão não estabelecida”, pressione o botão fornecido no receptor.

• Pode ser exibido “Carro fora do alcance” se a lata estiver longe do sensor ultrassônico.

• Conduza suavemente o carro para trás ou para a frente até o estacionamento.

• Conforme a distância entre o carro e o sensor fica inferior a 1,0 metro, a campainha emite um sinal sonoro.

• Conforme você se aproxima do sensor, a taxa de bipe aumenta, uma vez que o carro atinge 1 pé ou 0,3 metro, o display pede para parar o carro e você deve parar.

• O transmissor será reiniciado e ficará ocioso automaticamente. Desligue o receptor em seu carro. Se você alimentou o transmissor por bateria, desligue-o também.

Como operar este circuito de alarme do sensor de estacionamento (sensor de estacionamento móvel)

• É semelhante à instrução declarada anteriormente se o receptor exibir “Carro fora do alcance”, seu carro está longe do obstáculo.

• Quando você desliga o motor, o circuito do transmissor deve desligar. Desligue o circuito receptor manualmente.

Protótipo do autor:

Transmissor:

Destinatário: