MONITOR DE VEÍCULO ESTACIONADO

Hoje em dia a maioria das pessoas possui carro para o deslocamento diário, graças à facilidade de financiamento e com diversas opções de parcelamento. Com o crescimento explosivo das vendas no sector automóvel, a gestão do tráfego e do estacionamento são agora dois grandes problemas, especialmente nas cidades metropolitanas. Deixando de lado o problema do trânsito, o estacionamento tornou-se um grande problema, seja em escritórios ou em casa. Nem sempre é possível encontrar vaga em uma vaga de estacionamento e pode ser necessário estacionar o carro em qualquer lugar disponível. Isso levou a outro problema de roubo de carro. O carro permanece seguro em um estacionamento, mas quando estacionado em algum local distante, fica vulnerável a ser danificado ou roubado por elementos maliciosos. Vem o sistema de travamento central, mas ele apenas protege o precioso veículo contra roubo e não contra danos intencionais.

Neste projeto foi projetado um Sistema Anti-Roubo e Segurança Automóvel baseado em ATMega8 que pode ser instalado juntamente com os Sistemas de Fecho Central. O sistema embarcado desenvolvido neste projeto dota o usuário de um dispositivo de monitoramento remoto do carro que por padrão funciona como um relógio digital e é capaz de alertar o usuário caso algum elemento malicioso tente danificar o carro, tentar arrombar portas ou de alguma forma for capaz de ligar o carro por conta própria ilicitamente.

O sistema envolve dois dispositivos embarcados, um que deve ser instalado no carro e outro um relógio digital que é ao mesmo tempo um sistema de alerta de segurança do carro. Ambos os dispositivos são construídos no microcontrolador ATMega8. O sistema instalável foi projetado através da interface do módulo Acelerômetro GY-61, que pode detectar quaisquer solavancos no carro, e do módulo Bluetooth HC-12, que possibilita a comunicação de mensagens de alerta ao relógio digital remoto e ao sistema de segurança do carro. O sistema de monitor remoto é construído através da interface entre RTC-DS1307 e LCD de 16 × 2 caracteres para exibir mensagens de alerta, caso contrário, data e hora atuais. O dispositivo de monitoramento também se comunica com o sistema embarcado instalado através do módulo Bluetooth HC-12.

Figura 1: Protótipo de dispositivo incorporado no carro para proteção e roubo de carros

O dispositivo de instalação no carro foi projetado fazendo as seguintes conexões de circuito –

1) AVR ATmega8 – Atmega8 é um microcontrolador AVR de 8 bits com 23 pinos de E/S. Ele faz interface com o sensor acelerômetro GY-61 e o módulo Bluetooth HC-12 no circuito deste projeto.

2) Módulo acelerômetro GY-61 (ADXL335) – GY-61 é um módulo acelerômetro de 3 eixos. Ele faz interface com o controlador para detectar quaisquer vibrações no carro. O módulo vem com 5 terminais – VCC, GND, Eixo X, Eixo Y e Eixo Z. O pino VCC do módulo GY-61 está conectado à fonte de alimentação de 5V e o pino GND está conectado ao terra comum. O pino X do GY-61 está conectado ao 23º pino do ATmega8, que é o canal ADC 0 do microcontrolador. O pino Y do GY-61 está conectado ao 24º pino do ATmega8, que é o canal ADC 1 do microcontrolador, e o pino Z do GY-61 está conectado ao 25º pino do ATmega8, que é o canal ADC 2 do microcontrolador.

3) Módulo HC-12 – HC-12 é um módulo de comunicação de porta serial Bluetooth sem fio. Ele é usado para transmitir os dados do dispositivo de instalação no carro para o dispositivo de monitoramento remoto. O módulo possui 5 terminais – VCC, GND, Rx, Tx e SET. O pino VCC do HC-12 está conectado ao 5V DC e o pino GND do HC-12 está conectado ao terra comum. O pino TX do HC-12 está conectado ao 2º pino do ATmega8, o pino RX do HC-12 está conectado ao 3º pino do ATmega8 e o pino SET do módulo HC-12 está conectado ao 4º pino do ATmega8.

4) Conexões opcionais – Além dessas conexões, o dispositivo de instalação no carro pode ser conectado para utilizar mais três canais ADC do microcontrolador ATMega8. Já três canais ADC estão em uso para ler dados do sensor do acelerômetro GY-61. Um canal ADC pode ser usado para registrar alterações na tensão devido à partida automática do carro. Dois canais ADC podem ser usados ​​opcionalmente para conectar o interruptor/relé da chave de ignição e o sistema de trava da porta.

5) Fonte de energia – O dispositivo de instalação no carro pode ser alimentado pela bateria do carro. A tensão da bateria precisará ser regulada para 5V DC usando um regulador de tensão IC como o 7805.

O dispositivo de monitoramento remoto foi projetado fazendo as seguintes conexões de circuito –

1) AVR ATmega8 – O mesmo microcontrolador AVR ATMega8 é usado no dispositivo de monitoramento remoto. No dispositivo de monitoramento remoto, o controlador faz interface com LCD de 16×2 caracteres, módulo Bluetooth HC-12 e RTC DS1307 no circuito deste projeto.

2) Visor LCD 16×2 – Um LCD de caracteres faz interface com o controlador para exibir a data e hora atuais e o status do veículo. Os pinos VSS/GND e LED do módulo LCD são conectados ao terra e os pinos VCC e LED+ do LCD são conectados aos 5V DC. O pino VEE do LCD está conectado a um trimpot de 5k. O pino EN do LCD está conectado ao pino 16 do ATmega8 e o pino RS está conectado ao pino 15 do ATmega8. O pino RW do LCD está conectado ao terra. O LCD tem interface no modo de 4 bits. Assim, os pinos de dados D4, D5, D6 e D7 estão conectados aos pinos 26, 25, 24 e 23 do ATmega8 respectivamente.

3) RTC DS1307 – RTC DS1307 é um relógio em tempo real que faz interface com o AVR ATmega8 para mostrar a hora e a data atuais por padrão no display. O 8º pino do DS1307 está conectado a 5V DC e o 4º pino está conectado ao terra. O primeiro e o segundo pinos são conectados ao oscilador de cristal externo. O 3º pino do DS1307 está conectado ao terminal positivo de uma bateria de 3V e o 4º pino conectado ao terminal negativo de uma bateria de 3V. O 7º pino do DS1307 é conectado ao terminal negativo de um LED, enquanto o terminal positivo do mesmo LED é conectado ao 5V DC por meio de um resistor pull-up. O 5º e 6º pinos do DS1307 estão conectados aos 27º e 28º pinos do microcontrolador ATmega8.

4) Transistor BC548 – BC548 é um transistor NPN que é usado para acionar a campainha no sinal do microcontrolador AVR. O terminal base do transistor está conectado ao 14º pino do ATmega8. O terminal coletor está conectado à campainha e o terminal emissor está aterrado.

5) Módulo HC-12 – O mesmo módulo de comunicação de porta serial Bluetooth sem fio é usado no dispositivo de monitoramento remoto para comunicação de mensagens de alerta com o dispositivo de instalação no carro. O pino VCC do HC-12 está conectado ao 5V DC e o pino GND do HC-12 está conectado ao terra. O pino TX do HC-12 está conectado ao 2º pino do ATmega8, o pino RX do HC-12 está conectado ao 3º pino do ATmega8 e o pino SET do módulo HC-12 está conectado ao 4º pino do microcontrolador ATmega8.

A operação deste sistema pode ser entendida pelo que ambos os dispositivos embarcados de comunicação sem fio fazem. A função e o funcionamento de ambos os dispositivos foram descritos abaixo –

Dispositivo de instalação no carro – Quando o controlador do dispositivo do carro é ligado por uma fonte de 5 Vcc, os LED vermelho e verde começam a brilhar por um tempo e param. Por fim, apenas o LED vermelho brilha por um tempo, o que é uma indicação de que o dispositivo está verificando o módulo HC-12 e lendo tensões analógicas do módulo acelerômetro nos pinos ADC (ADC0 a ADC5). Depois de verificar se o módulo Bluetooth está funcionando bem e se os dados analógicos do sensor do acelerômetro foram recebidos corretamente, o LED vermelho para de brilhar. O LED verde pisca continuamente, o que indica que o microcontrolador está verificando o status de todos os canais ADC a cada 500 milissegundos. Se o LED vermelho acender continuamente, indica que há algum problema de comunicação com o módulo HC-12. Se o LED vermelho começar a piscar, isso indica que um ou mais canais ADC estão lendo alterações na tensão devido a vibração ou flutuações na fonte de alimentação. Assim que a solicitação de status for recebida do dispositivo de monitoramento remoto, o LED vermelho para. Assim, o LED Vermelho é usado como indicador de Erro e o LED Verde é usado como pisca-pisca.

Dispositivo de monitoramento remoto – O dispositivo de monitoramento remoto, por padrão, atua como um relógio digital em tempo real enquanto pisca qualquer mensagem de alerta e inicia a campainha quando recebe a mensagem apropriada do dispositivo do carro. Quando o controlador no dispositivo de monitoramento remoto é ligado por uma fonte de 5 Vcc, inicialmente todos os LEDs conectados a ele brilham por um tempo e a campainha gera um pequeno bipe. Depois disso, o LCD exibe uma mensagem de boas-vindas e verifica a comunicação do módulo HC-12 e a conexão com o módulo DS1307 RTC. Caso haja algum erro na comunicação via módulo HC-12 ou DS1307, será exibida uma mensagem de erro no display LCD. Se todas as conexões estiverem OK, ele começará a exibir a hora e a data atuais no LCD. O dispositivo continua enviando “?” caractere para o dispositivo do carro como uma solicitação de status a cada 500 milissegundos e aguarda a resposta. Se a resposta do dispositivo do carro contiver alguma mensagem de alerta, a campainha receberá um sinal PWM para emitir um bipe e o display LCD piscará a mensagem de alerta. Para interromper o bipe, o usuário precisa pressionar a chave S1, que configura o microcontrolador para o próximo ciclo de monitoramento. Se o RTC DS1307 não estiver conectado, ele deverá ser curto através do Jumper J1, que desvia do RTC e exibe uma mensagem formal “Tenha um bom dia” no LCD.

A hora e a data no dispositivo de monitoramento remoto podem ser atualizadas usando os botões S2 e S3. Quando o botão S2 é pressionado, o dispositivo entra no modo de edição. O botão S3 pode ser usado para alterar o valor do parâmetro selecionado, após o qual o botão S2 pode ser usado para selecionar o parâmetro que precisa ser alterado. Assim que a hora e a data forem atualizadas, o usuário deverá deixar o dispositivo por 5 segundos. Após 5 segundos, a hora e a data são salvas no DS1307 RTC e a data/hora atual são exibidas no LCD.

O dispositivo veicular pode comunicar as seguintes mensagens de alerta ao dispositivo de monitoramento remoto –

1) “SEM SINAL. VERIFICAR VEÍCULO E EMBARQUE” – Esta mensagem significa que o veículo está fora do alcance do sinal (roubo) ou que o dispositivo do automóvel não está respondendo devido à falta de energia. Portanto, o usuário precisa verificar imediatamente o veículo e a alimentação da bateria.

2) “JERKS/VIBRAÇÕES/MOTOR/CHAVE USADA” – Esta mensagem significa que as entradas ADC do dispositivo do carro observaram algumas mudanças em suas tensões de sinal, seja do GY-61 ou da partida do motor ou da porta aberta, etc.

3) “SINAL FRACO OU LONGA DISTÂNCIA” – Esta mensagem significa que o sinal codificado foi recebido pelo dispositivo do automóvel, mas possui valores incorretos. Portanto, o usuário precisa estacionar o veículo um pouco mais próximo para se livrar de sinais ruins e comunicar adequadamente as mensagens de status.

4) “DATA e HORA” ou exibir “TENHA UM BOM DIA” – Estas mensagens significam que nenhum erro foi observado e que o veículo está em condições seguras.

A instalação do dispositivo no carro envolve essencialmente as seguintes precauções –

1) O dispositivo instalado no veículo deve ser instalado em um local que permaneça protegido contra superaquecimento do motor, derramamento de água, etc. .

2) O usuário deve contar com a ajuda de um mecânico especializado para conectar as Entradas de Sinal 1 e 2, que são conexões opcionais de sensores para indicador de porta aberta e indicador de chave de ignição. Essas conexões só podem ser feitas por um mecânico experiente.

Ambos os circuitos são baseados no AVR ATmega8. O AVR é ​​programado em C embarcado usando AVR Studio 4 ou pode ser programado através de outras ferramentas de programação como Atmel Studio ou Notepad++ que também podem ser usadas para escrever e compilar o código. Primeiro de tudo, o usuário precisa adicionar os arquivos da biblioteca necessários anexados abaixo em um arquivo zip e depois copiar e colar o código no AVR Studio 4 para gerar o arquivo hexadecimal. No dispositivo automotivo, o ATmega8 é usado para detectar a vibração via GY-61 e os dados detectados no ADC são enviados para o dispositivo de monitoramento remoto via módulo Bluetooth HC-12. O dispositivo de monitoramento remoto, por padrão, exibe a data e a hora atuais, caso contrário, exibe qualquer mensagem de alerta da instalação no carro em um LCD de caracteres.

O código AVR do dispositivo do carro tem a seguinte divisão –

Constantes usadas no código: –

#define F_CPU 1000000UL :- Constante usada para definir a frequência do clock do MCU

#define FCPU_BY_100 F_CPU/100 :-Frequência dividida por 100 para cálculo da taxa de transmissão

#define ADCAVGDIFF 100: – usado para determinar a alteração do valor ADC

#define ADCEXTREMEDIFF 50: – usado para determinar a alteração do valor ADC

#define BLINKER_LED 0b00100000 :- LED piscante conectado ao pino 5 da Porta D

#define ERROR_LED 0b00100000 :- LED de erro conectado ao pino 5 da Porta B

#define HC12_SET 0b00000100 :-O pino SET do HC-12 está conectado ao pino 2 da porta D

#define ON 1: – Para ligar o LED

#define OFF 0: -Para desligar o LED

#define TOGGLE 2: -Para piscar o LED

#define USART_MAX_RECV_BUF_SIZE 10: – Tamanho máximo dos dados recebidos

Variável usada no código: –

uint8_t isHC12ERROR = 0: – verifique erro na comunicação HC-12

uint8_t USART_RECD_DATA_POS=0: – a posição da matriz de buffer

uint8_t isUSARTQUERY=0: – se RX solicitado para consulta

uint8_t USART_RXD = 0: – Para armazenar dados recebidos

int ADCHIVALUE(6)={0 , 0 , 0 , 0 , 0 , 0} : – Para definir o valor padrão do ADC

int ADCLOVALUE(6)={1024,1024,1024,1024,1024,1024}: – Para definir o valor padrão do ADC

int ADCVALUE (6): – Para armazenar valores ADC

int ADCAVGVALUE(6): – o valor médio do ADC

uint8_t ADC_ERROR_CODE = 0: -Usado para enviar código para RX se houver alteração no valor ADC

Arquivo de cabeçalho e bibliotecas usadas no código: –

#include : – Cabeçalho AVR padrão para entrada/saída

#include :-Cabeçalho AVR padrão para fornecer atrasos de tempo

#include :-Cabeçalho AVR padrão para interrupções

Função usada no código: –

initPorts: -inicializa a porta como entrada e saída

initAdc: -ADC inicializado

readAdc: -Lê o valor dos canais

USART_init: -inicializa a comunicação UART

HC12_sendChar: – envia caractere para HC-12

HC12_sendString: -envia string para HC-12

HC12_sendCommand: -envia comandos para HC-12

HC12_start: – verifique a comunicação do HC-12

setBlinker: -controla o LED do pisca-pisca

setError: -controla o LED de erro

sendStatus: -envia o status dos canais ADC

readAdcValues: -Lê o valor ADC de todos os canais

setAdcValues: -defina os valores ADC padrão

checkAdcValues: -verifica se há alteração no valor ADC

sei :- habilita interrupções

Algoritmo: –

1) Inicialmente, no programa principal, a porta é inicializada para entrada e saída, em seguida o LED piscante e o LED de erro acendem por um tempo e ambos são desligados. Após este UART inicializado para iniciar a comunicação.

_atraso_ms(100);

portasiniciais ;

_atraso_ms(10);

setBlinker(ON);

setError(ON);

_atraso_ms(500);

setBlinker (OFF);

setError(OFF);

USART_init ;

_atraso_ms(100);

2) O ADC é inicializado e o LED de erro é aceso, então uma função é usada para definir os valores padrão do ADC. Depois disso, o LED de erro apaga. A função “sei ” é usada para habilitar as interrupções. Depois disso a comunicação via HC-12 é verificada e iniciada.

initAdc ;

_atraso_ms(100);

setError(ON);

setAdcValues ;

_atraso_ms(200);

setError(OFF);

sei ;

HC12_start ;

3) O programa entra em um loop while, onde a variável do loop é usada para piscar o LED Error quando há um erro nos valores ADC. Nos primeiros 10 ciclos ele verifica os erros e faz a correspondência para diferentes condições.

se (loop>10)

{

setBlinker(TOGGLE);

se (isHC12ERROR)

setError(ON);

senão se (ADC_ERROR_CODE)

setError(TOGGLE);

outro

setError(OFF);

ciclo=0;

}

4) A função “readAdcValues” é usada para ler os valores ADC de todos os canais e a função “checkAdcValues” é usada para verificar erros nos valores.

readAdcValues ;

verificarValoresAdc ;

5) Se o dispositivo de monitoramento remoto enviar uma solicitação de status, ela será enviada por meio do seguinte trecho de código.

se (isUSARTQUERY==1)

{

enviarStatus ;

isUSARTQUERY = 0;

ADC_ERROR_CODE=0;

}

O código AVR do dispositivo de monitoramento remoto tem a seguinte divisão –

Constantes usadas no código: –

#define F_CPU 1000000UL :- Constante usada para definir a frequência do clock do MCU

#define FCPU_BY_100 F_CPU/100 :- Frequência dividida por 100 para cálculo da taxa de transmissão

#define ON 1: – Para ligar o LED

#define OFF 0: – Para desligar o LED

#define TOGGLE 2: – Para piscar o LED

#define ERROR 1: – usado quando há um erro

#define BUTTONS_PORT PIND: – porta do botão definida como porta D

#define BUTTON_UP 0b10000000 :- S3 está conectado ao pino 7 da porta D

#define BUTTON_NEXT 0b01000000 :- S2 está conectado ao pino 6 da porta D

#define BUTTON_MUTE 0b00100000 :- S1 está conectado ao pino 5 da porta D

#define BUTTON_SETTING 0b01000000 :- S2 está conectado ao pino 6 da porta D

#define RTC_BIT 0b00010000 :- jumper J1 conectado ao 4º pino da Porta D

#define HC12_SET 0b00000100 :-O pino definido do HC-12 está conectado ao pino 2 da PORTA D

#define BLINKER_LED 0b00100000 :- LED piscante conectado ao pino 5 da PORTA B

#define BUZZER_BIT 0b00000001 :-buzzer está conectado ao pino 0 da porta B

#define USART_MAX_RECV_BUF_SIZE 40: – o tamanho máximo do valor do buffer recebido

Variáveis ​​​​usadas no código: –

char USART_RECV_BUF(USART_MAX_RECV_BUF_SIZE+1): – usado para armazenar buffer recebido

char TEMP_STR(20): – para armazenar o valor do tempo

uint8_t CURRENT_PROCESS = 0: – Relógio do processo

uint8_t HC12error = 0: – usado para verificar erro no HC-12

uint8_t RTCerror = 0: -usado para verificar erro no RTC

uint8_t isUSART_DATA_READY=0: -verifica os dados recebidos do Tx

uint8_t USART_RECD_DATA_POS=0: – a posição da matriz de buffer

uint8_t USART_RXD = 0: – Para armazenar dados recebidos

uint8_t errorloop = 0: -indicação da campainha de controle

Arquivo de cabeçalho e bibliotecas usadas no código: –

#include : – Cabeçalho AVR padrão para entrada/saída

#include :-Cabeçalho AVR padrão para fornecer atrasos de tempo

#include :-Cabeçalho AVR padrão para interrupções

#include :-usado para realizar operação de cadeia de caracteres

#include “FHN_LCD4_LIB.C”: – Biblioteca LCD

#include “FHN_TWI_LIB.C”: -biblioteca para interface de dois fios

#include “fhn_rtc_ds1307_lib.C”: -Biblioteca RTC

Funções usadas no código: –

initPorts: -inicializa a porta como entrada e saída

initAdc: -ADC inicializado

readAdc: -Lê o valor dos canais

USART_init: -inicializa a comunicação UART

HC12_sendChar: – envia caractere para HC-12

HC12_sendString: -envia string para HC-12

HC12_sendCommand: -envia comandos para HC-12

HC12_start: – verifique a comunicação do HC-12

setBlinker: -controla o LED do pisca-pisca

setBuzzer: – controla a campainha

showDateTime: -mostra a hora no LCD

sendMessage: -envia mensagem via HC-12

editDateTime: -edita hora para RTC

clearUsartRx: – Limpa os dados recebidos no UART

sei :- habilita interrupções

Algoritmo: –

1) Inicialmente, a variável “errorloop” é utilizada para desligar a campainha quando há um erro. A porta é inicializada para entrada e saída. Depois disso, o LED pisca-pisca acende por um tempo e apaga. Depois disso, a campainha emite um bipe curto.

loop de erro uint8_t = 0;

_atraso_ms(100);

initPorts ;

_atraso_ms(500);

definir Pisca-pisca (ON);

_atraso_ms(500);

definir Pisca-pisca (DESLIGADO);

setBuzzer(ON);

_atraso_ms(200);

setBuzzer (OFF);

2) O LCD é inicializado e depois limpo, o que limpa quaisquer valores inúteis. No início, o LCD mostra a mensagem “Monitoramento de veículo estacionado –fnn/..” .que indica que o LCD está funcionando corretamente. Em seguida, o LED pisca-pisca fica ligado por um tempo e depois desligado.

LCD_start ( );

_atraso_ms(100);

LCD_clrscr ;

LCD_writeString(“VEÍCULO ESTACIONADO”);

LCD_gotoRowCol(2, 1);

LCD_writeString(“MONITOR -fhn/..”);

definir Pisca-pisca (ON);

_atraso_ms(500);

definir Pisca-pisca (DESLIGADO);

_atraso_ms(100);

3) A função “sei ” é usada para habilitar interrupções. Então, o UART é inicializado para comunicação Bluetooth. Novamente o LED pisca-pisca fica aceso por um tempo e depois apagado. É iniciada a comunicação via HC-12 e verificado se há alguma mensagem de alerta via comunicação HC-12. Novamente, o LED pisca-pisca fica aceso por um tempo e depois apagado. O LCD está limpo.

sei ;

USART_init ;

definir Pisca-pisca (ON);

_atraso_ms(500);

definir Pisca-pisca (DESLIGADO);

_atraso_ms(500);

Erro HC12 = HC12_start ( );

definir Pisca-pisca (ON);

_atraso_ms(500);

definir Pisca-pisca (DESLIGADO);

_atraso_ms(500);

//RTC_Start ;

_atraso_ms(100);

LCD_clrscr ;

4) O código verifica se o Jumper J1 está conectado e então desvia o RTC. Se J1 não estiver conectado, ele lê o valor RTC. Se houver algum erro na leitura dos dados do RTC será exibida a mensagem “NÃO conectado”. Em seguida, o LCD é apagado.

se ((PIND & RTC_BIT) == 0)

{

LCD_writeString(“VERIFICAÇÃO BY-PASS”);

LCD_gotoRowCol(2, 1);

LCD_writeString(”RTC:DS1307″);

RTCerro = 5;

}

outro

{

LCD_writeString(“Verificar RTC:DS1307”);

LCD_gotoRowCol(2, 1);

RTCerror=RTC_getTime ;

strcpy (TEMP_STR, TIMESTR);

if (RTCerror) //erro

LCD_writeString(“ERRO”);

senão if (strcmp ( TIMESTR, “HH:MM:SS”)==0)

{

LCD_writeString(“NÃO CONECTADO”);

RTCerro = 2;

}

}

_atraso_ms(1500);

LCD_clrscr ;

5) O programa entra em um loop while. Primeiro, ele define o LED para piscar a cada ciclo. Ele limpa o UART. Se o interruptor S1 for pressionado, a campainha será desligada. Se o interruptor S2 for pressionado, ele entrará no modo de edição de tempo. Ele envia uma solicitação de status para o dispositivo do carro via Bluetooth.

setBlinker(TOGGLE);

limparUsartRx ;

if ((BUTTONS_PORT & BUTTON_MUTE) == 0)

{

loop de erro=0;

}

if ((BUTTONS_PORT & BUTTON_SETTING) == 0)

{

editDateTime ;

}

enviar mensagem ( “?” );

6) Se o jumper J1 estiver conectado, a mensagem “TENHA UM BOM DIA MONITOR DE VEÍCULO” será exibida no LCD. Caso contrário, se J1 não estiver conectado, a hora e a data atuais do RTC serão exibidas.

if (erroloop==0)

{

se (RTCerror)

{

LCD_gotoRowCol(1,1);

LCD_writeString (“TENHA UM BOM DIA“);

LCD_gotoRowCol(2,1);

LCD_writeString (“MONITOR DE VEÍCULO “);

_atraso_ms(100);

}

outro

{

RTC_getData ;

_atraso_ms(100);

LCD_gotoRowCol(1,1);

LCD_writeString (“DATA: “);

LCD_writeString (DATESTR);

LCD_gotoRowCol(2,1);

LCD_writeString (“TEMPO: “);

RTC_getTime ;

LCD_writeString (TIMESTR);

LCD_writeString(””);

}

}

7) Se os dados recebidos do UART tiverem alguns valores incorretos, a mensagem “SINAL FRACO OU LONGA DISTÂNCIA” será exibida no LCD. Se os dados recebidos tiverem alguma mensagem de alerta, a mensagem “JEARK/VIBRATION/ENGINE/KEY USED” será exibida no LCD. Se não houver comunicação entre os dois módulos HC-12, a mensagem “NO SIGNAL CHECK VEHICLE & BOARD” será exibida no LCD.

se (isUSART_DATA_READY==1)

{

se (USART_RECV_BUF(0) != '<' USART_RECV_BUF(3) != '>' (USART_RECV_BUF(1)!=USART_RECV_BUF(2)) )

{

loop de erro++;

LCD_gotoRowCol(1,1);

LCD_writeString (“SINAL FRACO OU “);

LCD_gotoRowCol(2,1);

LCD_writeString (“LONGA DISTÂNCIA”);

}

senão se ( USART_RECV_BUF(1) != 0x80 )

{

loop de erro++;

se ( USART_RECV_BUF(1) & 0x07 )

{

LCD_gotoRowCol(1,1);

LCD_writeString (“empurrões/vibração/”);

}

se ( USART_RECV_BUF(1) & 0x38 )

{

LCD_gotoRowCol(2,1);

LCD_writeString (“MOTOR/CHAVE USADO “);

}

}

}

else // sinal está fora de cobertura

{

loop de erro++;

LCD_gotoRowCol(1,1);

LCD_writeString (“SEM SINAL. VERIFICAÇÃO”);

LCD_gotoRowCol(2,1);

LCD_writeString (“VEÍCULO E PLACA.”);

}

8) Se houver alguma vibração detectada pelo dispositivo do carro, ele liga a campainha para emitir bipes.

if (loop de erro> 0)

{

_atraso_ms(250);

setBuzzer(ON);

loop de erro = 1;

}

Confira o código completo e comece rapidamente a construir este projeto interessante. Observe que o sistema projetado aqui se destina a carros e outros veículos de quatro rodas. No entanto, ele pode ser instalado em bicicletas e scooters onde apenas três canais ADC para detectar vibrações e um canal ADC para detectar ignição ou partida automática podem ser usados.

Desafio faça você mesmo –

Quão emocionante teria sido se, em vez de receber as mensagens de alerta em um dispositivo integrado de monitoramento remoto, o usuário pudesse receber as mesmas mensagens em seu smartphone. Tente desenvolver o mesmo projeto com um aplicativo móvel onde o dispositivo de instalação no carro se conecta a um aplicativo móvel e o aplicativo móvel mostra e emite sinais sonoros de alerta.

Compre este projeto agora –

Quantidade necessária do componente

Microcontroladores ATmega8 (A) 2

Visor LCD 16×2 1

Módulos HC-12 2

GY-61 Módulo 1

DS 1307 CI 1

7805 CI2

BC548 Transistor 1

Bateria 3V (C2032) 1

Campainha Piezo 1

Potenciômetro 5K 1

Capacitor 470uf 25V 2

Capacitor 47uf 16V 2

Capacitor de disco 0,1uf 8

Resistor 1K 2

Resistores 3,3K 11

Resistor 10K 7

Resistor 33K 3

Resistor 47K 1

Diodos 1N4007 4

LEDs de 3 mm 6

Cristal 1 de 32,758 KHz

Suporte de bateria 3V 1

Base 2 IC de 28 pinos

Base IC de 8 pinos 1

Botão tátil de 2 pinos 5

Pressione para ligar os interruptores 2

Programador AVR 1

PCB/placa de ensaio conforme necessário

Fio de conexão conforme necessário

//Program to
​/*

filename : ParkedVehicleRx.C

author : fhn

date : 02-mar-2019

mcu : atmega8 (A)

usage : to receive data through HC-12 and set alarm accordingly. else display date and time only

*/


#define F_CPU 1000000UL

#define FCPU_BY_100 F_CPU/100


#define ON  1

#define OFF 0

#define TOGGLE 2

#define ERROR  1

#define OK


#define BUTTONS_PORT PIND

#define BUTTON_UP 0b10000000

#define BUTTON_NEXT 0b01000000

#define BUTTON_MUTE 0b00100000

#define BUTTON_SETTING 0b01000000

#define RTC_BIT 0b00010000 //portD

#define HC12_SET 0b00000100 //portD


#define BLINKER_LED 0b00100000 //portB

#define BUZZER_BIT 0b00000001 //portB



#define USART_MAX_RECV_BUF_SIZE 40

char USART_RECV_BUF(USART_MAX_RECV_BUF_SIZE+1);

char TEMP_STR(20);



#include 

#include 

#include 

#include 


uint8_t CURRENT_PROCESS = 0;

uint8_t HC12error=0, RTCerror=0;

uint8_t isUSART_DATA_READY=0;

uint8_t USART_RECD_DATA_POS=0;

uint8_t USART_RXD = 0;


#include "FHN_LCD4_LIB.C"

#include "FHN_TWI_LIB.C"

#include "fhn_rtc_ds1307_lib.C"

//============================================================

void initPorts ( ) 

{

DDRB=0;

DDRC=0;

DDRD=0;

LCD_DATA_REG  = ( LCD_DATA_BITS );

LCD_CTRL_REG  = ( LCD_ENABLE   LCD_RS );


DDRD  = 0b00000110;  

DDRB  = (BLINKER_LED   BUZZER_BIT);


cli ;  //all interrupts disabled

}

//============================================================

int USART_init ( ) 

{


// INITIATES 9500-8-N-1 FORMAT


UBRRL = 12;

UBRRH = 0;


UCSRA  = (1<'9') ch="0";

if ( ch>'3' && pos==0 )

ch="0";

if ( ch>'1' && (pos==3    pos==7) )

ch="0";

if ( ch>'1' && DATESTR(0)=='3' && pos==1 )

ch="0";

if ( ch>'2' && DATESTR(3)=='1' && pos==4 )

ch="0";

DATESTR(pos%10) = ch;

LCD_gotoRowCol (1,1 );

LCD_writeString ( DATESTR );

}

else

{

ch = TIMESTR(pos%10);

ch++; if (ch>'9') ch="0";

if ( ch>'5' && (pos==13    pos==16) )

ch="0";

if ( ch>'2' && pos==10 )

ch="0";

if ( ch>'3' && TIMESTR(0)=='2' && pos==11 )

ch="0";

TIMESTR(pos%10) = ch;

LCD_gotoRowCol (2,1 );

LCD_writeString ( TIMESTR );

}

}

else if ( (BUTTONS_PORT & BUTTON_NEXT) == 0 ) // MOVES TO NEXT POSITION

{

//isEdited=1;

eloop=0;

pos++;

if (pos>=18)

pos=0;

if (pos==2    pos==5    pos==12    pos==15 )

pos++;

if (pos==6) // for year 2000 series

pos++;

if (pos==7) // for year 2000 series

pos++;

}

else

{

eloop++;

}

}

// set for foolproof except Feb 29 days in leap year (alway 28 days max.)

if ( isEdited==1)

{

if ( DATESTR(0)=='3' && DATESTR(1)>'1')

{ DATESTR(1)='1'; }

if ( DATESTR(3)=='1' && DATESTR(4)>'2')

{ DATESTR(4)='2'; }

if ( DATESTR(0)=='3' && DATESTR(3)=='0' && DATESTR(4)=='2')

{ DATESTR(0)='2'; DATESTR(1)='8'; }

if ( DATESTR(0)=='3' && DATESTR(1)>'0' && DATESTR(3)=='0' &&(DATESTR(4)=='4'    DATESTR(4)=='6'    DATESTR(4)=='9' ))

{ DATESTR(1)='0'; }

if ( DATESTR(0)=='3' && DATESTR(1)>'0' && DATESTR(3)=='1' && DATESTR(4)=='1')

{ DATESTR(1)='0'; }

RTC_WriteDate ( DATESTR );

RTC_WriteTime ( TIMESTR );

LCD_gotoRowCol (2,11 );

LCD_writeString ("SAVED");

_delay_ms ( 2000 );

}

LCD_writeCommand ( 0x0C ); 



}

//============================================================

void clearUsartRx ( )

{

USART_RECD_DATA_POS=0;

isUSART_DATA_READY=0;

USART_RECV_BUF(0)=0;

USART_RECV_BUF(1)=0;

USART_RECV_BUF(2)=0;

USART_RECV_BUF(3)=0;

}

//============================================================

int main ( ) 

{


uint8_t errorloop = 0;


_delay_ms ( 100 );


initPorts  ;

_delay_ms ( 500 );


setBlinker (ON);

_delay_ms ( 500 );

setBlinker (OFF);

setBuzzer ( ON );

_delay_ms ( 200 );

setBuzzer ( OFF );


LCD_start ( );

_delay_ms ( 100 );


LCD_clrscr ;

LCD_writeString("PARKED VEHICLE");

LCD_gotoRowCol (2, 1);

LCD_writeString("MONITOR  -fhn/..");


setBlinker (ON);

_delay_ms ( 500 );

setBlinker (OFF);

_delay_ms ( 100 );




sei ;


USART_init ( );


setBlinker (ON);

_delay_ms ( 500 );

setBlinker (OFF);

_delay_ms ( 500 );


HC12error = HC12_start ( );


setBlinker (ON);

_delay_ms ( 500 );

setBlinker (OFF);

_delay_ms ( 500 );



//RTC_Start ( );

_delay_ms ( 100 );

LCD_clrscr ;

if ((PIND & RTC_BIT) == 0)

{

LCD_writeString("BY-PASS CHECKING");

LCD_gotoRowCol (2, 1);

LCD_writeString("      RTC:DS1307");

RTCerror = 5;

}

else

{

LCD_writeString("Check RTC:DS1307");

LCD_gotoRowCol (2, 1);

RTCerror=RTC_getTime ( );

strcpy (TEMP_STR, TIMESTR );

if ( RTCerror ) //error

LCD_writeString( "ERROR" ); 

else if (strcmp ( TIMESTR, "HH:MM:SS")==0)

{

LCD_writeString( "NOT CONNECTED" );

RTCerror = 2;

}

}


_delay_ms ( 1500 );


LCD_clrscr ;

while ( 1 )

{

setBlinker ( TOGGLE );

clearUsartRx ( );

if ( (BUTTONS_PORT & BUTTON_MUTE) == 0) 

{

errorloop=0;

}

if ( (BUTTONS_PORT & BUTTON_SETTING) == 0) 

{

editDateTime ;

}


sendMessage ( "?" );


if (errorloop==0)

{

if ( RTCerror )

{

LCD_gotoRowCol (1,1);

LCD_writeString ("HAVE A NICE DAY ");

LCD_gotoRowCol (2,1);

LCD_writeString ("VEHICLE MONITOR ");

_delay_ms(100);

}

else

{

RTC_getDate ( );

_delay_ms(100);

LCD_gotoRowCol (1,1);

LCD_writeString ("DATE: ");

LCD_writeString (DATESTR);

LCD_gotoRowCol (2,1);

LCD_writeString ("TIME: ");

RTC_getTime ( );

LCD_writeString (TIMESTR);

LCD_writeString ("  " );

}

}

_delay_ms(500);


if ( isUSART_DATA_READY==1 ) 

{


if ( USART_RECV_BUF(0) != '<'    USART_RECV_BUF(3) != '>'    (USART_RECV_BUF(1)!=USART_RECV_BUF(2)) )

{

errorloop++;

LCD_gotoRowCol (1,1);

LCD_writeString ("WEAK SIGNAL OR  ");

LCD_gotoRowCol (2,1);

LCD_writeString ("   LONG DISTANCE");

}

else if ( USART_RECV_BUF(1) != 0x80 )

{

errorloop++;

if ( USART_RECV_BUF(1) & 0x07 )

{

LCD_gotoRowCol (1,1);

LCD_writeString ("JERKS/VIBRATION/");

}

if ( USART_RECV_BUF(1) & 0x38 )

{

LCD_gotoRowCol (2,1);

LCD_writeString ("ENGINE/KEY USED ");

}

}

}

else // signal is out of coverage

{

errorloop++;

LCD_gotoRowCol (1,1);

LCD_writeString ("NO SIGNAL. CHECK");

LCD_gotoRowCol (2,1);

LCD_writeString ("VEHICLE & BOARD." );


}

setBuzzer(OFF);

if (errorloop>0)

{

_delay_ms(250);

setBuzzer ( ON );

errorloop=1;

}

}

}



//============================================================

ISR ( USART_RXC_vect )

{

USART_RXD = UDR; 



if ( USART_RECD_DATA_POS < USART_MAX_RECV_BUF_SIZE && USART_RXD>0)

USART_RECV_BUF(USART_RECD_DATA_POS++) = USART_RXD;


if ( USART_RECD_DATA_POS>=4 ) //( USART_RXD == '>' )

isUSART_DATA_READY=1;

}

//============================================================

RX
Texas

https://www.engineersgarage.com/wp-content/uploads/2019/10/library_attechment.zip