SISTEMA DE MONITORAMENTO DA VELOCIDADE … silva lemos sistema de monitoramento da velocidade em...
106
RODRIGO SILVA LEMOS SISTEMA DE MONITORAMENTO DA VELOCIDADE EM TEMPO REAL PARA VEÍCULOS POR GPS CANOAS, 2010
Transcript of SISTEMA DE MONITORAMENTO DA VELOCIDADE … silva lemos sistema de monitoramento da velocidade em...
RODRIGO SILVA LEMOS
SISTEMA DE MONITORAMENTO DA VELOCIDADE EM TEMPO
REAL PARA VEÍCULOS POR GPS
CANOAS, 2010
RODRIGO SILVA LEMOS
SISTEMA DE MONITORAMENTO DA VELOCIDADE EM TEMPO
REAL PARA VEÍCULOS POR GPS
Trabalho de conclusão apresentado para a banca examinadora do curso de Engenharia de Telecomunicações do Centro Universitário LA SALLE – Unilasalle, como exigência parcial para obtenção do grau de Bacharel em Engenharia de Telecomunicações.
Orientação: Profº Me. Diogo Scolari
CANOAS, 2010
RODRIGO SILVA LEMOS
SISTEMA DE MONITORAMENTO DA VELOCIDADE EM TEMPO REA L PARA
VEÍCULOS POR GPS
Trabalho de conclusão apresentado para a banca examinadora do curso de Engenharia de Telecomunicações do Centro Universitário LA SALLE – Unilasalle, como exigência parcial para obtenção do grau de Bacharel em Engenharia de Telecomunicações.
Aprovado pelo avaliador em 8 de dezembro de 2010.
AVALIADOR:
___________________________________________________
Profº Me. Diogo Scolari
Unilasalle
Dedico este trabalho a minha esposa Jaqueline, pela inspiração e apoio nos
momentos difíceis; minha mãe Zeny, pelo apoio incondicional aos meus estudos; e
principalmente ao meu pai Gomercindo, eterno referencial de caráter e bondade que
me guia e me ilumina de onde quer que esteja.
AGRADECIMENTOS
Agradeço a Deus por ter me guiado nesta difícil e vitoriosa caminhada; aos
familiares, que sempre estiveram comigo; aos amigos, que sempre se mostraram
presentes e interessados e aos colegas de graduação da Unilasalle.
Agradeço aos meus colegas de trabalho, que sempre me deram subsídio
moral e intelectual, para que minhas tarefas pudessem ser concluídas. Sem eles a
caminhada teria sido muito mais difícil.
Ao meu orientador, Prof° Me. Diogo Scolari, por su a paciência ao longo deste
projeto, e dedicação nos momentos decisivos.
Em especial, agradeço a minha esposa Jaqueline, que sempre esteve ao meu
lado em minhas decisões. Sempre me apoiou e me mostrou o caminho mais
sensato, através da sua grandeza e sabedoria.
Finalmente, agradeço aos meus pais Zeny e Gomercindo Lemos, sem os quais,
nada disso teria acontecido. Foram leais às minhas escolhas, muitas vezes
investindo-se no limite das suas forças. A eles trago o fruto do meu trabalho e da
minha dedicação.
RESUMO
Este documento apresenta um estudo focado no desenvolvimento e implementação
de um dispositivo capaz de receber e informar ao condutor de um veículo a máxima
velocidade permitida em um determinado trecho da rodovia, monitorando em tempo
real e informando o momento em que esta é ultrapassada. Instrumento este,
embarcado e independente de qualquer forma de supervisão externa ao veículo,
auxiliado por um sistema de GPS. Na implementação deste projeto foram utilizadas
ferramentas conhecidas pelo estudante de Engenharia de Telecomunicações e de
fácil aquisição tais como: Microcontrolador, módulo GPS, programação em
“Linguagem C” e programas para compilação e programação.
Palavras-chave: Veículo. Velocidade. Rodovia. Tempo real. GPS. Engenharia de
Telecomunicações. Microcontrolador. Linguagem C.
ABSTRACT
This paper presents a study focused on the development and implementation of a
device capable of receiving and informs to the driver of a vehicle the maximum speed
allowed on a particular stretch of highway, real-time monitoring and reporting the time
it is outdated. This instrument, embedded and independent any form of external
supervision to the vehicle, aided by a GPS system. In implementing this project were
familiar tools used by the student of Telecommunication Engineering and affordable
such as microcontroller, GPS module, programming in "C Language" and programs
for building and programming.
Keywords: Vehicle. Speed. Highway. Real time. GPS. Telecomunications
Engineering. Microcontroller. C language.
LISTA DE FOTOS
Foto 1: Protótipo do modelo embarcado....................................................................20 Foto 2: Controle remoto usado no projeto..................................................................39 Foto 3: Gravador com modificação............................................................................43
LISTA DE FIGURAS
Figura 1: Arquitetura interna do AT89S52..................................................................23
Figura 2: Pinagem externa do AT89S52 (DIP – 40 Pinos).........................................24
Figura 3: Constelação dos Satélites...........................................................................25
Figura 4: Estações de Terra.......................................................................................26
Figura 5: Módulo receptor com antena integrada......................................................28
Figura 6: Pinagem......................................................................................................28
Figura 7: Sentenças NMEA recebidas.......................................................................29
Figura 8: Sentenças recebidas através do hiperterminal do Windows......................30
Figura 9: Sentença utilizada no projeto, no detalhe a velocidade em Knots..............32
Figura 10: Placa de Desenvolvimento GGDL-3000...................................................33
Figura 11: Circuito Integrado MAX 232......................................................................35
Figura 12: Aplicação do MAX 232..............................................................................35
Figura 13: No detalhe o delay após cada conjunto de instruções..............................37
Figura 14: Buzzer.......................................................................................................38
Figura 15: Receptor de Infra Vermelho......................................................................39
Figura 16: Diagrama de Blocos do HS0038A2..........................................................40
Figura 17: Sinal reconhecido e processado pelo sensor...........................................40
Figura 18: “Ton” e “Toff” do sinal de teste..................................................................41
Figura 19: Aplicação proposta pelo fabricante...........................................................41
Figura 20: Placa Gravadora Cerne-Tec.....................................................................43
Figura 21: Criando um novo projeto...........................................................................45
Figura 22: Dispositivo escolhido.................................................................................45
Figura 23: Adicionando o código ao ambiente de desenvolvimento..........................46
Figura 24: Indicação da criação do arquivo “.hex”.....................................................47
Figura 25: Simulação de um contador.......................................................................48
Figura 26: IC-Prog 1.05D...........................................................................................49
Figura 27: Interface visual do programa gravador GP 8051 USB..............................50
Figura 28: IC-Prog pronto para gravação...................................................................50
Figura 29: Procedimento de gravação.......................................................................51
Figura 30: Processo de gravação concluído..............................................................51
Figura 31: Escolha da ferramenta a ser programada.................................................52
Figura 32: Testando a transformação de ASCII para ANSI.......................................53
Figura 33: Interface Visual do GPS Diagnostics........................................................55
Figura 34: Área de memória reservada para os SFR................................................60
Figura 35: Trecho do programa utilizado neste trabalho, em detalhe o registrador
IE................................................................................................................................62
Figura 36: Trecho do programa utilizado neste trabalho, em detalhe o registrador
IP................................................................................................................................64
Figura 37: Trecho do programa utilizado neste trabalho, em detalhe o registrador
TMOD (APÊNDICE A)................................................................................................65
Figura 38: Trecho do programa utilizado neste trabalho, em detalhe o
registrador..................................................................................................................66
Figura 39: Trecho do programa utilizado neste trabalho, em detalhe o registrador
TCON.........................................................................................................................67
Figura 40: Em detalhe o registrador SCON................................................................68
Figura 41: Cristal de Quartzo.....................................................................................69
Figura 42: Valor de carga do contador (FDh).............................................................70
Figura 43: Diagrama em bloco da porta serial I/O.....................................................71
Figura 44: Identificação da sentença NMEA..............................................................72
Figura 45: Conversão de Knots para Km/h................................................................73
Figura 46: Imagem capturada no osciloscópio RIGOL DS-1102E.............................74
Figura 47: Início da codificação da tecla de número 8...............................................75
Figura 48: Função de Interrupção..............................................................................76
Figura 49: Atribuição dos limites de velocidade a partir referida tecla no controle
remoto........................................................................................................................77
Figura 50: Limite codificado para ser enviado ao micrcontrolador A.........................78
Figura 51: Os 4 últimos bits da tecla de número 8.....................................................79
Figura 52: Microcontrolador “A” decodificando limites recebidos do microcontrolador
“B”...............................................................................................................................80
Figura 53: Velocidade sendo comparada com limite.................................................80
Figura 54: Condutor com velocidade acima do permitido................................. ........81
LISTA DE TABELAS
Tabela 1: Descrição dos pinos...................................................................................29
Tabela 2: Pinagem do Módulo LCD 16 x 2................................................................36
Tabela 3: Porta P1 com o conteúdo igual ao valor 0xAAh (1010101010b)...............61
Tabela 4: O registrador IE..........................................................................................62
Tabela 5: Registrador IE configurado com valor 84h (10000100b)............................62
Tabela 6: Registrador IP.............................................................................................63
Tabela 7: Registrador IP configurado com valor 04h (00000100b)............................63
Tabela 8: O registrador TMOD...................................................................................64
Tabela 9: Registrador TMOD com TIMER1 configurado no modo 2 (ANEXO
A)................................................................................................................................65
Tabela 10: Registrador TMOD com TIMER0 configurado no modo 1 (ANEXO
B)................................................................................................................................65
Tabela 11: O registrador TCON.................................................................................66
Tabela 12: Registrador TCON configurado com valor 04h (00000100h)...................67
Tabela 13: O registrador SCON.................................................................................67
Tabela 14: Registrador SCON configurado com valor 50h (01010000).....................68
LISTA DE ABREVIATURAS
CTB – Código de Trânsito Brasileiro
CFC – Curso de Formação de Condutores
IPVA -
GPS - Global Positioning System
LCD – Liquid Cristal Display
RF – Rádio Frequencia
SMS -
CPL - Combined Programming Language
BCPL - Basic CPL
UART - Universal Asynchronous Receiver and Transmitter
CI – Circuito Integrado
CPU – Central Processor Unit
ROM – Read Only Memory
PROM – Programable Read Only Memory
EPROM – Erasable Programable Read Only Memory
EEPROM – Electrically Erasable Programable Read Only Memory
RAM – Random Acces Memory
SRAM – Staic Random Acces Memory
DRAM – Dynamic Random Acces Memory
ISP - In-system programming
DIP - Dual In-line Package
PLCC - Plastic Leaded Chip Carrier
TQFP - Thin Quad Flat Pack
EUA – Estados Unidos da América
UTC - Universal Time Coordinated
CDMA - Code Division Multiple Access
PRN - Pseudo-Random Code
NMEA - National Marine Electronics Association
EIA - Eletronics Industries Association
ASCII - American Standard Code for Information Interchange
ZIF - Zero Insertion Force
IDE - Integrated Development Environment
NM – Nautical Mile
LISTA DE SÍMBOLOS
V – volts
DC – Direct Current
VDC – Tensão DC
VAC – Tensão Alternada
KB – Kilo Byte
MHz – Mega Hertz
Km – Kilo Metros
ns – Nano Segundos
Ω – Hom
dB – deci Bell
bps – bits por segundo
mA – mili Ampere
SUMÁRIO
1 INTRODUÇÃO..........................................................................................13
2 APRESENTAÇÃO ....................................................................................15
2.1 Apresentação do Projeto ........................................................................15
2.2 Programação ............................................................................................16
2.2.1 Linguagem C.............................................................................................18
2.3 Implementação em Hardware .................................................................19
2.4 Apresentação dos Principais Componentes ........................................19
2.4.1 Microcontroladores....................................................................................21
2.4.1.1 Microcontrolador AT89S52........................................................................22
2.4.2 GPS...........................................................................................................24
2.4.2.1 Módulo Receptor SkyNav SKM53.............................................................27
2.4.2.2 Padrão NMEA............................................................................................30
2.4.3 Placa de Desenvolvimento GGDL-3000...................................................32
2.4.4 Alimentação...............................................................................................33
2.4.5 Interface de Comunicação........................................................................34
2.4.5.1 MAX 232....................................................................................................34
2.4.6 Display LCD AMC 1602 A.........................................................................35
2.4.7 Buzzer.......................................................................................................37
2.4.8 Sensor Infravermelho................................................................................38
2.4.9 Placa Gravadora CERNE-TEC..................................................................41
2.5 Programas Utilizados ..............................................................................43
2.5.1 Keil uVision 3.............................................................................................43
2.5.2 Gravador CERNE GP8051........................................................................47
2.5.3 IC-Prog......................................................................................................50
2.5.4 DEV-C++...................................................................................................52
2.5.5 GPS Diagnostics.......................................................................................53
3 APLICAÇÃO .............................................................................................55
3.1 Controle da Velocidade ...........................................................................55
3.2 Limite de Velocidade Variável Para Um Determina do Trecho ............56
3.3 Aplicação de Multas em Tempo Real ....................................................57
4 PROCESSOS............................................................................................59
4.1 Configuração do AT89S52 ......................................................................59
4.2 Aquisição e Validação dos Dados GPS .................................................68
4.3 Aquisição dos Limites de Velocidade Para o Trec ho ..........................72
4.4 Comparação .............................................................................................78
5 CONCLUSÃO .......................................................................................... 81
REFERÊNCIAS.........................................................................................83
APÊNDICE A – Código do Microcontrolador A.........................................85
APÊNDICE B – Código do Microcontrolador B.........................................93
ANEXO A – Esquema elétrico da Placa de Desenvolvimento..................99
ANEXO B – Tabela ASCII Padrão..........................................................100
ANEXO C – Tabela ASCII Estendida......................................................101
ANEXO D – Conjunto de instruções do módulo LCD.............................102
1 INTRODUÇÃO
“Brasil é quinto país do mundo em mortes por acidentes de trânsito”, é o que
indica a pesquisa publicada recentemente pela Organização Mundial da Saúde
(OMS). (PORTAL DO TRÂNSITO, 2010)
“Mortes causadas por acidentes de trânsito sobem 20,8% entre 1994 e 2004”
segundo a Agência Brasil, órgão oficial do governo brasileiro. (FÓRUM DE
ENTIDADES NACIONAIS DE DIREITOS HUMANOS, 2007).
Ao se falar em pesquisas sobre acidentes de trânsito no Brasil, todas revelam
uma trágica estatística de crescimento de óbitos nestes eventos, principalmente em
estradas e rodovias. O fator preponderante na maioria das vezes é o desrespeito à
sinalização somado ao excesso de velocidade.
Além de óbitos, mutilações e perdas materiais, o acidente de trânsito traz
diversos prejuízos à sociedade e ao poder público, que arca todo ano com o peso
dos gastos com saúde e indenizações. Gastos estes que se tornam ínfimos se
comparados com o maior dos prejuízos: a perda da vida humana.
Este problema deve-se a inúmeros fatores, dentre eles a falta de educação
para o trânsito e uma fiscalização falha por parte dos órgãos competentes.
Para uma educação eficiente no trânsito não basta somente dar a informação,
é preciso despertar a consciência do indivíduo. O papel da educação é também, e
no caso do trânsito principalmente, desempenhado pela fiscalização que tem se
mostrado inadequada para determinados casos.
Várias medidas vem sendo tomadas, tais como: mudança no CTB, novos
métodos pedagógicos na formação do condutor, aumento das taxas no CFC,
aumento de IPVA, privatizações de rodovias, instalação de novos radares,etc. Tudo
acaba contribuindo positivamente, porém, com muita morosidade no que diz respeito
a redução de acidentes, e com ineficácia no quesito desrespeito aos limites de
velocidade.
Se fizermos um comparativo com o modelo do sistema de “Controle de
Tráfego Aéreo”, onde o piloto obedece a uma série de regras e é orientado e
controlado através de uma série de dispositivos, veremos que algumas adaptações
são plausíveis e necessárias.
14
Alguns anos e muitas mortes por acidentes no trânsito se passarão até que
um sistema eficaz seja implementado, mas o primeiro passo tem que ser dado
urgentemente.
Este documento trata sobre um projeto que visa implemetar o controle da
velocidade através da interação veículo/rodovia através de um sistema embarcado.
Este sistema é responsável por receber parâmetros, ao longo de todo trajeto
percorrido, e apresentar em tempo real instruções ao condutor. Instruções de caráter
mandatório, imperativo, que fazem com que o condutor se mantenha dentro dos
limites de velocidade daquele trecho. O sistema também é capaz de configurar a
infração por excesso de velocidade e aplicar a multa adequada àquela situação.
O projeto está focado no uso da tecnologia na fiscalização de trânsito,
utilizando técnicas e equipamentos de baixo custo cujo tema será abordado com
detalhes no que diz respeito à implementação, componentes, programação e
funcionamento do sistema. Não serão deixados de lado sugestões e comentários
sobre possíveis implementações ao projeto como um todo.
15
2 APRESENTAÇÃO
2.1 Apresentação do Projeto
Este trabalho apresenta o projeto de equipamento capaz de indicar a
velocidade atual de um objeto através dos dados recebidos por um módulo receptor
de GPS. O dispositivo projetado possui também a capacidade de receber dados
externos a ele, através de um receptor de infravermelho, utilizando-os na fixação de
diferentes limites de velocidade ao longo de um determinado trecho. Os limites de
velocidade, os auxílios visuais e a velocidade atual do objeto, são apresentados em
dois “displays de LCD 16 X 2”.
Para este trabalho, o equipamento será aplicado em um automóvel, de forma
embarcada, sendo alimentado pela tomada de 12V deste veículo. Saliento que o
mesmo equipamento possui livre aplicação a qualquer objeto que se mova, neste
caso, utiliza-se uma bateria para sua alimentação.
Ao longo de todo trajeto percorrido pelo veículo serão apresentadas também,
mensagens de informação e advertência de forma visual e sonora, fazendo com que
o condutor se mantenha dentro dos limites de velocidade para aquele trecho,
indicando quais atitudes devem ser tomadas naquele instante.
Todas as atitudes necessárias são tomadas pelo condutor, não há
intervenção da máquina sobre o homem no que diz respeito a condução e a
manutenção da velocidade do veículo. Fica a critério do condutor, permanecer ou
não dentro dos limites de velocidade para aquele trecho. Logo, um serviço extra de
aplicação de multas foi implementado no projeto.
Ao entrar em uma área controlada o equipamento recebe, via RF, o limite de
velocidade para aquele trecho. A velocidade atual a qual se desloca o veículo é
comparada em tempo real com o limite do trecho, caso a velocidade do veículo seja
maior, mensagens de advertência e alertas sonoros são apresentadas ao condutor.
Caso a velocidade permaneça maior, uma indicação sonora e luminosa é
apresentada, indicando que o condutor foi multado. Neste instante o equipamento
aciona o envio de uma mensagem SMS ao posto de fiscalização mais próximo,
indicando que aquele veículo deve ser multado. É claro que esta é uma sugestão de
16
aplicação, porém, totalmente palpável, já que no equipamento encontra-se
implantado o sistema que possibilita o acionamento de um módulo responsável pelo
envio desta mensagem.
A aquisição dos dados GPS é feita através do receptor SkyNav SKM53,
fabricado pela Skylab M&C Technology.
O processamento, controle e armazenamento, são feitos através de um
microcontrolador da família 8051, o “AT89S52”, fabricado pela ATMEL. Este
componente é largamente aplicado na indústria eletro-eletrônica mundial.
A escolha de um microcontrolador desta família se deve a vários fatores,
dentre eles:
Baixo custo do componente – cerca de R$ 5,00 no varejo;
Baixo custo operacional - o 8051 é amplamente difundido nas escolas
técnicas deste país, barateando consideravelmente a mão de obra de programação
e implementação.
2.2 Programação
A programação do microcontrolador pode ser feita em qualquer tipo de
linguagem, tanto em “alto nível” como em “baixo nível”. Basta que se tenha um
software (compilador) capaz de compilar a linguagem escolhida, e que seja capaz de
criar um arquivo com a extensão “.hex”, contendo as instruções e os dados
programados para aquele microcontrolador.
O compilador, para o nosso caso, deve possuir “bibliotecas” com o conteúdo
interno do AT89S52, com informações sobre seus registradores, bancos de
memórias e instruções. O compilador escolhido para este projeto foi o “KEIL
uVISION 3”, e será apresentado posteriormente.
O “KEIL” foi escolhido por possuir ambiente de desenvolvimento, compilador e
ambiente de simulação integrados em uma única interface gráfica. Este software
possui também uma grande vantagem sobre seus concorrentes, a programação
pode ser feita em “Assembly” ou em “C”, já que a maioria de compiladores para este
microcontrolador só aceitam linguagem “Assembly”.
17
A linguagem de programação utilizada foi a “Linguagem C”. Ela foi escolhida
devido a diversos fatores positivos, tanto para a área de desenvolvimento quanto
para produção, vejamos:
• O “C” é muito difundido, tanto na área da indústria quanto na área
acadêmica;
• Esta linguagem serve como base para diversas outras plataformas, isto
acaba sendo um atrativo já que outros softwares como, por exemplo, o
MATLAB, poderão ser manipulados pelo mesmo setor ou operador, caso
seja utilizado como apoio ao desenvolvimento;
• A literatura disponível para “C” é mais difundida do que para outras
linguagens;
• A implementação de cálculos matemáticos é mais acessível em
linguagens de alto nível, como o “C”;
• O número grande de “Bibliotecas” desta linguagem facilita
implementações em software.
Uma desvantagem da linguagem “C” é o tamanho do código “.hex” gerado
pelos compiladores. Este tamanho não segue uma regra, varia de compilador para
compilador. Isto ocorre por que as instruções na linguagem em que foi feita a
programação tem que ser correlacionadas com a linguagem nativa do
microcontrolador. Esta correlação e feita por quem desenvolveu o compilador e pode
variar de um para outro.
Caso a programação fosse feita na linguagem nativa do AT89S52, o
“Assembly”, o espaço ocupado por dados e instruções seria menor. Porém, o
manuseio desta linguagem é muito mais delicado e de difícil implementação em
alguns casos, como por exemplo, o uso de cálculos trigonométricos.
Não descartamos o uso do “Assembly” como segunda opção, dependendo da
habilidade e da vivência do programador com a linguagem.
18
2.2.1 Linguagem C
A primeira versão de “C” foi criada por Dennis Ritchie em 1972 nos
laboratórios da empresa “Bell”. Este protótipo da linguagem “C” foi desenvolvido
para ser incluído como um dos softwares que seriam distribuídos juntamente com o
sistema operacional Unix do computador “DEC PDP-11”, na equipe certificada por
Ken Thompson.
Em 1967 surge a linguagem “CPL” nas universidades de Londres e
Cambridge, com o objetivo de elevar um pouco mais o nível da programação.
Ainda em 1967, em Cambridge, Martin Richards criou o “BCPL”, uma
simplificação do CPL.
Em 1970, Ken Thompson, chefe da equipe que projetou o UNIX para o “ DEC
PDP11” do “Bell Labs”, implementou um compilador para uma versão mais reduzida
do CPL, a linguagem “B’.
Tanto “BCPL” quanto “B’ mostravam-se muito limitadas, prestando-se apenas
para certas classes de problemas.
Após uma tentativa de reescrever o UNIX com uma linguagem de alto nível,
no caso o “B”, constatou-se a inviabilidade por este ser um programa muito lento
para esta aplicação.
Este e outros problemas levaram o projetista Dennis Ritchie, do “Bell Labs’, a
trabalhar no desenvolvimento de uma nova linguagem, sucessora do “B”, que viria
então a ser chamada de “C”.
A linguagem “C” buscou manter o "contato com o computador real" e ainda
sim dar ao programador novas condições para o desenvolvimento de programas em
áreas diversas, como comercial, científica e de engenharia.
Por muitos anos a sintaxe tida como padrão da linguagem “C” foi aquela
fornecida com o “UNIX versão 5.0” do “Bell Labs”. A principal documentação deste
padrão encontra-se na publicação "The C Programming Language", de Brian
Kernighan e Dennis Ritchie (K&R), tida como a "bíblia da linguagem C".
O mais interessante desta versão de “C” era que os programas-fonte criados
para rodar em um tipo de computador podiam ser transportados e recompilados em
outros sem grandes problemas. A esta característica dá-se o nome de portabilidade.
19
Com ela, uma empresa que desenvolve um programa pode fazê-lo rodar em
diferentes computadores sem ter um elevado custo a cada vez que isto for feito.
Finalmente em 1985, o ANSI (American National Standards Institute)
estabeleceu um padrão oficial de C o chamado "C ANSI". (SWAN, 1994)
2.3 Implementação em Hardware
Neste projeto implementamos um receptor de GPS, com antena embutida,
acoplado a um microcontrolador. A comunicação entre os equipamentos é feita
através de uma interface de comunicação no padrão UART, via serial full-duplex de
8 bits.
Implementamos ainda, uma interface visual responsável por apresentar os
dados e os alertas do sistema através de dois displays de LCD de dezesseis colunas
por duas linhas (LCD 16 X 2), e uma interface sonora através um “Buzzer” DC.
Todo este sistema é alimentado através de um circuito com entrada de 12
VDC/VAC e saída de 5 VDC.
2.4 Apresentação dos Principais Componentes
A partir deste item será feita uma apresentação de cada um dos principais
componentes e suas principais características. Não será feito um estudo mais
detalhado de cada componente, afim de evitar fugir do foco deste trabalho.
Os principais componentes utilizados neste projeto são:
• 02 (dois) Microcontroladores AT89S52;
• 02 (dois) Display’s de LCD 16 X 2;
• 01 (um) Módulo Receptor GPS;
• 01 (um) Buzzer;
• 01 (um) Sensor de infravermelho ;
20
• 01 (uma) Interface de comunicação entre o microcontrolador e o
módulo GPS;
• 01 (um) Circuito de alimentação e;
• 10 (dez) Led’s;
• Dentre outros componentes discretos como resistores, capacitores e
transistores.
Os experimentos práticos e as simulações foram efetuados com auxílio de
uma placa de desenvolvimento, que posteriormente será apresentada.
O módulo de GPS e a interface de comunicação e alimentação foram
montados em uma matriz de contatos (protoboard).
O protótipo completo, com o módulo conectado a placa, pode ser visualizado
na foto abaixo.
Foto 1: Protótipo do modelo embarcado Fonte: autoria própria, 2010.
21
2.4.1 Microcontroladores
O microcontrolador é um dispositivo semicondutor produzido em forma de
Circuito Integrado (CI). Os microcontroladores são dispositivos altamente complexos
e versáteis, pois possuem em sua arquitetura todas as partes básicas de um
microcomputador:
• Microprocessador (CPU);
• Memórias não-voláteis (ROM /PROM/EPROM /EEPROM);
• Memórias voláteis (RAM, SRAM, DRAM, Flash RAM);
• Portas de entrada e saídas (paralela e/ou serial, conversores
analógico/digitais, etc.).
Muitas vezes o microcontrolador é chamado de microcomputador de um único
chip, por possuir todas as “etapas” de processamento e controle inerentes a um
microcomputador.
Existem diversos tipos de microcontroladores disponíveis no mercado,
projetados para infinitas aplicações com infinitas características. Além disso,
diversos fabricantes produzem microcontroladores da família 8051 (Intel, AMD,
Atmel, Dallas, OKI, Matra, Philips, Siemens, SMC, SSI).
A Intel iniciou a produção do “8051” em 1981. Em 1982 foram produzidos 2
(dois) milhões de unidades; em 1985 foram 18 milhões; e em 1993, 126 milhões.
(KRAUS JR, 2010)
Além do “8051” propriamente dito, existem variantes como o 8031 (sem
memória ROM interna e com apenas 128 bytes de memória RAM), o 8751 (4 kB de
memória EPROM) e o 8052 (8 kB de memória ROM, um terceiro timer e 256 bytes
de memória RAM. (KRAUS JR, 2010)
Para este projeto foi escolhido o AT89S52, variante do “8052”, fabricado pela
ATMEL. Os motivos desta escolha são muitos, inclusive os já citados na subseção
2.1, “Apresentação do Projeto”, onde o custo operacional e a facilidade de aquisição
na praça local foram fatores decisivos.
22
2.4.1.1 Microcontrolador AT89S52
O AT89S52 é um microcontrolador que surgiu a partir do “8052’ e do “8051’,
logo, possui algumas melhorias em relação a seus antecessores.
Este microcontrolador possui 3 (três) temporizadores/contadores, um a mais
que o “8051”.
Possui maior capacidade de memórias, tanto RAM quanto ROM, e um
número maior de interrupções.
As principais características do AT89S52 são:
• Compatibilidade com os produtos da família MCS 51;
• 8K bytes de memória Flash reprogramável;
• 1000 (mil) ciclos de regravações;
• Faixa de operação entre 4.0 e 5.5 V;
• Operação totalmente estática entre 0 (zero) e 33 MHz;
• Proteção do programa em 3 (três) níveis;
• RAM interna de 256 bytes;
• 32 linhas de E/S (Entrada/Saída) programáveis;
• Três temporizadores/contadores de 16 bits;
• Oito fontes de interrupção;
• Uma UART serial programável “full duplex”;
• Modo de economia de energia desligado/ocioso;
• “Restart” da CPU através de interrupções nos modos de economia de
energia;
• Temporizador cão de guarda (Watchdog Timer);
• Data Pointer duplo;
• Velocidade de programação rápida e;
• Programação ISP.
O AT89S52 é fabricado com 3 (três) tipos de encapsulamento. Podemos
encontrá-lo nos padrões: DIP, PLCC e TQFP. O componente utilizado neste projeto
é o padrão DIP de 40 pinos.
23
As figuras 1 e 2 mostram o diagrama de blocos, retirados do Datasheet deste
CI, e a pinagem externa com a identificação de suas funções.
Figura 1: Arquitetura interna do AT89S52
Fonte: Datasheet ATMEL AT89S52.
24
Figura 2: Pinagem externa do AT89S52 (DIP – 40 Pinos) Fonte: Datasheet ATMEL AT89S52.
Na Seção 4 (quatro) deste trabalho, será feita uma explicação detalhada
sobre o funcionamento geral do projeto. Com o decorrer da apresentação e
explicação, os componentes internos e as funções do AT89S52, que foram
utilizados, vão sendo apresentados.
2.4.2 GPS
A tecnologia atual permite que qualquer pessoa possa se localizar no planeta
com uma precisão altamente satisfatória O sistema responsável por esse avanço é o
Global Positioning System (Sistema de Posicionamento Global - GPS)
O GPS foi concebido pelo Departamento de Defesa dos EUA no início da
década de 1960, sucedendo o “projeto NAVSTAR”, onde os pontos de referência
utilizados não eram satélites e sim radares em solo. O sistema de GPS foi declarado
totalmente operacional apenas em 1995. Seu desenvolvimento custou 10 bilhões de
dólares.
O sistema é composto atualmente por uma constelação de 24 satélites que
orbitam a terra a 20.200 km e emitem simultaneamente sinais de rádio codificados.
25
Testes realizados em 1972 mostraram que a pior precisão do sistema era de
15 metros, e a melhor, 1 metro. Preocupados com o uso inadequado, os militares
americanos implantaram duas opções de precisão: para usuários autorizados (eles
mesmos) e usuários não-autorizados (civis). Os receptores GPS de uso militar
apresentavam precisão de 1 metro e os de uso civil, de 15 a 100 metros.
Figura 3: Constelação dos Satélites Fonte: SCOLARI, 2004.
Cada satélite emite um sinal que contém: código de precisão (P); código geral
(CA) e informação de status. Como outros sistemas de rádio-navegação, todos os
satélites enviam seus sinais de rádio exatamente ao mesmo tempo, permitindo ao
receptor avaliar o lapso entre emissão/recepção. A potência de transmissão é de 50
Watts.
A hora-padrão (UTC) GPS é um dos dados transmitidos pelo satélite.
Receptores de GPS em qualquer parte do mundo mostrarão a mesma hora, minuto
e segundos. A hora-padrão é altamente precisa, pois cada satélite tem um relógio
atômico, com precisão de “ns” (nano segundos).
O receptor tem que reconhecer as localizações dos satélites. Uma lista de
posições, conhecida como almanaque, é transmitida de cada satélite para os
26
receptores. Controles em terra rastreiam os satélites e mantém seus almanaques
acurados.
Figura 4: Estações de Terra Fonte: SCOLARI, 2004.
A transmissão do sinal dos satélites é feita com modulação CDMA em duas
freqüências chamadas de L1 (1575,42 MHz) e L2 (1227,6 MHz).
O sinal gerado pelos satélites contém um "código de identidade" (ou pseudo-
randômico), dados efêmeros (de status) e dados do almanaque.
• O código de identidade “Pseudo-Random Code” (PRN) identifica qual
satélite está transmitindo. Usa-se como referência dos satélites seus
“PRN’, de 1 a 32.
O código pseudo-randômico permite que todos os satélites do sistema
compartilhem a mesma freqüência sem interferências. É um sistema
engenhoso que torna o GPS prático e relativamente barato de se usar. De
fato, os sinais GPS são tão fracos que não são maiores que o ruído de fundo
(de rádio) inerente à Terra. O princípio do código pseudo-randômico, que
significa literalmente "aparentemente aleatório", se baseia em uma
27
comparação realizada em muitos ciclos de um sinal, que é demorada e
incômoda se comparada com um sinal de TV por exemplo.
• Os dados efêmeros (de status) são constantemente transmitidos e
contém informações de status do satélite (operacional ou não), hora, dia,
mês e ano.
• Os dados de almanaque dizem ao receptor onde procurar cada satélite
a qualquer momento do dia. Com um mínimo de três satélites, o receptor
pode determinar uma posição de latitude/longitude – que é chamada
posição fixa 2D – bi-dimensional. Com a recepção de quatro ou mais
satélites, um receptor pode determinar uma posição 3D, isto é,
latitude/longitude/Altitude. Pelo processamento contínuo de sua posição,
um receptor pode também determinar velocidade e direção do
deslocamento.
2.4.2.1 Módulo Receptor SkyNav SKM53
O SkyNav “Série SKM53” é um módulo receptor de sinal GPS que possui um
desempenho compatível com nosso trabalho. Este dispositivo possui uma antena
interna integrada com freqüência central de 1575+- 3MHz e 50 Ω de impedância, o
que facilita sua implementação em diversos tipos de projetos já que dispensa
cablagem e suportes para antenas. Facilita também, pois o projetista não precisa se
preocupar com a aquisição de mais um componente, a antena, e não precisa se
preocupar com diferentes modelos, diferentes fabricantes, conexões e casamentos
de impedância.
28
Figura 5: Módulo receptor com antena integrada Fonte: Datasheet SkyNav SKM 53.
Figura 6: Pinagem Fonte: Datasheet SkyNav SKM 53.
Este receptor possui uma alta sensibilidade na recepção igual a “- 165 dBm”.
O SKM53 recebe o sinal de GPS na banda de freqüência “L1”, com uma taxa
de atualização de posição de 1 HZ. Sua precisão também surpreende positivamente,
são 3m, quando em modo 3D, cerca 0,1 m/s na velocidade e 60ns no tempo.
O módulo processa os dados e os envia a uma taxa de 9600 bps, através de
uma saída UART. Esta saída possui características compatíveis com o
microcontrolador escolhido para este projeto, logo, a conexão pode ser feita
diretamente. Seguindo recomendações do fabricante, foi colocado um resistor de
29
push-pull na saída do módulo GPS, a fim de melhorar a estabilidade na
comunicação.
Tabela 1: Descrição dos pinos
Fonte: Datasheet SkyNav SKM 53
Para visualizar os dados enviados pelo receptor (sentenças NMEA),
diretamente no Hiperterminal do Windows, é necessário implementar uma interface
para o padrão “EIA RS – 232”. Esta interface foi montada com o CI “MAX 232”, que
será apresentado posteriormente.
A série SKM53 suporta as seguintes sentenças NMEA: GGA, GLL, GSA,
GSV, RMC VTG, ZDA.
Figura 7: Sentenças NMEA recebidas Fonte: Datasheet SkyNav SKM 53
30
2.4.2.2 Padrão NMEA
A “National Marine Electronics Association” é o órgão responsável pela
padronização dos equipamentos eletrônicos da Marinha norte-america. Este órgão é
responsável pela criação do padrão que leva seu nome, o padrão NMEA.
Este padrão foi desenvolvido visando a conexão de dispositivos eletrônicos de
uso da Marinha, porém, se tornou um padrão de uso voluntário por parte da
indústria. A sua primeira versão foi liberada em março de 1983. Caba ressaltar que o
padrão NMEA é protegido pelas leis de copyright e não é gratuito e custa cerca de
250 dólares americanos para não-membros da instituição (NMEA).
O padrão NMEA define dentre outros: características elétricas do sinal,
protocolo da transmissão de dados, sincronismo e formatos específicos de
sentenças de transmissão. Este padrão foi adotado internacionalmente na indústria
de receptores GPS devido sua confiabilidade e simplicidade em sua implementação,
além de ser constantemente atualizado (versão, 3.01, data de janeiro de 2002).
Um dos itens deste padrão trata da comunicação e a maneira como são
apresentadas as informações processadas pelo receptor. Estas informações são
processadas de acordo com os dados recebidos da constelação de satélites do
sistema de GPS e atualizadas (na maioria dos equipamentos a atualização é feita
uma vez por segundo). O módulo recebe, dentre outros, horário UTC e, localização
e identidade de cada satélite. O receptor faz os cálculos necessários e apresenta os
resultados através de linhas contendo informações diversas. Estas linhas são
chamas de sentenças NMEA.
31
Figura 8: Sentenças recebidas através do hiperterminal do Windows Fonte: autoria própria, 2010.
Uma sentença NMEA possui até 82 caracteres do padrão ASCII. Cada
sentença começa com o caractere “$” (24h) e termina com um “carriage return” (^M
= 0Dh) e uma instrução de nova linha (“LF”, ^J = 0Ah), tudo retirado do padrão ASCII
(ANEXO B). Todos os campos de dados são delimitados por vírgulas (,) e tem
comprimento variável. Os campos nulos também são delimitados por vírgulas (,)
mas não contêm nenhuma informação. O primeiro campo de dados é um campo de
endereço, chamado de cabeçalho. Este campo identifica a sentença como se fosse
um índice, se for necessário extrair alguma informação específica das sentenças,
basta identificar aquela que contém a informação desejada. O último campo de
dados é um controle de soma conhecido com “checksum”.
O cabeçalho possui uma apresentação que inicia com os caracteres “GP”,
sucedidos de 3 (três) caracteres que nomeiam a sentença, por exemplo:
“$GPGGA”.
Existem ainda sentenças de conteúdo proprietário que iniciam com o
caractere “P” (de “proprietary”), seguido de 3 (três) caracteres que identificam o
fabricante (código da instituição), e mais dois caracteres que identificam a sentença,
por exemplo:
32
Uma sentença proprietária da empresa “GARMIN” é apresentada como,
“$PGRMME” (“P”, “GRM” e “ME”).
Os códigos de alguns dos fabricantes de equipamentos que adotam o formato
NMEA são: ASH (Ashtech), Cmp (C-Map), CSI (Communications Systems Intl), DAS
(Dassault Sercel), DNT (Del Norte), FEC (Furuno Electric Corp), GRM (Garmin
Corp), HPK (Hewlett Packard), e HWM (Honeywell Marine).
Existem várias sentenças, que trazem diversos tipos de dados ao usuário.
Neste projeto foi implementada a sentença “GPRMC”. Esta sentença possui os
dados de “velocidade sobre o solo” em sua composição. (SANTOS, 2010)
Figura 9: Sentença utilizada no projeto, no detalhe a velocidade em Knots Fonte: autoria própria, 2010.
2.4.3 Placa de Desenvolvimento GGDL-3000
As simulações deste projeto foram efetuadas com auxílio dos softwares, que
serão apresentados posteriormente, e da placa de desenvolvimento GGDL-3000.
Esta placa possui um soquete de encaixe rápido para o microcontrolador,
cristal de oscilação e diversos acessórios que podem ser utilizados, como: barra de
33
led’s, buzzer, relé, dentre outros, como pode ser observado na figura abaixo, e em
seu diagrama, no Anexo “A”.
Figura 10: Placa de Desenvolvimento GGDL-3000 Fonte: autoria própria, 2010.
2.4.4 Alimentação
Durante o processo de desenvolvimento foram utilizadas duas formas de
alimentação: fonte de tensão contínua conectada na rede elétrica, e bateria
chumbo/ácida de 12V / 15mA.
A placa de desenvolvimento GGDL-3000 possui circuito de alimentação da
própria placa. Quando utilizada em bancada, foi alimentada com uma fonte de
tensão contínua de 9 ~ 14 V / 500mA. Quando foram efetuados testes em campo, foi
utilizada a bateria citada anteriormente.
O circuito montado na protoboard recebeu a mesma alimentação da placa de
desenvolvimento, tanto em bancada como em campo. Porém, foi implementado um
circuito regulador de tensão (CI 7805) para rebaixar e regular a tensão para 5 V,
34
usados na alimentação do módulo receptor GPS e a interface de comunicação (CI
Max 232).
2.4.5 Interface de Comunicação
O sinal recebido pelo módulo GPS é processado, e é neste momento que o
módulo entra com os dados da constelação de satélites em seu sistema e as
sentenças NMEA são criadas.
Os dados contendo estas sentenças é enviado ao microcontrolador de
maneira serial, full-duplex com 8 bits de dados e um “stop bit”. Este último bit tem a
função de indicar o término de um byte
Esta transmissão ocorre com um Baud Rate de 9600, valor utilizado na
grande maioria dos módulos GPS pesquisados para este trabalho.
Utilizamos uma interface de comunicação com auxílio do CI Max 232.
A placa de desenvolvimento utilizada possui em sua entrada serial este CI,
sua função é transformar o sinal que entrada na placa em um nível que possa ser
reconhecido pelo 89S52.
2.4.5.1 MAX 232
O “CI Max 232”, utilizado na interface de comunicação entre o módulo
receptor e o microcontrolador, é um duplo driver/receptor utilizado na comunicação
serial entre um DTE (terminal de dados) e um DCE (comunicador de dados).
Este componente é comumente utilizado em interfaces onde seja necessário
adaptar os níveis de tensão, como por exemplo, do “TTL” para "CMOS”.
Este padrão é denominado “RS–232” pela EIA, órgão responsável por sua
padronização. Abaixo temos a pinagem deste CI e a montagem/aplicação sugerida
pelo fabricante.
35
Figura 11: Circuito Integrado MAX 232 Fonte: Datasheet MAX 232.
Figura 12: Aplicação do MAX 232 Fonte: Datasheet MAX 232.
2.4.6 Display LCD AMC 1602 A
O display de LCD “16 X 2”, é um “periférico inteligente”, que possui um
microprocessador próprio que se comunica com o mundo externo através de 8 bits.
O display utilizado neste projeto possui 16 colunas por 2 (duas) linhas, onde
cada ponto possui uma matriz “5x8”, que forma o caractere. Este display tem a
capacidade de apresentar 32 caracteres e armazenar mais 64 caracteres em sua
memória interna.
A grande maioria dos displays possui um registrador interno chamado “RS”, e
é através deste registrador que informamos se o que está sendo enviado ao display
36
é um dado ou uma instrução para ele, já que todos os bytes enviados ao LCD
passam por apenas um barramento.
Possui também outros dois registradores importantes, chamados “R/W” (de
Read e Write) e “E” (de Enable). O primeiro é responsável pela leitura e escrita de
um caractere no LCD. Se possuir valor 1 (um) faz a leitura do dado, se possuir valor
0 (zero) faz a escrita do dado.
O segundo, o registrador “E”, trata-se de um “Latch” responsável por habilitar
o recebimento dos dados no LCD, através do barramento de dados de 8 vias.
Existe ainda uma iluminação extra para alguns displays, chamado backlight.
Quando existente é comandada sua intensidade através dos pinos 15 e 16.
Tabela 2: Pinagem do Módulo LCD 16 x 2 Pino Função Descrição
1 Alimentação Terra ou GND 2 Alimentação VCC ou +5V 3 V0 Tensão para ajuste de contraste (ver Figura 1)
4 RS Seleção: 1 - Dado, 0 - Instrução 5 R/W Seleção: 1 - Leitura, 0 - Escrita 6 E Chip select 1 ou (1 → 0) - Habilita, 0 - Desabilitado 7 B0 LSB 8 B1 9 B2 Barramento
10 B3 de 11 B4 Dados 12 B5 13 B6 14 B7 MSB 15 A Anodo p/ LED backlight 16 K Catodo p/ LED backlight
Fonte: adaptado de DATASHEET Display LCD AMC1602A, 2010.
Sempre que um display é iniciado (ligado), deve-se configurá-lo para que
apresente os caracteres da maneira que o programador deseja, isso justifica a
existência do registrador “RS”, pois são enviados bytes com instruções (ANEXO D),
e bytes com dados.
37
Estas instruções são responsáveis pela maneira como o caractere será
apresentado, se da direita para a esquerda ou o contrário, se de baixo para cima, se
será escrito na primeira linha, primeira coluna, etc
Não podemos esquecer que para cada instrução realizada devemos preservar
um delay em nosso programa.
Figura 13: No detalhe o delay após cada conjunto de instruções Fonte: autoria própria, 2010.
2.4.7 Buzzer
Uma das funções deste projeto inclui a emissão de alertas visuais e sonoros.
Os alertas sonoros estão presentes no momento em que o condutor excede o
limite de velocidade, ao receber um novo limite de velocidade para o trecho e no
instante em que é multado.
38
Para emissão destes alertas foi implementado um buzzer de 5 V. Este
componente é facilmente encontrado no varejo, possui custo acessível e fácil
implementação.
Figura 14: Buzzer Fonte: imagem internet, 2010.
2.4.8 Sensor Infravermelho
O modelo proposto indica a utilização de um transmissor de RF, localizado na
via, emitindo os limites de velocidade para o trecho, e um receptor da mesma
tecnologia embarcado no veículo, recebendo estes limites.
Para este trabalho, implementamos um sistema de emissão e recepção com
sinal Infra Vermelho (IR). Este sinal é emitido através de um controle remoto:
Foto 2: Controle remoto usado no projeto Fonte: autoria própria, 2010.
39
O sensor receptor utilizado é o HS0038A2:
Figura 15: Receptor de Infra Vermelho Fonte: Datasheet HS0038A2.
Este sensor possui a função de fotodetector através de um diodo tipo PIN, e
também a função de pré amplificador.
Figura 16: Diagrama de Blocos do HS0038A2 Fonte: Datasheet HS0038A2.
Este receptor identifica o sinal IR e libera em sua saída um sinal de mesma
freqüência e modulação, porém, na forma de onda quadrada. Este processo é
utilizado na decodificação do sinal já que o mesmo possui um filtro interno para
PCM.
40
Figura 17: Sinal reconhecido e processado pelo sensor Fonte: Datasheet HS0038A2.
Figura 18: “Ton” e “Toff” do sinal de teste Fonte: Datasheet HS0038A2.
O componente foi escolhido por ser de fácil implementação, possuir baixo
custo, e alimentação de 5 VDC, a mesma de todos os outros componentes do
λ = 950 nm, sinal de teste, Figura 17
, veja Figura 18
41
projeto. Basta alimentar, aterrar e conectar sua saída em alguma porta do
microcontrolador. No nosso caso, sua saída é conectada no AT89S52, no pino
responsável por sua interrupção.
Figura 19: Aplicação proposta pelo fabricante Fonte: Datasheet HS0038A2.
O processo completo de aquisição dos limites de velocidade, implementado
com IR, será detalhado oportunamente neste trabalho.
2.4.9 Placa Gravadora CERNE-TEC
Para o desenvolvimento do programa responsável pelo controle e execução
do projeto, foram utilizados softwares que serão oportunamente apresentados,
inclusive o software deste gravador.
Após todas as etapas de programação e simulação, um arquivo no formato
“HEX-80” e extensão “.hex” era gravado no microcontrolador, afim de verificar seu
funcionamento.
Para efetuar a gravação deste arquivo foi utilizado um gravador de
microcontrolador conectado com o PC através da porta USB.
O gravador “GP 8051 USB” foi adquirido através da loja virtual Cerne
Tecnologia e Treinamento (www.cerne-tec.com.br).
42
Este gravador utiliza um “PIC 18F 2550” em seu processo de gravação e
funciona com a tensão de alimentação proveniente da própria porta USB, não sendo
necessário utilizar fonte de alimentação externa.
Este gravador possui em seu modelo original um soquete simples tipo DIP de
40 pinos para alojar o microcontrolador, como pode ser visto na figura 20.
Figura 20: Placa Gravadora Cerne-Tec Fonte: www.cerne-tec.com.br , Acessado em julho de 2010.
Para o uso deste gravador, o CI é encaixado no soquete, gravado, e retirado.
O soquete utilizado pelo fabricante não é ideal para este procedimento.
Para solucionar este problema, o soquete simples foi substituído por um
soquete de encaixe rápido tipo ZIF, melhorando consideravelmente o processo de
gravação.
43
Foto 3: Gravador com modificação Fonte: autoria própria, 2010.
2.5 Programas Utilizados
Alguns programas foram utilizados no desenvolvimento deste trabalho.
Plataformas para desenvolvimento de software, emuladores e gravadores.
Todos os programas utilizados foram adquiridos em suas versões gratuitas,
através da internet. Estas ferramentas foram imprescindíveis em todas as etapas de
projeto, desde a concepção até a implementação propriamente dita.
Faremos agora uma apresentação destes programas e em qual etapa do
projeto foram utilizados.
2.5.1 Keil uVision 3
O Keil é basicamente um software que é utilizado no desenvolvimento de
outros softwares, um “Ambiente Integrado de Desenvolvimento” (IDE - Integrated
44
Development Environment). Ele possui uma interface visual muito completa e de
fácil entendimento, além de possuir uma versão gratuita para download.
O Keil possui em sua distribuição, bibliotecas do padrão “ANSI C”, como por
exemplo "stdio" e “stdlib”, e possui também bibliotecas específicas para o
microcontrolador a ser programado.
Existe uma lista muito grande de microcontroladores e PIC’s, de diversos
fabricantes que podem ser escolhidos neste ambiente de desenvolvimento.
Podemos afirmar com convicção que o keil é o software de maior importância
neste trabalho. È nele que a programação e as simulações são efetuadas.
Para utilizarmos esta ferramenta seguimos alguns passos:
1° Abrir o programa e criar um novo projeto, em “Pr oject” e em seguida, “New
uVisio Project”.
Figura 21: Criando um novo projeto Fonte: autoria própria, 2010.
Dentro deste projeto poderão ser incluídos diversos códigos diferentes.
2° Em seguida o keil abre uma janela para que seja escolhido o dispositivo
que será programado. No nosso caso, um microcontrolador do fabricante ATMEL, o
AT89S52.
45
Figura 22: Dispositivo escolhido Fonte: autoria própria, 2010
3° Em seguida, deve-se clicar com o botão direito e m cima de “Source Group
1” afim de adicionar o código que será trabalhado. Caso não se tenha nenhum
trecho pronto, no menu “File”, abrir ”new file” e salvar com a extensão escolhida, no
nosso caso “.C”.
Figura 23: Adicionando o código ao ambiente de desenvolvimento Fonte: autoria própria, 2010.
46
Além das funções já citadas, ele possui também a função de criar, a partir do
código escrito pelo programador, o código em formato hexadecimal (.hex) que será
gravado na memória do microcontrolador.
Figura 24: Indicação da criação do arquivo “.hex” Fonte: autoria própria, 2010.
O equipamento responsável por efetuar esta gravação é o gravador CERNE
GP8051, que será apresentado posteriormente.
O keil em sua versão livre permite que sejam feitas simulações utilizando um
código com tamanho máximo de 2 KB. Esta limitação trouxe um incômodo
considerável na fase de programação e simulação.
A solução encontrada para superar esta dificuldade foi desmembrar o código
e testá-lo em partes diferentes, com tamanhos inferiores a 2 KB. Não se tornaria
viável mudar de software na fase em que foi detectado este problema, já que existia
um prazo estipulado para o fechamento deste projeto.
Para os “delays” e contadores, por exemplo, a técnica de desmembramento
foi muito utilizada.
47
Figura 25: Simulação de um contador Fonte: autoria própria, 2010.
2.5.2 Gravador CERNE GP8051
Como já foi comentado, a gravação do arquivo “.hex” é feita com o gravador
“GP 8051 USB”.
Para o procedimento de gravação utilizou-se o software proprietário deste
gravador, executado com sistema operacional Windows XP.
O software, assim como o hardware, infelizmente não pôde ser usado na sua
forma original. Um segundo programa teve que ser usado em conjunto com o
primeiro, pois este não reconhecia o arquivo “.hex” gerado pelo software Keil.
O problema se deu, pois o keil gera um arquivo que contem somente os
dados e as instruções que devem ser gravados, e o software do gravador precisa
48
além disso que sejam completados com “00FF’ os espaços de memória que não
serão utilizados.
Para solucionar este problema foi utilizado o software “IC-Prog”, que será
apresentado na “Subseção 2.5.3.”.
Figura 26: IC-Prog 1.05D Fonte: autoria própria, 2010.
Repare que no caso acima, o conteúdo do arquivo “.hex” encontram-se a
partir do endereço “0800” e o restante da memória é preenchida com “00FF”.
Solucionado o problema, seguimos os seguintes passos na gravação:
1° Inserir o microcontrolador no ZIF soquete do gra vador.
2° Conectar o gravador na porta USB do PC.
O gravador utiliza driver do próprio Windows, neste instante o hardware é
reconhecido e a interface visual do software á aberta automaticamente. A interface é
intuitiva e de fácil manuseio.
49
Figura 27: Interface visual do programa gravador GP 8051 USB Fonte: autoria própria, 2010.
3° Apagar o conteúdo atual da memória do microcontr olador .
4° Abrir o IC-Prog e selecionar o modelo do microco ntrolador que será
gravado, no nosso caso selecionar AT89S52.
Figura 28: IC-Prog pronto para gravação Fonte: autoria própria, 2010.
5° Através do menu “File”, abrir o arquivo”.hex” qu e deve ser gravado e
salvá-lo com outro nome na extensão “.hex”.
6° Somente agora o software do gravador poderá util izar o arquivo. Clicar
em “Gravar AT89S52 ou AT89S8253”.
50
Figura 29: Procedimento de gravação Fonte: autoria própria, 2010.
7° Ao término da gravação uma mensagem como abaixo informa que o
microcontrolador foi gravado.
Figura 30: Processo de gravação concluído Fonte: autoria própria, 2010.
Após o processo concluído, retira-se o microcontrolador que está pronto para
o uso.
2.5.3 IC-Prog
O IC-Prog é um software gratuito para programar microcontroladores,
memórias e diversos modelos de PIC.
Compatível com diversos gravadores disponíveis gratuitamente na internet. O
IC-Prog como todo bom software gratuito está disponível em diversos idiomas
incluindo português.
51
Este software foi utilizado em nosso projeto como auxiliar no processo de
gravação do microcontrolador, por preencher os requisitos técnicos do hardware
gravador CERNE GP8051 como citado anteriormente.
Sua utilização é muito simples e seu processamento muito rápido, trata-se de
um executável de fácil manuseio. Basta abrir o programa, escolher a ferramenta
(PIC, microcontrolador ou memória) que será feita a gravação e abrir o arquivo
“.hex”.
Figura 31: Escolha da ferramenta a ser programada Fonte: autoria própria, 2010.
Este programa é utilizado também para efetuar gravações no modo ISP, com
utilização da porta paralela do PC. Porém, não foi utilizado com este intuito neste
projeto, pois a gravação foi efetuada com o software próprio do hardware gravador
adquirido, através da porta USB.
52
2.5.4 DEV-C++
O “DEV-C++” é um Ambiente de Desenvolvimento Integrado (IDE) para
programação na linguagem C/C++, gratuito e de código aberto, totalmente escrito
em Delphi
Neste trabalho, foi utilizado em ambiente Windows, como auxiliar na
concepção deste projeto. Sua interface de fácil interação foi fator decisivo na
escolha de um ambiente paralelo ao Keil.
Diversos trechos de código que não tinham ligação direta com o AT89S52, ou
seja, não necessitavam das bibliotecas específicas, foram escritos e testados neste
software.
Figura 32: Testando a transformação de ASCII para ANSI
Fonte: autoria própria, 2010.
Após a análise dos resultados, os trechos eram copiados para o “keil”, sendo
inseridos no código principal.
2.5.5 GPS Diagnostics
53
Este programa foi utilizado como auxiliar na utilização do módulo GPS. Como
o módulo não possui nenhuma interface visual, foi necessário utilizar esta
ferramenta, através da porta serial do PC, em diversas etapas do projeto.
Capaz de identificar diversas sentenças e capaz de identificar diferentes
fabricantes de módulos receptores de GPS. Aplicado ao sistema operacional
Windows, este software possui uma versão livre que pode ser facilmente encontrada
na internet.
O software identifica as sentenças NMEA e apresenta os resultados através
de uma boa interface gráfica, além de apresentar em tempo real o recebimento das
sentenças NMEA na mesma tela.
O GPS Diagnostics foi utilizado para efetuar o teste do equipamento, para
efetuar as medições das velocidades, dos delays do módulo, em fim, foi uma
ferramenta muito importante no desenvolvimento deste trabalho.
54
Figura 33: Interface Visual do GPS Diagnostics Fonte: autoria própria, 2010.
No detalhe da figura 33 as sentenças NMEA sendo recebidas. E acima, as
sentenças interpretadas pelo GPS Diagnostics.
55
3 APLICAÇÃO
Nossa proposta se restringe primeiramente a aplicação em trechos de
estradas e rodovias, onde a fiscalização se mostra cada vez mais ineficiente.
A implementação nestes trechos, de maneira experimental, seria também
muito mais acessível, devido ao tipo de fluxo de veículos. Em uma rodovia existem
basicamente dois sentidos de trânsito, e ambos estão fisicamente muito próximos, o
que facilita a emissão e captura do sinal de RF. Em um trecho urbano com várias
vias fisicamente próximas, o controle individual se torna mais complexo.
Sua aplicação em trechos urbanos está condicionada a mudanças em seu
projeto original, porém, não inviabiliza sua implementação
3.1 Controle da Velocidade
A principal função deste projeto é auxiliar na diminuição de acidentes de
trânsito. Um dos fatores que mais contribui para o acidente de trânsito é a ineficiente
fiscalização da velocidade nas estradas e rodovias.
A legislação brasileira prevê que radares de controle de velocidade devam ser
anunciados quando existentes, levando os maus condutores a reduzir sua
velocidade apenas naquele determinado ponto, e logo em seguida retomam a
velocidade não permitida. Esta fiscalização é falha e ultrapassada, pois apenas um
pequeno trecho da rodovia está sendo fiscalizado efetivamente. Além disso, o custo
de cobertura por radar, para o mesmo tipo de cobertura deste projeto, acabaria
gerando um custo alto para o estado.
Contar apenas com o fator humano na tomada de decisões que podem
colocar a vida de terceiros em risco, e contar apenas com a consciência do condutor
esperando que sejam cumpridas as regras de trânsito, não nos parece ser a melhor
opção. Logo, uma interação e um determinado controle efetuado pela máquina se
tornam indispensável.
Aliado a uma política de educação eficiente para o trânsito, o controle é a
melhor forma de garantir a queda no número de acidentes de trânsito.
56
Para este trabalho foi implementado um sistema de controle onde a
velocidade atual do objeto é dada pelo sistema de GPS.
O equipamento embarcado recebe os dados da velocidade e recebe ao longo
da via, por outro sistema, os limites de velocidade. O sistema de GPS atualiza seus
dados uma vez por segundo, logo, a velocidade é atualizada com esta freqüência.
Constantemente a velocidade e o limite para o trecho são comparados,
independentes de outro sistema externo, assim, a fiscalização é feita
individualmente em cada veículo.
3.2 Limite de Velocidade Variável Para Um Determina do Trecho
Além de efetuar uma fiscalização mais eficiente, este projeto trás uma
melhoria na qualidade do trânsito com a implementação de limites de velocidade
variáveis.
Como vimos anteriormente, o condutor intercepta um transmissor de RF no
início e no fim do trecho a ser fiscalizado. O limite de velocidade para aquele trecho
é apresentado no display juntamente com um alerta sonoro. A velocidade pode
ainda ser apresentada em painéis na rodovia, no mesmo ponto do transmissor.
Estes painéis eletrônicos de indicação são aplicados atualmente em diversas
rodovias no Brasil.
Ainda sobre o transmissor de RF, este deverá ser controlado remotamente,
via fibra óptica, RF, Data link, etc. A tecnologia utilizada para seu controle pode
variar de acordo com a disponibilidade local.
Logo, a velocidade para um determinado trecho pode ser monitorada e
modificada a qualquer instante, remotamente, de acordo com vários parâmetros, tais
como:
Condições meteorológicas no trecho monitorado - Uma rodovia que se
encontra sob neblina não deveria possuir o mesmo limite de velocidade que possui
em um dia ensolarado, por exemplo. O mesmo se aplica para condições de chuva e
durante a noite;
Fluxo de veículos no trecho monitorado – Uma rodovia possui um fluxo de
veículos variável. Logo, o controle desse fluxo deve ser tratado de maneira
57
diferenciada. O fluxo pode variar em determinados horários do dia ou em datas
especiais como finais de semana prolongados e feriados. A aplicação de um limite
de velocidade de acordo com o fluxo deve diminuir o congestionamento e acabar
com o trânsito proibido nos acostamentos. Lembrando que o motivo de muitos
congestionamento e paradas bruscas se deve ao fato de o condutor “furar a fila” pelo
acostamento, fazendo com que todos os outros parem ou diminuam a velocidade
para que ele entre novamente na via;
Da mesma forma, a rodovia pode ter seu limite de velocidade aumentado,
trazendo um ganho muito grande de qualidade no trânsito.
Este monitoramento e controle devem ser feitos por órgão competente, de
forma criteriosa e com a tecnologia que julgar conveniente.
3.3 Aplicação de Multas em Tempo Real
De nada adianta impor um limite de velocidade e fiscalizá-lo se não houver
um sistema de punição para quem ultrapassar o limite imposto.
O projeto prevê a implementação de um módulo GSM podendo ser utilizado
para o envio de uma mensagem ao posto policial mais próximo caso o veículo
ultrapasse o atual limite de velocidade. Ressaltamos que o projeto prevê esta
implementação, porém, este item não foi executado neste trabalho.
No entanto, o controle deste módulo e a simulação de seu acionamento foram
implementados junto ao software e ao hardware deste projeto.
O veículo ao ultrapassar o limite de velocidade é alertado através de
mensagens apresentadas no display, além de alertas sonoros emitidos pelo buzzer.
Somente após a permanência nesta situação por um período de tempo determinado,
a mensagem de multa é enviada através do módulo GSM (ou GPRS). Esta
mensagem contém a identidade digital do veículo, podendo ser facilmente
implementado o local onde ocorreu a infração (através do GPS) e o tipo de infração
(média, grave ou gravíssima) de acordo com o percentual excedido, como prevê o
CTB.
Em seguida o condutor é alertado mais uma vez, através do display e do
buzzer, desta vez informando que o veículo foi multado. Neste caso, após
58
implementarmos o algoritmo para tipificar a multa, o valor da mesma pode ser
apresentado ao condutor no display de LCD no instante em que este foi multado.
59
4 Processos
Nesta seção faremos uma explicação sobre os processos de aquisição dos
dados GPS, limites de velocidade e como é feito o processamento deste conteúdo.
A partir da próxima subseção a explicação será feita a partir da programação
do AT89S52, onde partes do código que se encontra nos anexos”B” e ”C”, serão
apresentadas ao longo desta seção.
Como foi citado anteriormente, os componentes internos utilizados (partes
internas do microcontrolador, LCD e demais componentes) serão apresentados ao
longo da explicação, a fim de facilitar a leitura e a compreensão deste trabalho.
4.1 Configuração do AT89S52
O AT89S52 possui uma região de sua memória composta por alguns
registradores de funções especiais. São os chamados SFR.
Na área de memória SFR, existem alguns registradores que são bytes e bits
endereçáveis, e outros que são apenas bytes endereçáveis. Nesta área não é
possível fazer gravação de código.
Figura 34: Área de memória reservada para os SFR Fonte: INTERNET, 2010.
60
Estes registradores devem ser configurados de acordo com a aplicação do
microcontrolador. Neste trabalho utilizamos alguns deles:
• P0, P1, P2 e P3 – As “portas” 0, 1, 2 e 3 são SFR’s de 8 bits cada, que
possuem seus estados apresentados diretamente em seus pinos físicos
correspondentes, como visto na Fig. Xx. Estes bits podem ser acessados
individualmente e são usados como portas de E/S. Neste projeto estas
portas são utilizadas para enviar e receber dados tanto para periféricos
como de um microcontrolador para o outro. No caso de acionamento de
periféricos optamos pelo acionamento através de transistor do tipo PNP,
com acionamento em nível baixo. Abaixo, um exemplo de utilização da
porta P1:
Tabela 3: Porta P1 com o conteúdo igual ao valor 0xAAh (1010101010b) Pino 8 7 6 5 4 3 2 1
Identificador P1.7 P1.6 P1.5 P1.4 P1.3 P1.2 P1.1 P1.0
Valor do Bit 1 0 1 0 1 0 1 0
Nível de Saída VCC GND VCC GND VCC GND VCC GND
Fonte: autoria própria, 2010.
• IE (Interrupt Enable) – O registrador “IE” é o responsável por habilitar
as interrupções do AT89S52 que se deseja utilizar.
Seus bits são endereçáveis por software, não podendo ser acessados
diretamente como nas portas “P0 -3”.
Para habilitar uma interrupção, atuamos neste registrador através das
seguintes chaves:
61
Tabela 4: O registrador IE Bit 7 6 5 4 3 2 1 0
Símbolo EA ----- ET2 ES ET1 EX1 ET0 EX0
1 – Habilita Interrupção 0 – Desabilita Interrupção
Fonte: adaptado de DATASHEET AT89S52, 2010.
Onde “EA”, habilita todas interrupções que estiverem selecionadas com nível
alto. Neste projeto esta sendo utilizada a interrupção “EX1” (Interrupção
Externa 1 – INT1). Esta interrupção é utilizada no recebimento dos limites de
velocidade.
Para este trabalho o registrador “IE’ foi configurado da seguinte maneira:
Tabela 5: Registrador IE configurado com valor 84h (10000100b) Bit 7 6 5 4 3 2 1 0
Símbolo EA ----- ET2 ES ET1 EX1 ET0 EX0
Nível 1 0 0 0 0 1 0 0
Fonte: autoria própria, 2010.
Figura 35: Trecho do programa utilizado neste trabalho, em detalhe o registrador “IE” Fonte: autoria própria, 2010.
62
• IP (Interrupt Priority) – Para programarmos a prioridade de uma
interrupção, utilizamos o registrador IP cujas chaves são:
Tabela 6: Registrador IP Bit 7 6 5 4 3 2 1 0
Símbolo ----- ----- ----- PS PT1 PX1 PT0 PX0
1 – Interrupção com prioridade de atendimento 0 – Interrupção sem prioridade
Fonte: adaptado de DATASHEET AT89S52, 2010.
As prioridades são sempre programadas dentro de sua categoria, por
exemplo, com “PT0” igual 1(um) o TIMER0 é atendido antes do TIMER1.
Para este trabalho a prioridade de acionamento é da Interrupção
Externa1, a única utilizada no momento, porém, optamos por deixar este
registrador preparado caso fossem introduzidas novas interrupções.
O registrador IP foi configurado da seguinte maneira:
Tabela 7: Registrador IP configurado com valor 04h (00000100b) Bit 7 6 5 4 3 2 1 0
Símbolo ----- ----- ----- PS PT1 PX1 PT0 PX0
Nível 0 0 0 0 0 1 0 0
Fonte: autoria própria, 2010.
63
Figura 36: Trecho do programa utilizado neste trabalho, em detalhe o registrador IP Fonte: autoria própria, 2010.
• TMOD (Time Mode) – Este registrador seleciona o timer que será
utilizado e o modo de operação deste timer (temporizador ou contador). Os
bits M1 e M0 são utilizados na escolha do modo, de 0 (zero) a 3 (três).Abaixo
a configuração para este projeto:
Tabela 8: O registrador TMOD Bit 7 6 5 4 3 2 1 0
Símbolo GATE1 C/T1 M1 M0 GATE0 C/T0 M1 M0
TIMER 0 TIMER 1
Fonte: adaptado de DATASHEET AT89S52, 2010.
Foram utilizados os TIMER’s 0 (zero) e 1 (um) neste projeto, nos
modos 1 (um) e 2 (dois). O modo 1 configura o TIMER como temporizador de
16 bits, e o modo 2 (dois) como temporizador de 8 bits.
Tabela 9: Registrador TMOD com TIMER1 configurado no modo 2 (ANEXO A)
64
Bit 7 6 5 4 3 2 1 0
Símbolo GATE1 C/T1 M1 M0 GATE0 C/T0 M1 M0
Nível 0 0 1 0 0 0 0 0
Fonte: autoria própria, 2010.
Figura 37: Trecho do programa utilizado neste trabalho, em detalhe o registrador TMOD (APÊNDICE A)
Fonte: autoria própria, 2010.
Tabela 10: Registrador TMOD com TIMER0 configurado no modo 1 (ANEXO B) Bit 7 6 5 4 3 2 1 0
Símbolo GATE1 C/T1 M1 M0 GATE0 C/T0 M1 M0
Nível 0 0 0 0 0 0 0 1
Fonte: autoria própria, 2010.
65
Figura 38: Trecho do programa utilizado neste trabalho, em detalhe o registrador TMOD (APÊNDICE B)
Fonte: autoria própria, 2010.
• TCON (Time Control) – Neste registrador podemos configurar bits de
TIMER e bits de interrupções:
Tabela 11: O registrador TCON Bit 7 6 5 4 3 2 1 0
Símbolo TF1 TR1 TF0 TR0 IE1 IT1 IE0 IT0
TIMER INTERRUPÇÃO
Fonte: adaptado de DATASHEET AT89S52, 2010.
É no “TCON’ que escolhemos a forma de como será feita a interrupção
(no nosso caso INT1), se por borda ou nível. Colocando-se o flag IT1 para
nível 1 (um), o acionamento é feito por nível, e 0( zero), é feito por borda.
Para este trabalho a interrupção é acionada na “borda de descida” do sinal
responsável pela interrupção (sinal de infravermelho). Logo, coloca-se 1 (um)
no flag IT1:
66
Tabela 12: Registrador TCON configurado com valor 04h (00000100h) Bit 7 6 5 4 3 2 1 0
Símbolo TF1 TR1 TF0 TR0 IE1 IT1 IE0 IT0
Nível 0 0 0 0 0 1 0 0
Fonte: autoria própria, 2010.
Figura 39: Trecho do programa utilizado neste trabalho, em detalhe o registrador TCON
Fonte: autoria própria, 2010.
• SCON (Serial Control) – Neste registrador é feita a configuração da
porta serial do AT89S52. Ele contém não somente os bits de controle de
modo, como também o nono bit para transmissão e recepção (TB8 e RB8),
e os bits de controle de interrupções de transmissão de recepção da serial
(TI e RI).
Tabela 13: O registrador SCON Bit 7 6 5 4 3 2 1 0
Símbolo FE/SM0 SM1 SM2 REN TB8 RB8 TI RI
Fonte: adaptado de DATASHEET AT89S52, 2010.
67
O módulo de GPS se comunica com o microcontrolador através do
padrão UART de 8 bits, isto equivale ao modo 1 na configuração do SCON.
Logo, os bits SM0 e SM1 recebem 0 (zero) e 1 (um) respectivamente.
Em seguida, é necessário habilitar a recepção serial através do bit
“REN”.
Tabela 14: Registrador SCON configurado com valor 50h (01010000) Bit 7 6 5 4 3 2 1 0
Símbolo FE/SM0 SM1 SM2 REN TB8 RB8 TI RI
Nível 0 1 0 1 0 0 0 0
Fonte: autoria própria, 2010.
Figura 40: Em detalhe o registrador SCON Fonte: autoria própria, 2010.
68
4.2 Aquisição e Validação dos Dados GPS
Como citado no início deste trabalho, foram usados dois AT89S52, um desses
microcontroladores tem a função receber e processar os dados do GPS, e
apresentar a velocidade do objeto em um dos dois displays de LCD, neste caso o
“display A”. O microcontrolador em questão também será denominado de
“microcontrolador A”
Os dados com as sentenças NMEA são recebidos pelo “microcontrolador A”
através da porta serial. Esta comunicação é feita através dos padrões inseridos no
SCON, a uma taxa de 9600 bps. Esta é a taxa de recepção que precisa ser
configurada através do temporizador, no nosso caso através do “TIMER 1”.
Para utilização de qualquer um dos temporizadores é necessário que se
aplique um cristal entre os pinos 18 e 19 do AT89S52 para acionar o circuito
oscilador interno do microcontrolador. Este cristal é formado por quartzo e possui
características piezoelétricas.
Figura 41: Cristal de Quartzo Fonte: INTERNET, 2010.
Um cristal com freqüência de 11.0592 MHz foi escolhido, pois o mesmo gera
uma taxa de erro de 0% para o Baud Rate em questão, que é calculado da seguinte
forma:
Baud Rate = k * (Freqüência do Oscilador) / 32 * 12 * [256 – (TH1)]
• Se SMOD = 0, k = 1;
69
• Se SMOD = 1, k = 2;
• SMOD = bit 7 de PCON;
• Ou seja,
se SMOD = 0, logo, TH1= 256 – ((Freqüência do Oscilador / 384) / Baud);
se SMOD = 1, logo, TH1= 256 – ((Freqüência do Oscilador / 192) / Baud).
• Para o cristal e Baud Rate em questão:
TH1 = 256 – ((11059200 / 384) / 9600)
TH1 = 256 – 3
TH1 = 253
• O valor a ser carregado em TH1 é igual a 253 (FDh), como pode ser
visto no código abaixo:
Figura 42: Valor de carga do contador (FDh) Fonte: autoria própria, 2010.
70
Sabemos que a comunicação é feita com 8 bits de cada vez, mais um bit de
parada. Ou seja, o módulo envia um caractere por vez.
Os caracteres tem que ser armazenados para posteriormente serem
processado, estes são armazenados no SBUF (Serial Buffer), um de cada vez, após
o reconhecimento do bit de parada.
O SBUF é um registrador de 8 bits, utilizado tanto para armazenar como para
enviar os dados na via serial:
Figura 43: Diagrama em bloco da porta serial I/O Fonte: adaptado de DATASHEET AT89S52, 2010.
Feitas as configurações necessárias, iniciamos pelo reconhecimento de uma
sentença NMEA.
Sabemos que toda sentença começa com o caractere “$”, que possui
codificação ASCII (ANEXO D) igual a “0x24h”.
O primeiro passo é identificar quando o microcontrolador está recebendo uma
sentença NMEA, para depois identificar a sentença que contem os dados de
velocidade real. Porém, após manusear diversas vezes estas sentenças, foi
observado que a sentença “$GPRMC” (sentença que possui os dados de velocidade
real) é a única que possui o caractere “R”, e este está presente no cabeçalho da
sentença. Logo, descartamos a identificação do “$” e seguimos direto para a
identificação do “R”.
71
Para identificar um caractere é necessário receber, armazenar no SBUF, e
comparar com o que está sendo procurado.
Após identificar o cabeçalho da sentença que será utilizada, os caracteres
seguintes são armazenados em um vetor de 60 posições, tamanho suficiente para
armazenar a sentença inteira.
Depois de armazenada a sentença, é necessário verificar a validade dos
seus dados. Quando os dados são totalmente confiáveis, a sentença apresenta o
caractere “A” na posição 16 do vetor, que teve como início o caractere “R”.
Figura 44: Identificação da sentença NMEA Fonte: autoria própria, 2010.
Com a sentença totalmente capturada, e sua validade checada, os dados de
velocidade já podem ser processados.
A primeira coisa a ser feita é a conversão da velocidade de “Knots” para
“Km/h”. Para isso, multiplica-se a velocidade recebida por “1,85”. Pois, sabe-se que:
1 Knot = 1 NM / hora e;
1 NM = 1,852 m então;
1 Km/h = 1,852 * 1 Knots, usamos 1,85 (esta precisão é suficiente)
72
Figura 45: Conversão de Knots para Km/h Fonte: autoria própria, 2010.
Lembrando que o módulo GPS envia caracteres no Padrão ASCII, e estes,
tem que ser convertidos para o padrão ANSI no formato “Inteiro”, para só então
serem feitos os cálculos e as conversões necessárias.
Depois de Identificada a velocidade, esta é apresentada no “display A”.
4.3 Aquisição dos Limites de Velocidade Para o Trec ho
Neste projeto os limites de velocidade são identificados através do
recebimento de um sinal infravermelho, emitido pelas teclas de um controle remoto.
Para este trabalho foram decodificadas as teclas dos números 4 (quatro), 6
(seis) e 8 (oito). Estas teclas estão relacionadas aos limites de velocidade iguais a
40, 60 e 80Km/h, respectivamente. Foi decodificada ainda, a tecla de liga/desliga
para indicarmos o ingresso em uma região em que não há fiscalização pelo sistema
de GPS.
73
O sensor receptor de infravermelho tem sua saída conectada a porta “P3.3”
(pino 13) do “microcontrolador B”. Este é o gatilho que dispara a interrupção externa
“INT1” neste microcontrolador.
A porta “P3.3” possui naturalmente nível alto em seu registrador e o
acionamento ocorre em nível baixo, tanto em borda de descida quanto em detecção
de nível baixo. Para este projeto a interrupção é acionada no momento em que há a
detecção de uma borda de decida neste registrador.
O sinal infravermelho emitido pelo controle remoto possui as seguintes
características:
• Possui codificação no padrão PCM;
• Inicia em nível baixo e permanece por um longo tempo (10 ms) e em
seguida há um nível alto de aproximadamente 5 ms;
• Após estas duas transições inicia-se um padrão de transmissão de 26
bits que estão presentes em todas as teclas do controle remoto em
questão, e que serão ignorados neste projeto:
Figura 46: Imagem capturada no osciloscópio RIGOL DS-1102E Fonte: autoria própria, 2010.
74
• Na tela do osciloscópio o sinal de infravermelho é apresentado
da direita para esquerda. Após o trânsito destes 26 bits inicia-se o
recebimento do código em 16 bits, da tecla que foi pressionada.
Figura 47: Início da codificação da tecla de número 8 Fonte: autoria própria, 2010.
Então, o início do código específico se dá após a passagem das duas
transições iniciais, mais o trânsito dos 26 bits padrão. Aproximadamente no instante
58,5 ms como pode ser visto na fig.xxxx, em seguida, inicia-se o processo de
decodificação.
A sequência de decodificação implementada passa pelos seguintes passos:
1° - O microcontrolador identifica uma interrupção. Neste instante, o local
onde o programa foi interrompido é salvo, e é feito um direcionamento para a função
responsável pela “INT1’:
Início do código 26 bits padrão
75
Figura 48: Função de Interrupção Fonte: autoria própria, 2010.
2° - Ao entrar na função, o sistema de detecção de interrupções é
desabilitado, pois neste instante o programa já se encontra na função desejada, a
fim de se fazer o processamento do sinal que continua sendo recebido.
3° - É feita uma contagem (delay) até 58,40ms, e só então inicia-se o
processo de decodificação da tecla pressionada.
4° - Depois de identificada a tecla pressionada, po de-se então atribuir o limite
de velocidade àquela tecla específica.
76
Figura 49: Atribuição dos limites de velocidade a partir referida tecla no controle remoto
Fonte: autoria própria, 2010.
Após identificado o limite de velocidade, deve-se informar ao condutor este
limite através do “display B”. Também é necessário que seja enviado o limite de
velocidade para o “microcontrolador A”, para que este possa comparar a velocidade
atual com o limite atual.
O limite de velocidade é codificado, a fim de ocupar um espaço pequeno na
memória e para facilitar o seu transporte.
77
Figura 50: Limite codificado para ser enviado ao micrcontrolador A Fonte: autoria própria, 2010.
Quanto aos 16 bits de código da tecla pressionada, deve-se armazenar um a
um, de maneira que possa ser formada uma palavra ou um byte. No caso deste
projeto, não se fez uso dos 16 bits e sim dos primeiros 8 bits, devido ao número
reduzido de teclas utilizadas.
Para decodificação destes oito bits se faz necessário identificar se o sinal
recebido em nível lógico alto se trata de 1 (um) ou 0 (zero) lógico, em nosso
programa, pois o PCM codifica o nível alto em relação de sua permanência neste
nível.
No controle remoto utilizado neste projeto, para um pulso que permaneça em
nível alto por 1,6ms, é etribuido nível lógico igual a 1. Para um pulso que permaneça
em nível alto por 0,8ms, é etribuido nível lógico igual a zero.
Os 16 bits de código são enviados a partir do LSB, e quando de trata de uma
tecla que representa um número, este código contém o valor em binário do
respectivo número.
40Km/h = 01b 60Km/h = 10b 80Km/h = 11b
78
Figura 51: Os 4 últimos bits da tecla de número 8 Fonte: autoria própria, 2010.
Repare que ao pressionar a tecla de número 8, o sinal recebido possui o valor
do número 8: “1000” (este número equivale a 8 no código binário)
Lembrando que é transmitido primeiramente o LSB dos 16 bits, logo, recebe-
se “0001”, e uma sequência de mais 12 bits que completam o código.
4.4 Comparação
Depois de estabelecido o limite de velocidade a tarefa é comparar em tempo
real a velocidade a qual se move o objeto, com o limite imposto naquele instante.
Neste momento é necessário trabalhar com os dois microprocessadores, pois
um envia informações de controle ao outro.
Como visto anteriormente, o microcontrolador “A” recebe do “B “ os limites
codificados. Estes, agora são decodificados para então ser feita a comparação da
velocidade atual como o limite atual.
0 0 0 1
79
Figura 52: Microcontrolador “A” decodificando limites recebidos do microcontrolador “B”
Fonte: autoria própria, 2010.
Figura 53: Velocidade sendo comparada com limite
Fonte: autoria própria, 2010.
80
Caso a velocidade seja excedida, o microcontrolador “A”, retorna para “B” a
informação de que foi excedida a velocidade. Em seguida, o microcontrolador “B”, já
com a informação de excesso de velocidade, emite os alertas ao condutor.
O microcontrolador “B” informa através do LCD de que a velocidade deve ser
diminuída, e o buzzer emite um alerta uma vez por segundo, enquanto a velocidade
permaneça acima do permitido.
Figura 54: Condutor com velocidade acima do permitido Fonte: autoria própria, 2010.
Se o condutor permanecer nesta situação, o sistema entra no modo de
aplicação de multa.
81
5 CONCLUSÃO
Um sistema de controle de velocidade mais eficiente trará uma diminuição de
óbitos nas estradas e rodovias. Acreditamos que este trabalho possui potencial para
trazer este benefício à sociedade.
. Contudo, o sistema de controle como um todo, necessita de uma série de
adaptações legais e técnicas para sua implementação. Necessita também de um
período de adaptação por parte da sociedade, onde, uma implementação em
pequenos trechos de rodovias, com um aumento programado, seria a melhor
maneira de iniciar este tipo de controle.
Neste trabalho apresentamos uma idéia de como seria o controle de
velocidade, um modelo global com várias sugestões. Citamos as várias etapas e
técnicas necessárias, os programas e os componentes. Mas não nos detivemos
somente ao modelo global e projetamos o equipamento que virá embarcado no
veículo, responsável pela fiscalização. Ao concluir a etapa de implementação deste
equipamento, após todo processo de concepção, e simulação, ratificamos
plenamente a viabilidade deste projeto.
As etapas de programação e simulação foram decisivas para o sucesso desta
empreitada. Porém, enfrentamos problemas nesta área. Tivemos que utilizar um
segundo software para apoiar o principal. Uma mudança no hardware e software
gravadores trará uma diminuição no tempo de programação, consequentemente
uma diminuição na mão-de-obra desta área.
O programa Keil, distribuído gratuitamente, também trouxe um incômodo na
parte da programação. Este programa em sua versão livre permite que sejam feitas
simulações utilizando um código com um tamanho máximo de 2 KB. Medidas
paliativas foram tomadas, porém, a substituição por outro software, talvez até em
outro sistema operacional como LINUX, seria mais interessante para o projeto.
Salientamos que estas mudanças não foram feitas durante o andamento do
projeto, pois o prazo de entrega foi priorizado. Os problemas citados acima surgiram
em uma etapa em que correções valiam mais a pena do que fazer grandes
modificações no projeto.
Um grande ganho para o projeto foi a montagem do mesmo em protoboard.
No início do projeto foi utilizada somente a placa de desenvolvimento GGDL -3300,
82
porém, com o avanço do projeto, tornou-se inviável os testes e simulações já que
era necessário fazê-las com dois microcontroladores e dois displays.
O resultado geral alcançado neste trabalho foi muito satisfatório, tanto na
parte de programação quanto na implementação, os componentes utilizados se
mostraram totalmente capazes de desempenhar as tarefas para as quais foram
escolhidos.
O receptor de GPS possui uma sensibilidade e uma precisão muito
satisfatória, além de possuir um custo muito acessível. O AT89S52 possui uma
versatilidade muito grande, o que possibilitou a implementação de idéias que foram
surgindo ao longo do projeto.
Estes fatores foram estimulantes no fechamento deste projeto, trazendo
ânimo e coragem para seguir até implementação e visualização dos últimos
resultados.
83
REFERÊNCIAS
DATASHEET, AT89S52 - 8-bit Microcontroller with 8K Bytes in System Programmable Flash. © Atmel Corporation 2001 [5] [10] [11] [12] [13] DATASHEET, SkyNav SKM53 Series - Ultra High Sensitivity and Low Power. The Smart Antenna GPS Module. ©Copyright 2008 Skylab M&C Co., Ltd, All Right Reserved [6] DATASHEET, LCD MODULE AMC 1602 . Oriented Display, Specifications for LCD Module. Modify the full specification, 2005.3. [x] DATASHEET, IR Receiver Modules for Remote Control Systems - HS0038A2 Vishay Semiconductor GmbH, P.O.B. 3535, D-74025 Heilbronn, Germany, Rev. 1.0, 08-Feb-08 [14] DATASHEET, Dual EIA-232 Drivers/Receivers - MAX 232 © Copyright 2004, Texas Instruments Incorporated FÓRUM DE ENTIDADES NACIONAIS DE DIREITOS HUMANOS. (2007). http://www.direitos.org.br/index.php?option=com_content&task=view&id=2639&Itemid=2 Acesso: 15 de setembro de 2010. [2] KRAUS JR.,Werner. Apostila 8051 Hari . Departamento de Automação e Sistemas - Universidade Federal de Santa Catarina. 2010. Disponível em: http://www.das.ufsc.br/~werner/eel7030/8051/Apostila8051Hari.pdf Acesso: 15 de outubro de 2010. LAIONE, Fábio. Computação Embarcada. Material - Didático Universidade Federal da Grande Dourados, Faculdade de Ciências Exatas e Tecnologia. Disponível em: http://www.do.ufgd.edu.br/fabioiaione/CE/index_CE.html Acesso: 23 de setembro de 2010. [ ] MAZIDI, Muhammad Ali; MAZIDI, Janice Gillispie; MCKINLAY. The 8051 microcontroller and embedded systems: using Assembly and C. Upper Saddle River [Estados Unidos]: Pearson Prentice Hall, 2006.
84
NICOLOSI, Denys E. C. Microcontrolador 8051 com linguagem C : Prático e Didático. São Paulo, SP, Érica, 2005. ______. Laboratório de Microcontrolador Família 8051 . São Paulo, SP, Érica, 2005. ______. Microcontrolador 8051 Detalhado . São Paulo, SP, Érica, 2000. PORTAL DO TRÂNSITO. (2009). Portal especializado em assuntos de trânsito. Disponível em: http://www.portaldotransito.com.br/noticias/brasil-e-quinto-pais-do-mundo-em-mortes-por-acidentes-de-transito.html Acesso: 20 de agosto de 2009. [1] SÁ, Maurício Cardoso de. Programação C para Microcontroladores 8051 . São Paulo, SP: Érica, 2005. [7] SANTOS, Marcelo Carvalho dos. Padrão de Formato de Dados NMEA . Material Didático. 2010. Disponível em: http://www.mundogeo.com.br/revistas-interna.php?id_noticia=7926 Acesso: 25 de outubro de 2010. [16] SCOLARI, Diogo. Identificador de Pontos Usando GPS. Trabalho acadêmico, Pontifícia Universidade Católica do Rio Grande do Sul, Porto Alegre, 2004. SWAN, Tom. Tecle & Aprenda C . São Paulo : Berkeley, 1994.
85
APÊNDICE A – Código do Microcontrolador A
/////////////////////////////////////////////////////// //////////////////////////// BIBLIOTECAS ///////////// #include<REGX52.H> #include<intrins.h> #include<stdio.h> #include<stdlib.h> #include<math.h> //////////////////////////////////////////////////////////// /////////////////////////// ATRIBUIÇÕES A PINOS FÍSICOS //// //////////////////////////////////////////////////////////// #define limite_0 P1_0 #define limite_1 P1_1 #define v_acima P1_2 #define led_multa P1_3 #define buzzer P2_3 #define LCD_data P0 #define LCD_rs P2_7 #define LCD_rw P2_6 #define LCD_en P2_5 ////////////////////////////////////////////////////////////////////////////// //////////////////////////// VARIÁVEIS ///////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// unsigned char NMEA[60]; unsigned char vet[6],vet_v[4],limite = 0,conta_virgula = 0, n1=0,n2=0,n3=0,i=0,a=0,j=0,n=0, //conta_led =0; unsigned int v_int=0,v_int1; //índices double d1,d2,d3,v_km; /////////////////////////////////////////////////////////////// ///////////////////////////// FUNÇÕES ///////////////////////// ////////////////////////////////////////////////////////////// void liga_LCD() // tempo para LCD começar a processar informações unsigned int i1; For (i1=0;i1<8500; i1++); void delay_LCD() // tempo para cada operação no LCD unsigned char i,j; for(i=0;i<40;i++) for(j=0;j<2;j++); void LCD_instruction(unsigned char var) //função que passa //as instruções para o LCD LCD_data = var; LCD_rs = 0; LCD_rw = 0; LCD_en = 1; _nop_(); _nop_();
86
LCD_en = 0; delay_LCD(); void LCD_senddata(unsigned char var) LCD_data = var; LCD_rs = 1; LCD_rw = 0; LCD_en = 1;//habilita buffer de recepção do LCD _nop_(); _nop_(); LCD_en = 0;//desabilita buffer de recepção do LCD delay_LCD(); void LCD_sendstring(unsigned char *var)//função que passa //caracter por caracter para a função "LCD_senddata" while(*var) LCD_senddata(*var++); delay_LCD(); void delay_inicio()///// 1 ciclo de máquina = 12 cloks. //Período para F = 11.0592, 9.0422 * 10 e-8. 1 ciclo de máquina = 1. 085 us. unsigned int i,j; for (i=0;i<500; i++) for (j=0;j<922; j++);//1 ms unsigned char RX_SERIAL(void) //recebe char da porta serial unsigned char c; while(!RI); RI =0; c = SBUF; return SBUF; void main(void)///função Principal
SCON = 0X50; // 01010010 - SCON: modo 1 - *N1, 8 bits, REN = 1, recepção habilitada TMOD = 0X20; ////TMOD: timer 1, modo 2, 8 bits reload, SMOD=0 TH1 = 0xFD; ///TH1: valor de carga para BAUD_RATE de 9600 bps com cristal de 11.0592 TR1 = 1;////habilita timer 1 led_multa = 1;
//////////////Intruções para LCD///////////////////////////////////////////// liga_LCD(); LCD_instruction(0x38); LCD_instruction(0x38); LCD_instruction(0x0C); LCD_instruction(0x01); LCD_instruction(0x06); LCD_instruction(0x07);
/////////////////////////Inicializando/////////////////////////////////// LCD_instruction(0x80); LCD_sendstring(" TCC ");
87
LCD_instruction(0xC0); LCD_sendstring(" RODRIGO LEMOS "); delay_inicio(); delay_inicio();
///////////// Mensagem enquanto sentença GPRMC não é válida LCD_instruction(0x80); LCD_sendstring(" INICIALIZANDO "); LCD_instruction(0xC0); LCD_sendstring(" GPS "); delay_inicio(); ////////////////////////////////////////////////////////////////////////////// ///////////////////LOOP de leitura da serial e escrita no LCD////////////////////// for(;;) TR1 = 1;////habilita timer 1 RI = 0;// zera flag de recebimento da serial buzzer = 1;// desliga buzzer conta_virgula = 0; //zera contador i=0; NMEA [i] = RX_SERIAL();//recebe um CHAR if (NMEA [i] == 'R')// Verifica se o CHAR recebido é um "R", //letra que só se encontra na sentença que será utilizada, //logo, identifico a sentença while (i < 60)// Preenche um vetor de 60 posições. //Capturo a sentença GPRMC inteira. i++; NMEA [i] = RX_SERIAL(); delay_LCD();
if (NMEA [15] == 'A')//Testa a validade da sentença
///////RECEBE DO uC 1 LIMITES DE VELOCIDADE ///////////
if (limite_0 == 0 && limite_1 == 0) limite = 0;
if (limite_0 == 1 && limite_1 == 0) limite = 40;
if (limite_0 == 0 && limite_1 == 1) limite = 60;
if (limite_0 == 1 && limite_1 == 0) limite = 80; for (j=0;j < 50; j++)
88
if (NMEA [j] == ',')// primeira virgula conta_virgula ++; if(conta_virgula == 7)//As informações de velocidade
//encontram-se sempre nesta sentença e após a sétima vírgula
a = j + 1 ;// variável "a" possui a posição da sétima vírgula + um, // onde tenho o primeiro dígito de velocidade n = 0; while (NMEA [a]!= ',')// Enche buffer "vet[]" com os dados da velocidade, //enquanto não encontra a próxima vírgula
vet[n] = NMEA[a]; n++; a++;
/// IDENTIFICA QUANTAS CASAS ANTES DO PONTO QUE SEPARA O DECIMAL ///////
if (vet[1] == '.')// se for velocidade x.xx ,//A velocidade em Knots neste caso,
// possui 1 dígito antes do decimal //mas quando convertida para Km/h, chega a dois dígitos (9.99Knots * 1,85 = //18,48), //logo, divido a conversão para char em //dois laços diferentes, um para x.xx Km/h e outro para xx.xx Km/h
n1 = (unsigned char)(vet[0]- 0x30); d1 = (double)((vet[2]- 0x30) / 10); v_km = (double) (1.85 * (n1 + d1)); // COMPARA VELOCIDADE ATUAL COM LIMITE///////////////////////
if ((v_km > limite)&&(limite != 0))////TEM QUE SER DIFERENTE DE ZERO TAMBÉM, //POIS QUANDO NÃO TENHO LIMITE, ELE É ZERO.
conta_led = conta_led +1;//conta 1 segundo, já que passa por aqui a cada segundo //devido atualização do GPS if(conta_led == 6)//conta 5 segundos, no sexto, aciona o procedimento de multa e
//zera contador
led_multa = 0;//ACENDE LED conta_led = 0; buzzer = 0;// liga buzzer, ALERTA SONORO DE QUE ESTÁ ACIMA DA //VELOCIDADE
v_acima = 0;// acende led indicando que veículo está acima da velocidade // //permitida
if (v_km < limite)// a qualquer instante que a velocidade se enquadra dentro do limite, o //contador é zerado
led_multa = 1;//apaga LED da multa conta_led = 0; v_acima = 1;//APAGA LED
89
////PROCEDIMENTO PARA TRANSFORMAR A VELOCIDADE EM CARACTER E IMPRIMIR NO LCD///////////////////////// if (v_km < 10) v_int = (int)(v_km);// Transforma em inteiro, usa só a parte inteira do double
vet_v[0] = (unsigned char)(v_int + 0x30);//transforma em char(ASCII) a parte inteira vet_v[1] = '.';/// Para este "if", como v_km é menor que 10, sempre tem um "."
//na segunda posição do vetor v_int = (int)((v_km - v_int) * 10);//pega a v_km(em double), diminui do v_int
//e multiplica por dez. Encontra o decimal do v_km. vet_v[2] = (unsigned char)(v_int + 0x30);//Transforma o segundo dígito em //char(ASCII)
//////// Escreve no LCD /////////////// LCD_instruction(0x80); LCD_sendstring("VELOCIDADE ATUAL"); LCD_instruction(0xC0); LCD_sendstring(" "); LCD_senddata(vet_v[0]); LCD_senddata(vet_v[1]); LCD_senddata(vet_v[2]); LCD_sendstring(" Km/h "); if (v_km >= 10 && v_km < 20) v_int = (int)(v_km / 10);//divide por dez e pega o inteiro vet_v[0] = (unsigned char)(v_int + 0x30);
v_int = (int)((v_km ) - (v_int * 10));// Pega o segundo dígito //do valor //inteiro
vet_v[1] = (unsigned char)(v_int + 0x30);// Transforma o //segundo //dígito em char(ASCII) vet_v[2] = '.';/// Para este "if", como v_km é maior que 10, //sempre //tem um "." na // terceira posição do vetor v_int = (int)(v_km);//Pega a parte inteirta do double v_int = (int)((v_km - v_int) * 10);//pega a v_km(em double), //diminui do v_int e multiplica por dez. Encontra o decimal do v_km. vet_v[3] = (unsigned char)(v_int + 0x30); /////////////////////////////////////// Escreve no LCD /////////////// LCD_instruction(0x80); LCD_sendstring("VELOCIDADE ATUAL"); LCD_instruction(0xC0); LCD_sendstring(" "); LCD_senddata(vet_v[0]); LCD_senddata(vet_v[1]); LCD_senddata(vet_v[2]); LCD_senddata(vet_v[3]); LCD_sendstring(" Km/h "); /////////////////////////////////////////////////////////////////////////
if (vet[2] == '.') ///////// se for velocidade xx.xx /////// n1 = (unsigned char)((vet[0]- 0x30) * 10);// Muda de Char para //inteiro n2 = (unsigned char)(vet[1]- 0x30);// Muda de Char para inteiro v_int = (int) (n1 + n2);//Parte inteira da velocidade, ainda em //knots
90
d1 = (double)((vet[3]- 0x30) / 10);// Pega decimal da velocidade v_km = (double) (1.85 * (v_int + d1));// Transforma para Km/h /////// COMPARA VELOCIDADE ATUAL COM LIMITE////////
if ((v_km > limite)&&(limite != 0))////TEM QUE SER DIFERENTE DE ZERO TAMBÉM, //POIS QUANDO NÃO TENHO LIMITE, ELE É ZERO.
conta_led = conta_led +1;//conta 1 segundo, já que passa por aqui a //cada //segundo devido atualização do GPS
if(conta_led == 6)//conta 5 segundos, no sexto, aciona o procedimento //de //multa e zera contador
led_multa = 0;///ACENDE LED conta_led = 0; v_acima = 0;// acende led buzzer = 0;// liga buzzer if (v_km < limite)// a qualquer instante que a velocidade se enquadra //dentro do //limite, o contador é zerado led_multa = 1;//apaga LED da multa conta_led = 0; v_acima = 1;//APAGA LED //PROCEDIMENTO PARA TRANSFORMAR A VELOCIDADE EM CARACTER E IMPRIMIR NO //LCD///////////////////////// if ((v_km >= 10) && (v_km < 100)) v_int = (int)(v_km / 10);//divide por dez e pega o inteiro vet_v[0] = (unsigned char)(v_int + 0x30); v_int = (int)((v_km ) - (v_int * 10));// Pega o segundo dígito do inteiro
vet_v[1] = (unsigned char)(v_int + 0x30);// Transforma o //segundo //dígito em //char(ASCII)
vet_v[2] = '.';/// Para este "if", como v_km é maior que 10, sempre tem //um "." //na terceira posição do vetor
v_int = (int)(v_km);//Pega a parte inteirta do double v_int = (int)((v_km - v_int) * 10);//pega a v_km(em double), //diminui do v_int e multiplica por dez. Encontra o decimal do v_km. vet_v[3] = (unsigned char)(v_int + 0x30); //////////////////////////////////// Escreve no LCD /////////////// LCD_instruction(0x80); LCD_sendstring("VELOCIDADE ATUAL"); LCD_instruction(0xC0); LCD_sendstring(" "); LCD_senddata(vet_v[0]); LCD_senddata(vet_v[1]); LCD_senddata(vet_v[2]); LCD_senddata(vet_v[3]); LCD_sendstring(" Km/h "); if ((v_km >= 100) && (v_km < 200))
91
v_int = (int)(v_km / 100);//divide por cem e pega o inteiro vet_v[0] = (unsigned char)(v_int + 0x30); v_int1 = (int)((v_km ) - (v_int * 100));// Pega o segundo dígito do //inteiro v_int = (int)(v_int1 / 10);
vet_v[1] = (unsigned char)(v_int + 0x30);// Transforma o segundo dígito em //char(ASCII)
v_int = (int)((v_int1 ) - (v_int * 10));// Pega o terceiro dígito do inteiro vet_v[2] = (unsigned char)(v_int + 0x30); vet_v[3] = '.';/// Para este "if", como v_km é maior ou igual a 100, //sempre tem um "." na quarta posição do vetor v_int = (int)(v_km);//Pega a parte inteirta da velocidade v_int = (int)((v_km - v_int) * 10);//pega a v_km(em double), diminui do //v_int e multiplica por dez. Encontra o decimal do v_km. vet_v[4] = (unsigned char)(v_int + 0x30); //////////////////////////////////////// Escreve no LCD /////////////// LCD_instruction(0x80); LCD_sendstring("VELOCIDADE ATUAL"); LCD_instruction(0xC0); LCD_sendstring(" "); LCD_senddata(vet_v[0]); LCD_senddata(vet_v[1]); LCD_senddata(vet_v[2]); LCD_senddata(vet_v[3]); LCD_senddata(vet_v[4]); LCD_sendstring(" Km/h "); ///////////////////////////////////////////////////////////////////////////////// if (vet[3] == '.') //////// se for velocidade xxx.xx //////////////////////////// n1 = (unsigned char)((vet[0]- 0x30) * 100);// Muda de Char para inteiro n2 = (unsigned char)(vet[1]- 0x30 * 10);// Muda de Char para inteiro n3 = (unsigned char)(vet[2]- 0x30);// Muda de Char para inteiro
v_int = (int) (n1 + n2 + n3);//Parte inteira da velocidade, ainda em knots d1 = (double)((vet[4]- 0x30) / 10);// Pega decimal da velocidade v_km = (double) (1.85 * (v_int + d1));// Transforma para Km/h
/////////////////////////////// COMPARA VELOCIDADE ATUAL COM LIMITE////////////
if ((v_km > limite)&&(limite != 0))////TEM QUE SER DIFERENTE DE ZERO TAMBÉM, //POIS QUANDO NÃO TENHO LIMITE, ELE É ZERO.
conta_led = conta_led +1;//conta 1 segundo, já que passa por aqui a cada //segundo devido atualização do GPS
if(conta_led == 6)//conta 5 segundos, no sexto, aciona o procedimento de //multa e zera contador
led_multa = 0; conta_led = 0; v_acima = 1;//APAGA LED buzzer = 0;// liga buzzer, ALERTA SONORO DE QUE ESTÁ ACIMA DA VELOCIDADE
v_acima = 0;// acende led indicando que veículo está acima da velocidade permitida
92
if (v_km < limite)// a qualquer instante que a velocidade se enquadra dentro do limite, o //contador é zerado
led_multa = 1;//apaga LED da multa conta_led = 0; //PROCEDIMENTO PARA TRANSFORMAR A VELOCIDADE EM CARACTER E IMPRIMIR NO LCD///////////////////////// if ((v_km >= 100) && (v_km < 1000)) v_int = (int)(v_km / 100);//divide por cem e pega o inteiro
vet_v[0] = (unsigned char)(v_int + 0x30); v_int1 = (int)((v_km ) - (v_int * 100));// Pega o segundo dígito do inteiro
v_int = (int)(v_int1 / 10); vet_v[1] = (unsigned char)(v_int + 0x30);// Transforma o segundo dígito em char(ASCII)
v_int = (int)((v_int1 ) - (v_int * 10));// Pega o terceiro dígito do inteiro vet_v[2] = (unsigned char)(v_int + 0x30); vet_v[3] = '.';/// Para este "if", como v_km é maior ou igual a 100, sempre tem um "." na quarta
//posição do vetor v_int = (int)(v_km);//Pega a parte inteirta da velocidade v_int = (int)((v_km - v_int) * 10);//pega a v_km(em double), diminui do v_int e multiplica por
//dez. Encontra o decimal do v_km. vet_v[4] = (unsigned char)(v_int + 0x30);
//////// Escreve no LCD ///////////////
LCD_instruction(0x80); LCD_sendstring("VELOCIDADE ATUAL"); LCD_instruction(0xC0); LCD_sendstring(" "); LCD_senddata(vet_v[0]); LCD_senddata(vet_v[1]); LCD_senddata(vet_v[2]); LCD_senddata(vet_v[3]); LCD_senddata(vet_v[4]); LCD_sendstring(" Km/h ");
///////////////////////////////////////////////////////////////////////////////////////////////////////// j = 0;//sai do último loop NMEA [15] = 'Z'; // muda a validade da sentença para forçar saída
93
APÊNDICE B – Código do Microcontrolador B
#include<REGX52.H> #include<intrins.h> #include<stdio.h> #include<stdlib.h> #include<math.h> /////////////////////////////////////////////////////////////////////////////////// /////////////////////////// ATRIBUIÇÕES A PINOS FÍSICOS /////////////////////////// /////////////////////////////////////////////////////////////////////////////////// #define led_limite0 P1_0 #define led_limite1 P1_1 #define v_acima P1_2 #define led_multa P1_3 #define ID_0 P1_4 #define ID_1 P1_5 #define ID_2 P1_6 #define ID_3 P1_7 #define pino_int P3_3 #define buzzer P2_3 #define LCD_data P0 #define LCD_rs P2_7 #define LCD_rw P2_6 #define LCD_en P2_5 ////////////////////////////////////////////////////////////////////////////// //////////////////////////// VARIÁVEIS ///////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// unsigned char limite = 0; unsigned int i=0,a=0,j=0; //índices void liga_LCD() // tempo para LCD começar a processar informações unsigned int i; for (i=0;i<8500; i++); void delay_LCD() // tempo para cada operação no LCD unsigned char i,j; for(i=0;i<40;i++) for(j=0;j<2;j++); void LCD_instruction(unsigned char var)//função que passa as instruções para //o LCD LCD_data = var; LCD_rs = 0; LCD_rw = 0; LCD_en = 1; _nop_(); _nop_(); LCD_en = 0; delay_LCD();
94
void LCD_senddata(unsigned char var) LCD_data = var; LCD_rs = 1; LCD_rw = 0; LCD_en = 1; //habilita buffer de recepção do LCD _nop_(); _nop_(); LCD_en = 0; //desabilita buffer de recepção do LCD delay_LCD(); void LCD_sendstring(unsigned char *var)//função que passa caracter por caracter para a função "LCD_senddata" while(*var) LCD_senddata(*var++); delay_LCD(); void delay_inicio()///// 1 ciclo de máquina = 12 cloks. Período para F = //11.0592, 9.0422 * 10 e-8. 1 //ciclo de máquina = 1. 085 us. unsigned int i,j; for (i=0;i<500; i++) for (j=0;j<922; j++);//1 ms ///////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////INTERRUPÇÂO/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////// void infrared_int(void) interrupt 2 /// INTERRUPÇÃO PELO CONTROLE REMOTO, INT1 unsigned char valor = 0, estado = 0, conta_bit; EA = 0;// desabilita para não acionar novamente, //já que o sinal é uma onda quadrada
//Espera 58,48 ms, espera passar todos bits "padrão", //para começar a trabalhar com os bits variáveis de código, //e então identificar a tecla, este tempo acaba no meio do //primriro nível baixo ////
TMOD = 0x01;// timer 0, modo 1 com 16 bits para poder contar //até 53881 = 58,40 ms TL0 = 0x86; TH0 = 0x2D; TR0 = 1;//// Liga timer zero while (TF0 == 0); TR0 = 0;///// desliga timer 0
TF0 = 0;//// Flag de estouro de contagem, deve ser zerado por //software, caso não //esteja //acionada interrupção por timer.
conta_bit = 0;//conta os bits recebidos após os 58.48 ms, //queremos receber 8 bits, já //o suficiente para decodificarmos o PCM while (conta_bit < 7)////recebe 7 bits rotacionando, depois do //enlace receberá o //último sem rotacionar if (pino_int == 1)///// Espera até encontrar nível 1 =~ 5V
95
////////////////Espera 882us, tempo para identificar se é 1 ou zero. TR0 = 0; TL0 = 0xE6; TH0 = 0xFC; TR0 = 1; while (TF0 == 0); TR0 = 0; TF0 = 0; ////////////////////////////////////////////////////////////////////////////// estado = pino_int;///estado recebe o valor //instantâneo do pino de //interrupção, zero ou um if ( estado == 0) valor = valor + estado ; valor = valor << 1 ; if ( estado == 1) valor = valor + estado ; valor = valor << 1 ; //////////////// Se estado é igual a 1, espera mais 1 ms passar todo nível. TR0 = 0; TL0 = 0x78; TH0 = 0xFC; TR0 = 1; while (TF0 == 0); TR0 = 0; TF0 = 0; /////////////////////////////////////////////////////////////////////////// conta_bit = conta_bit + 1; if (conta_bit == 7)// O último bit será recebido sem rotacionar, //senão, perco o //primeiro bit recebido estado = pino_int; valor = valor + estado; if /*(valor == 0x04 )*/(valor == 0x20)//botão 4, 40Km/h buzzer = 0; limite = 40;
if /*(valor == 0x06 )*/(valor == 0x60)//botão 6, 60Km/h buzzer = 0; limite = 60;
if /*(valor == 0x08 )*/(valor == 0x10)//botão 8, 80Km/h
96
buzzer = 0; limite = 80;
if (valor == 0x18)//botão desliga, sai de uma área //controlada buzzer = 0; limite = 0;
delay_LCD(); delay_LCD(); delay_LCD(); delay_LCD(); EA = 1;// ativa interrupções novamente para sair da //função pronto para ser //interrompido novamente buzzer = 1;//desliga buzzer void main(void)///função Principal led_multa = 1; buzzer = 1; IE = 0x84;// habilita int1 TCON = 0x04;// 00000100 habilita int1 por borda de descida IP = 0x04;// 00000100 coloca a int1 com prioridade máxima //////////////Intruções para LCD///////////////////////////////////////////// liga_LCD(); LCD_instruction(0x38); LCD_instruction(0x38); LCD_instruction(0x0C); LCD_instruction(0x01); LCD_instruction(0x06); LCD_instruction(0x07); //////////////////////////Inicializando/////////////////////////////////// LCD_instruction(0x80); LCD_sendstring(" TCC "); LCD_instruction(0xC0); LCD_sendstring(" RODRIGO LEMOS "); delay_inicio(); delay_inicio(); ////////////////////////////////////////////////////////////////////////////// ///////////////////LOOP de leitura da serial e escrita no LCD////////////////////// for(;;) if (limite == 0) led_limite0 = 0;////meu código //para este //limite led_limite1 = 0; LCD_instruction(0x80); LCD_sendstring("SEM FISCALIZACAO"); LCD_instruction(0xC0); LCD_sendstring("PELO //SISTEMA GPS"); if (limite == 40)
97
led_limite0 = 1;////meu código //para este //limite led_limite1 = 0; /////////////////////////Alerta visual de que o limite de velocidade mudou
LCD_instruction(0x80); LCD_sendstring("VELOCIDADE "); LCD_instruction(0xC0); LCD_sendstring("LIMITE 40 //Km/h");
if (limite == 60) led_limite0 = 0;////meu código //para este //limite led_limite1 = 1; /////////////////////////Alerta visual de que o limite de velocidade mudou LCD_instruction(0x80); LCD_sendstring("VELOCIDADE "); LCD_instruction(0xC0); LCD_sendstring("LIMITE 60 //Km/h");
if (limite == 80) led_limite0 = 1;////meu código //para este //limite led_limite1 = 1; /////////////////////////Alerta visual de que o limite de velocidade mudou LCD_instruction(0x80); LCD_sendstring("VELOCIDADE "); LCD_instruction(0xC0); LCD_sendstring("LIMITE 80 //Km/h"); if (v_acima == 0)/////RECEBE //INDICAÇÃO //DO uC A DE QUE FOI EXCEDIDO O LIMITE LCD_instruction(0x80); LCD_sendstring(" DIMINUA //SUA "); LCD_instruction(0xC0); LCD_sendstring(" VELOCIDADE "); if(led_multa == 0) buzzer = 0; /////bip longo ID_0 = 0;//// Envia ID do veículo ID_1 = 1; ID_2 = 0; ID_3 = 1; delay_inicio(); ID_0 = 1; ID_1 = 1; ID_2 = 1; ID_3 = 1; buzzer = 1;
98
99
ANEXO A – Esquema elétrico da Placa de Desenvolvime nto
100
ANEXO B – Tabela ASCII Padrão
Disponível em: http://www.asciitable.com/ Acesso: 20 de novembro 2010.
101
ANEXO C – Tabela ASCII Estendida
Disponível em: http://www.asciitable.com/ Acesso: 20 de novembro 2010.
102
ANEXO D – Conjunto de instruções do módulo LCD
INSTRUÇÃO RS R/W B
7 B6
B5
B4
B3
B2
B1
B0
DESCRIÇÃO e tempo de execução (uS)
t
Limpa Display 0 0 0 0 0 0 0 0 0 1 -Limpa todo o display e retorna o cursor para a primeira posição da primeira linha
1.6 mS
Home p/ Cursor
0 0 0 0 0 0 0 0 1 * -Retorna o cursor para a 1. coluna da 1. Linha -Retorna a mensagem previamente deslocada a sua posição original
1.6 mS
Fixa o modo de funcionamento
0 0 0 0 0 0 0 1 X S -Estabelece o sentido de deslocamento do cursor (X=0 p/ esquerda, X=1 p/ direita) -Estabelece se a mensagem deve ou não ser deslocada com a entrada de um novo caracter (S=1 SIM, X=1 p/ direita) -Esta instrução tem efeito somente durante a leitura e escrita de dados.
40 uS
Controle do Display
0 0 0 0 0 0 1 D C B -Liga (D=1) ou desliga display (D=0) -Liga(C=1) ou desliga cursor (C=0) -Cursor Piscante(B=1) se C=1
40 uS
Desloca cursor ou mensagem
0 0 0 0 0 1 C R * * -Desloca o cursor (C=0) ou a mensagem (C=1) para a Direita se (R=1) ou esquerda se (R=0) - Desloca sem alterar o conteúdo da DDRAM
40 uS
Fixa o modo de utilização do módulo LCD
0 0 0 0 1 Y N F * * -Comunicação do módulo com 8 bits(Y=1) ou 4 bits(Y=0) -Número de linhas: 1 (N=0) e 2 ou mais (N=1) -Matriz do caracter: 5x7(F=0) ou 5x10(F=1) - Esta instrução deve ser ativada durante a inicialização
40 uS
Posiciona no endereço da CGRAM
0 0 0 1 Endereço da CGRAM
-Fixa o enderço na CGRAM para posteriormente enviar ou ler o dado (byte)
40 uS
Posiciona no endereço da DDRAM
0 0 1 Endereço da DDRAM
-Fixa o enderço na DDRAM para posteriormente enviar ou ler o dado (byte)
40 uS
Leitura do Flag Busy
0 1 BF
AC -Lê o conteúdo do contador de endereços (AC) e o BF. O BF (bit 7) indica se a última operação foi concluída (BF=0 concluída) ou está em execução (BF=1).
0
Escreve dado na CGRAM / DDRAM
0 1 Dado a ser gravado no LCD
- Grava o byte presente nos pinos de dados no local apontado pelo contador de endereços (posição do cursor)
40 uS
Lê Dado na CGRAM / DDRAM
1 1 Dado lido do módulo - Lê o byte no local apontado pelo contador de endereços (posição do cursor)
40 uS
Fonte: Adaptado do DATASHEET Display LCD AMC 1602 A
