Embed Size (px)
Citation preview
CENTRO UNIVERSITÁRIO ADVENTISTA DE SÃO PAULO
ENGENHEIRO COELHO
WAGNER ROCHA BARROS
SISTEMA DE AUTOMAÇÃO VEICULAR COM ARDUINO E ANDROID
ENGENHEIRO COELHO
2012
WAGNER ROCHA BARROS
SISTEMA DE AUTOMAÇÃO VEICULAR COM ARDUINO E ANDROID
Trabalho de Conclusão de Curso do Centro
Universitário Adventista de São Paulo do curso
de Tecnólogo em Sistemas para Internet, sob
orientação do Prof. Me.Thales de Társis Cezare.
ENGENHEIRO COELHO
2012
Trabalho de Conclusão de Curso do Centro Universitário Adventista de São Paulo, do curso
de Tecnólogo em Sistemas para Internet apresentado e aprovado em 18 de Junho de 2012.
_________________________________________________
Prof. Me.Thales de Társis Cezare
_________________________________________________
Prof. Me. Peterson Peixoto dos Santos
_________________________________________________
Prof. Me. Mateus dos Santos
Dedico esse trabalho primeiramente a Deus que
me deu a capacitação e a força necessária,
agradeço também aos meus pais pelo incentivo
e amor. Dedico também aos meus professores
em especial ao professor Thales pelo apoio e
dedicação. Dedico ainda aos meus amigos por
me animarem e encorajarem na conclusão
desse trabalho
AGRADECIMENTOS
A Deus em primeiro lugar pelo dom da vida e por me conduzir sempre em caminhos
de paz mesmo nos momentos mais difíceis, nunca me abandonou cuidando dos
menores detalhes da minha existência .
Aos meus pais Francisco e Maria pela educação, cuidado e dedicação de me ensinar o
caminho da verdade. O enorme sacrifício pra poder me acompanha nesse momento
tão importante.
Ao Unasp Campus Engenheiro Coelho pela privilegio de aqui estudar, sou
extremamente agradecido pelo apoio e base para construção de um sonho.
A todo corpo docente pelo conhecimento passado nesses três anos de convivência
que vão marcar minha vida pra sempre. Em especial quero agradecer pelo carinho,
empenho e dedicação do meu orientador o professor Thales de Társis Cezare.
Aos meus amigos que sempre me encorajaram durante a jornada de projeto e
exclusão desse trabalho.
Nossa tecnologia passou a frente de nosso
entendimento, e a nossa inteligência
desenvolveu-se mais do que a nossa sabedoria.
Roger Revelle
RESUMO
Este trabalho descreve o projeto e implementação de uma plataforma de controle
construída em módulos, possibilitando ao usuário escolher quais funções do veiculo se
deseja automatizar utilizando assim hardwares Open Source onde os conceitos de
automação serão aplicados. O projeto propõe o controle de um veículo de passeio utilizando
um celular SmartPhone com sistema operacional Android, efetuando os controles
relacionados a partida do motor, abertura de portas e capô. A novidade dessa abordagem é
o uso de um servidor socket desenvolvido em linguagem de programação Java e o hardware
de controle dos atuadores Open Source. O sistema de gerenciamento dos atuadores foi
desenvolvido utilizando o microcontrolador Atmel 2560 e a linguagem de programação C
para a programação dos códigos possibilitando assim a automação das ações desejadas no
automóvel. A aplicação cliente utilizada no celular foi desenvolvida no ambiente de
programação Eclipse com framework Android. Utilizando a linguagem de programação Java
para codificação das classes. A comunicação entre o sistema de gerenciamento dos
atuadores do veículo, intermediado pelo servidor socket, e o sistema de controle do celular
SmartPhone a aplicação cliente foi utilizado a rede de acesso a internet de alta velocidade
3G e o protocolo TCP para troca de mensagens entre a aplicação cliente e o sistemas de
gerenciamento dos atuadores. Esta abordagem abre uma grande variedade e possibilidades
de utilização deste projeto para outras áreas da automação.
Este projeto torna possível o controle das principais funções de um veículo automotor de
passeio, possibilitando assim uma maior segurança e conforto ao usuário permitindo-o
desligar o veículo remotamente em caso de emergência.
Palavras Chave: Automação veicular; Android; Arduino.
ABSTRACT
This paper describes the design and implementation of a control platform built in modules,
enabling the user to choose which functions of the vehicle so if you want to automate using Open
Source hardware where automation concepts will be applied. The project proposes the control of a
passenger vehicle using a mobile Smartphone with Android operating system, making the controls
related to starting the engine, opening doors and hood. The novelty of this approach is the use of a
socket server developed in Java programming language and hardware control actuators Open
Source. The management system of the actuator was developed using the Atmel 2560
microcontroller and C programming language for programming codes thus enabling the automation
of desired actions in the car. The client application used in the cell was developed in the
programming environment Eclipse with Android framework. Using the Java programming language
for encoding classes. Communication between the management system of the vehicle actuators,
brokered by the socket server, and control system SmartPhone mobile client application was used to
access network high-speed 3G Internet and the TCP for exchanging messages between the client
application management systems and actuators. This approach opens a wide variety and possibilities
to use this project to other areas of automation.
This design makes it possible to control the main functions of a motor vehicle drive, allowing for
greater security and comfort to the user allowing you to remotely turn off the vehicle in an
emergency.
Keywords: Automation vehicle; Android; Arduino.
LISTA DE ILUSTRAÇÕES
Figura 1 - Partes técnicas do microcontrolador Arduino Mega 2560. .................................................21 Figura 2 - Ambiente de desenvolvimento Arduino 0022. ...................................................................24 Figura 3 - Arquitetura Android. .........................................................................................................27 Figura 4 - Plataforma de desenvolvimento Eclipse com plug-in Android. ...........................................28 Figura 5 - Arquitetura simplificada da plataforma eclipse. .................................................................29 Figura 6 - Emulador Andoid. ..............................................................................................................30 Figura 7 - Arduino Atmega 2560. .......................................................................................................32 Figura 8 - Diagrama de bloco do sistema proposto. ...........................................................................38 Figura 9 - Arquitetura conceitual do módulo de controle e automação. ............................................39 Figura 10 - Diagrama de classe Módulo Cliente. ................................................................................41 Figura 11 - Telas Emulador e Conexão com Servidor. .........................................................................42 Figura 12 - Layout módulo cliente. ....................................................................................................42 Figura 13 - Diagrama de classe modulo servidor. ...............................................................................43
LISTA DE ABREVIATURAS E SIGLAS
SiAV – Sistema de Automação Veicular
SWT – Standard Widget Toolkit
IDE – Ambiente Integrado de Desenvolvimento
PHP – Personal Home Page – linguagem interpretada livre
ABS – Anti Block System – Sistema anti bloqueio
ESP – Eletronic Stability Program – Programa eletrônico de estabilidade
INRIA – Intitut National de Recherche en Informatique et en Automatique – Instituto de
pesquisas em informática e automação
DARPA – Defense Advanced Research Projects Agency – Agência da defesa em projetos de
pesquisa avançada.
MCU – Movimento Circular Uniforme
ICSP – In Circuit Serial Programming
VIN – Vehicle Identification Number
FTDI – Future Technology Devices International
GND – Graduated Neutral Density Filter – Filtro Graduado de Densidade Neutra
RAM – Random Access Memory – Memória de acesso
EPROM - Erasable Programmable Only Memory – Memória programável apagável.
SUMÁRIO
1 INTRODUÇÃO ................................................................................................................................12
1.1 Fundamentos Tecnológicos ....................................................................................................13
1.2 Tecnologia Aplicada a Automação Veicular ............................................................................15
1.2.1 Aspectos Gerais das Tecnologias Aplicadas a Sistemas de Automação Veicular ..............15
1.2.2 Sistemas Inteligentes Veiculares ......................................................................................16
1.3 Sistema de Automação Veicular .............................................................................................18
1.3.1 Sistema de Apoio ao Motorista ........................................................................................19
1.3.2 Sistemas Veiculares Robóticos .........................................................................................19
1.4 Hardware Arduino e Seus Conceitos .......................................................................................20
1.4.1 Aspectos do Arduino ........................................................................................................20
1.4.2 Funcionamento do Arduino .............................................................................................21
1.4.3 Especificações técnicas do Arduino ..................................................................................22
1.5 Ambiente de Desenvolvimento e seus Conceitos ...................................................................23
1.5.1 Plataforma de desenvolvimento Arduino ........................................................................24
1.5.2 Plataforma de desenvolvimento Android ........................................................................26
1.5.2.1 Estrutura geral da plataforma ....................................................................................26
1.5.2.2 Arquitetura ................................................................................................................27
1.5.2.3 Bibliotecas .................................................................................................................27
1.5.3 Plataforma de desenvolvimento Eclipse ..........................................................................28
1.5.3.1 Arquitetura Eclipse ....................................................................................................29
1.5.3.2 Emulador Android ......................................................................................................30
1.6 Caracterização do Problema ...................................................................................................31
1.7 Projeto SiAV............................................................................................................................31
1.8 Motivação deste Trabalho ......................................................................................................32
1.9 Justificativa .............................................................................................................................33
2 OBJETIVOS .....................................................................................................................................35
2.1 Objetivos Gerais .....................................................................................................................35
2.2 Objetivos específicos ..............................................................................................................35
3 METODOLOGIA ..............................................................................................................................36
4 SISTEMA DE AUTOMAÇÃO VEICULAR COM ARDUINO E ANDROID - Desenvolvimento .................37
4.1 Arquitetura do Sistema...........................................................................................................37
4.1.1 Arquitetura na primeira fase do projeto SiAV ..................................................................37
4.1.2 Arquitetura na segunda fase do projeto SiAV ..................................................................38
4.2 Aspectos Gerais Desenvolvimento do Software de Controle ..................................................40
4.2.1 Módulo controlador cliente .............................................................................................40
4.2.1.1 Diagrama de classe do Módulo Cliente .......................................................................40
4.2.1.2 Layout do módulo cliente...........................................................................................41
4.2.2 Modulo controlador servidor ...........................................................................................42
4.2.2.1 Diagrama de classe do Modulo Servidor.....................................................................43
5 CONCLUSÃO ..................................................................................................................................44
5.1 Trabalhos futuros ...................................................................................................................44
6 REFERÊNCIAS .................................................................................................................................45
APÊNDICES .......................................................................................................................................49
12
1 INTRODUÇÃO
Atualmente, os sistemas autônomos são utilizados em diferentes áreas da tecnologia
e varias aplicações utilizam microcontrolador que cada vez mais são exigidos a atender as
crescentes evoluções e necessidades de desempenho, baixo custo, tempo de ciclo e
dispositivos cada vez menores. Um sistema autônomo pode ser caracterizado por sua
capacidade de execução das tarefas para as quais foi projetado, sem a interferência de
qualquer controle externo (Baltes J. e Lin Y. Lin, 1999).
O sistema embarcado vem ganhando espaço com o aumento da tecnologia e várias
aplicações vêm sendo desenvolvidas ao redor do mundo, os dispositivos móveis vem
ganhando destaque pela integração com os sistemas embarcados, essa nova integração traz
grandes avanços no desenvolvimento possibilitando assim a criação de sistemas integrados
cada vez mais inteligentes e possibilitando ao usuário interagir com ele.
Junto à evolução dos microcontrolador veio a miniaturização dos dispositivos móveis
que faz parte da quinta geração dos computadores, os chamados computadores invisíveis,
como exemplo, os Smartphones que são máquinas completas de propósito geral e que já
contam com sistemas operacionais baseados em softwares livres.
O advento dos sistemas operacionais de código livre trouxe grande flexibilidade no
desenvolvimento de sistemas, possibilitando a criação de software de qualidade atendendo
uma vertente importante no desenvolvimento de baixo custo, como exemplo: Linux e
Android. Simultaneamente surgiu também a ideia de criação de hardwares Open Source para
uma maior interação com o desenvolvimento de sistemas autômatos utilizando, por
exemplo, o microprocessador Atmega 2560 montado em uma plataforma Arduino.
Utilizando de técnicas cada vez mais elaboradas para o desenvolvimento de sistemas
e a grande complexidade dos atuais sistemas de automação veicular envolvendo dispositivos
mecânicos, eletrônicos e sistemas computacionais, estimulam a introdução de novas
metodologias de projeto. Um ponto importante é que as metodologias de desenvolvimento
exigem um nível de abstração alto para elaboração, verificação e validação do sistema
proposto.
Este trabalho descreve um sistema de controle e automação veicular baseado em
técnicas de arquitetura de software e hardware Open Source. Desta maneira foi definido um
fluxo de projeto que permite um alto nível de abstração para validação do sistema. O
13
sistema proposto é composto de um controlador (desenvolvido com hardware Open Source)
e diversos atuadores, interfaces, sensores e etc. Tendo como objetivo a construção da base
de controle do veículo. Para o projeto de automação veicular o sistema foi projetado e
implementado utilizando técnicas e tecnologias que estão ganhando cada vez mais
visibilidade internacional.
A implementação do sistema de controle e automação foi desenvolvida em etapas
diferentes durante sua elaboração que são descritas neste trabalho. Inicialmente, foi
projetado o sistema de controle e automação, utilizando os conceitos de microcontrolador
embarcado para o controle dos atuadores instalados no veículo. A segunda etapa consistiu
no desenvolvimento do ambiente de interação com o usuário, utilizando-se de um celular
SmartPhone com sistema operacional android.
1.1 Fundamentos Tecnológicos
Inicialmente, descreve-se um breve histórico dos sistemas de automação veicular,
enfatizando a evolução e a incorporação de sistemas automatizados. Também são
abordadas as principais tecnologias aplicadas a veículos de passeio a evolução dos sistemas
e os conceitos que revolucionaram a forma de dirigir um veículo possibilitando novos
patamares de segurança, conforto e economia.
As pesquisas em automação veicular abriram as portas para o surgimento de
sistemas que auxiliam o motorista na execução de tarefas pré-estabelecidas e no
gerenciamento de funções específicas ou gerais como: manter a velocidade do veículo,
manter a distância do veículo a sua frente, controle de funções do veículo ou até mesmo o
monitoramento da temperatura no interior do veículo.
Com o avanço das tecnologias relacionadas aos veículos automatizados, surgiram
novos paradigmas na área de sistemas veiculares robotizados. Estes sistemas ganham
espaço em aplicações industriais (e.g. carga e descarga) e, em aplicações urbanas
objetivando cada vez mais isentar as pessoas de executarem tarefas repetitivas e/ou
desgastantes.
Por outro lado, os sistemas de automação veicular objetivam o aumento de
segurança, pois com o desenvolvimento desses sistemas não haveria mais excesso de
velocidade, ultrapassagens perigosas, roubo de veículos poderiam ser minimizados com um
14
sistema automatizado de controle do veículo, desenvolvimento de sistemas de vigilância e
acionamento via satélite. Com o surgimento de novas tecnologias e o avanço das linguagens
de programação tornou possível o desenvolvimento de sistemas cada vez mais seguros e
confiáveis.
O ambiente de programação eclipse para o desenvolvimento de códigos na
linguagem de programação Java foi iniciado na IBM desenvolvendo a primeira versão do
produto e fazendo a doação deste para a comunidade Open Source. Possui forte orientação
ao desenvolvimento baseado em plug-ins. Possibilitando assim um amplo suporte ao
desenvolvedor com centenas de plug-ins que procuram atender as diferentes necessidades
dos programadores.
Utilizando a IDE Eclipse com plug-ins pode-se desenvolver não só em Java, mas
também em C, C++, PHP e Python.
Juntamente com o desenvolvimento dos sistemas veiculares automatizados o
surgimento de novas tecnologias de sistemas embarcados tem se mostrado necessário para
dar suporte as necessidades cada vez mais pujantes. A quantidade de eletrônica embarcada
nos veículos, atualmente, já está na casa de centenas no caso de veículos mais luxuosos.
Visando este crescimento as indústrias de desenvolvimento de sistemas eletrônicos
para aplicações veiculares estão investindo na pesquisa de novas metodologias para o
controle dos sistemas veiculares embarcados. Nessa dinâmica a computação reconfigurável
vem se mostrando uma tecnologia interessante. O projeto Arduino iniciou-se na cidade de
Ivrea, Itália, em 2005, com o intuito de interagir em projetos escolares de forma a ter um
orçamento menor que outros sistemas de prototipagem disponíveis naquela época. Seu
sucesso foi sinalizado com o recebimento de uma menção honrosa na categoria
Comunidades Digitais em 2006, pela Prix Ars Electronica, além da marca de mais de 50.000
placas vendidas até outubro de 2008.
Atualmente, o hardware é feito através de um microcontrolador Atmel AVR, que
pode ser estendido se necessário for para implementação do projeto. A flexibilidade e
reconfigurabilidade do hardware tem se mostrado competitiva em termos de custo do chip e
do seu ciclo de projeto.
Na seção seguinte são abordados os conceitos tecnológicos aplicados no
desenvolvimento do sistema de controle e automações de um veículo de passeio Estes
15
conceitos estão relacionadas com a aplicação de Sistemas Reconfiguráveis para o projeto de
Sistemas de Automação Veicular.
1.2 Tecnologia Aplicada a Automação Veicular
Dentro dos conceitos relacionados à automação veicular são descritas as tecnologias
aplicadas aos veículos de passeio seus conceitos e o estado da arte em sistemas inteligentes
para o controle veicular.
1.2.1 Aspectos Gerais das Tecnologias Aplicadas a Sistemas de Automação Veicular
A automação veicular, além de proporcionar ao motorista segurança em situações
críticas, pode também auxiliá-lo dando-lhe informações necessárias para que possa executar
manobras, ou mesmo automatizar alguma das tarefas relacionadas à dirigibilidade. A
indústria automotiva tem investido nesta área visando aumentar o conforto, segurança,
estabilidade e rendimento dos veículos, utilizando-se de sistemas embarcados que
controlam a ação de frenagem ABS – Anti-lock-Breaking-System (Kelber, 2003a), estabilidade
do veículo ESP – Eletronic Stability Program (Kelber, 2003a), controle da velocidade, controle
da autonomia, controle do consumo médio de combustível, controle de temperatura.
Com o aumento das necessidades de tornar os veículos mais inteligentes, soluções
computacionais tornaram-se cada vez mais comuns. Em diversos países os motoristas
podem contar com computadores que possuem os mapas das ruas da cidade e recebem
informações sobre as condições de trânsito escolhendo para o motorista o melhor trajeto.
As tecnologias atualmente desenvolvidas apresentam em sua maioria um grande
conjunto de sensores, transdutores, atuadores, sistemas de comunicação modernos, que
possibilitam a estes veículos cada vez mais executar tarefas mais complexas de forma
segura. Para dotar estes veículos de comportamentos inteligentes são incorporados
componentes de percepção garantindo maiores níveis de autonomia e robustez.
Cada vez mais os projetos de veículos inteligentes estão incorporando tecnologias de
desenvolvimento de robôs autônomos, estudos da cinemática (Dudek G. and Jenkin M.,
2000), comunicação, controle e inteligência para execução de tarefas.
16
A concepção de um veículo com graus de autonomia é uma ideia que vem sendo
explorada e estudada por todo o mundo. A automação veicular, mesmo em seus diferentes
níveis, proporciona aos motoristas e ocupantes, maior segurança em condições adversas.
Auxilia na condução do veículo executando tarefas de forma automatizadas, como por
exemplo: manter o veículo na pista dentro da faixa correta, manter a distância dos veículos a
sua frente, controlar a velocidade do veículo conforme o trânsito ou achar o caminho mais
curto e seguro para se chegar ao destino (Kelber C. R, et al., 2005).
Em 1997, o I.N.R.IA – Institut National de Recherche en Informatique et en
Automatique apresentou ao público um veículo de fabricação em série, chamado de CyCab,
com diversos modos de movimentação automatizados (Baille, Gérard et all., 1999). O CyCab
já está sendo produzido pela empresa Robosoft, que já apresenta inclusive outros modelos,
com o RoBUCAB, o RobuRIDE e o RoBUCAR (Robosoft, 2003).
Em 2003, a Toyota lançou, no Japão, o Prius, um modelo de veículo com capacidade
de efetuar manobras de estacionamento autonomamente (Self-parking, 2003).
Em outubro de 2005, quatro veículos conseguiram completar o percurso da
competição promovida pelo DARPA – Defense Advanced Research Projects Agency, o DARPA
Grad Chalenge Race. 132 milhas (aproximadamente 212 km) foram percorridas pelo deserto
de Nevada, nos Estados Unidos da América, de maneira completamente autônoma (CNN (a),
2005).
1.2.2 Sistemas Inteligentes Veiculares
Um ponto importante é a introdução de sistemas inteligentes na indústria
automobilística, neste caso, na literatura o termo “Sistema Inteligente” é mais aplicado na
introdução de novas tecnologias (eletrônica embarcada, sistema micro processados, etc.)
para viabilizar técnicas que aumentem a segurança, conforto e aspectos ambientais.
Nas últimas décadas os veículos de passeio têm deixado de serem máquinas
essencialmente mecânicas e incorporado cada vez mais sistemas eletrônicos de controle e
acionamentos controláveis usando informações desse sistema. A princípio foi uma “simples”
substituição do sistema de ignição com platinado pela Ignição Eletrônica. O desenvolvimento
dos sistemas de ignição eletrônica ocorreu simultaneamente com os sistemas de injeção
eletrônica.
17
Atualmente, veículos apresentados como carro conceito, dispõem de sistemas
completos totalmente drive-by-wire. Exemplos destes são o Pivo, da Nissan (CNN (b), 2005) e
o PM da Toyota (Toyota, 2006).
Com o surgimento e a popularização cada vez maior dos conceitos de sistemas
eletrônicos embarcados aplicados aos veículos de passeio, o mercado mundial responde
cada vez mais de forma positiva, dando suporte para o desenvolvimento de novas técnicas e
a realização de projetos e conceitos.
Com o crescimento das pesquisas na área de aplicação e projetos de sistemas surgem
novas necessidades tecnológicas para aumentar a segurança e o conforto do motorista e
ocupante. Os projetos de sistemas inteligentes embarcados nos veículos vêm contribuindo
para o desenvolvimento de vários ramos, tecnológico, acadêmicos e de mercado. Segundo
(Kelber C. R, et all., 2005), um dos motivos principais do surgimento de carros inteligentes é
propiciar ao motorista maior segurança e conforto em condições adversas.
Os conceitos mais aplicados nos sistemas inteligentes embarcados nos veículos
de passeio são:
ABS – Anti-lock-Breaking-System;
BAS – Breaking-Assistant;
ESP – Electronic Stability Program;
TCS – Traction Control System;
by-Wire;
Cruise Control;
Lane keeping Assistance;
Parking Assistance.
Estes sistemas foram desenvolvidos com o objetivo de proporcionar ao motorista
maior segurança em condições críticas ou auxiliado na execução de tarefas relacionadas a
condução do veículo. Cada dia os veículos inteligentes somam as novas tecnologias
formando assim uma plataforma embarcada mais complexa. Para gerenciar todos estes
sistemas estão sendo aplicados conceitos estruturais, o que tem dado aos projetistas destes
sistemas novas direções para projetar sistemas modulares responsáveis por controlar ações
do veículo.
18
Acompanhando esta tendência, este trabalho possui uma arquitetura modular onde
cada um dos módulos é responsável por ações sendo os módulos subdivididos em blocos
formando uma arquitetura distribuída. Estas tecnologias têm apresentado bons resultados,
no projeto Autonomies Fahren, (Becker, 1998), (Simon, 1999), (Sönitz, 1999), (Simon, 2000) e
(Sönitz, 2001).
1.3 Sistema de Automação Veicular
Nos últimos anos as pesquisas focadas na área de veículos inteligentes têm gerado
conceitos que estão revolucionando o mundo no que se diz respeito a transporte pessoal. As
linhas de pesquisas são as mais diversas possíveis, mas em comum, focam pontos como
segurança, conforto, cuidados ambientais e adaptabilidade para diferentes circunstâncias
(por exemplo, soluções veiculares voltadas para deficientes).
Por outro lado, os novos desenvolvimentos buscam cada vez mais substituir as
soluções mecânicas por soluções eletromecânicas (Kelber, 2003a). Nesta seção serão
estudados os diferentes sistemas de automação veicular. Do ponto de vista dos objetivos e
das técnicas aplicadas, os sistemas de automação veicular podem ser divididos em: Sistemas
de Apoio ao Motorista e Sistemas Veiculares Robóticos.
No primeiro caso, as técnicas têm como objetivo auxiliar o motorista na execução de
tarefas determinadas melhorando o desempenho do usuário e a segurança. No segundo
caso, trata-se de resolver o problema conhecido na literatura como Hands-free Vehicle
Driving (Giove D, 2004).
No caso do sistema envolver todos os controles parciais do veículo o termo usado na
literatura é Automated Highway System (AHS) (Han_Shue, et al., 1999).
19
1.3.1 Sistema de Apoio ao Motorista
Os sistemas de apoio ao motorista surgiram na década de 80 com o intuito de
proporcionar maior conforto e segurança ao motorista e os passageiros. São classificados em
dois grandes grupos: sistemas passivos e sistemas ativos (Kelber C. R, et al., 2005).
No sistema passivo a eletrônica identifica os sinais das variáveis que indicam um
cenário e alerta o motorista, que toma as devidas providências com a finalidade de
contornar a situação.
Já no caso do sistema ativo ele funciona como um “copiloto eletrônico” e em casos
de situações perigosas ele atua diretamente sobre as variáveis para efetuar a correção
necessária para auxiliar o piloto a contornar o problema. O princípio deste sistema nunca
tira do motorista o controle do veículo, ou seja, mantém a responsabilidade do condutor
atuando como auxiliar em situações de perigo.
Os sistemas de identificação de obstáculos podem ser aplicados em veículos de
pequeno e grande porte. Um sistema muito útil para a segurança dos motoristas e
passageiros em condições de pouca visibilidade ou de cochilo do motorista é o Sistema de
Aviso do Abandono de Pista. Fontes de estudo das causas dos acidentes apresentam um
elevado número de acidentes causados por motivos relacionados a perda de controle da
direção do veículo pelo abandono da pista (Kelber, 2003a).
Outro sistema muito utilizado atualmente com a popularização cada vez maior dos
GPS – Global Positioning System são os de navegação. Baseados em mapas digitais das
regiões estes sistemas funcionam como um guia instantâneo para o motorista auxiliando na
definição das rotas a serem percorridas para alcançar seu destino. Atualmente, muitos
destes sistemas estão ligados a sistemas mais complexos, o que possibilita ao motorista
obter informações das condições de trânsito, se o combustível que está no tanque é
suficiente para chegar até o destino, e oferece rotas alternativas mais rápidas e seguras
(Kelber, 2003a).
1.3.2 Sistemas Veiculares Robóticos
Recentemente surgiram os robôs móveis destacando-se por sua mobilidade guiada,
semiautônoma ou totalmente autônoma. A tecnologia dos robôs móveis tornou-se grande
20
foco de pesquisa sendo difundida em diferentes áreas e em diversas aplicações (e.g.
exploração de ambiente hostil). Pesquisas também tem se intensificado na aplicação dos
conceitos da robótica móvel em veículos de passeio.
Dentre os projetos que tem se destacado estão os participantes do Grand DARPA
Challenge 2004 – Autonomous Ground Vehicles, este evento vem ocorrendo anualmente e
tem como objetivo vencer uma distância de 300 quilômetros de forma completamente
autônoma, a equipe vencedora recebe um prêmio de 1 milhão de dólares.
O setor de carga, descarga e transporte tem se destacado nos investimentos de apoio
ao motorista. Projetos de carregadeiras, empilhadeiras autônomas foram desenvolvidos
pelas empresas FOX GmbH e Goetting KG.
1.4 Hardware Arduino e Seus Conceitos
Nesta seção são apresentados a descrição da configuração do hardware, as
ferramentas utilizadas e os conceitos aplicados para se configurar um microcontrolador
embarcado em lógica reconfigurável. Também é apresentada a descrição do software
desenvolvido, seu funcionamento no controle de cada um dos módulos e suas variáveis.
Adicionalmente, são apresentados os resultados do desenvolvimento do hardware de
controle, a ocupação dos recursos lógicos do Arduino e seu desempenho.
A configuração do Hardware de controle representa uma das etapas primordiais
desse trabalho e objetiva o projeto e implementação de um sistema para o controle e
automação do veículo que atenda as necessidades de segurança e os objetivos definidos
para o controle do veículo dentro das especificações do projeto SiAV.
1.4.1 Aspectos do Arduino
O Arduino faz parte do conceito de hardware e Open Source e está aberto para uso e
contribuição de toda sociedade. O conceito Arduino surgiu na Itália em 2005 com o objetivo
de criar um dispositivo para o controle de projetos construídos de uma forma menos
dispendiosa do que outros sistemas disponíveis no mercado.
Arduino é uma plataforma de computação física (são sistemas digitais ligados a
sensores e atuadores, que permitem construir sistemas que percebam a realidade e
21
respondam com ações físicas), baseada em uma simples placa de Entrada/Saída micro
controlada e desenvolvida sobre uma biblioteca que simplifica a escrita da programação em
C/C++. O Arduino pode ser usado para desenvolver artefatos interativos stand-alone ou
conectados ao computador através do Adobe Flash, Processing, Max/MSP, Pure Data ou
SuperCollider.
Um microcontrolador (também denominado MCU) é um computador em um chip,
que contem processador, memória e periféricos de entrada/saída. É um microprocessador
que pode ser programado para funções específicas, em contraste com outros
microcontrolador de propósito geral (como os utilizados nos PCs). Eles são embarcados no
interior de algum outro dispositivo, no nosso caso o Arduino, para que possam controlar
suas funções ou ações (Silva l. a, 2010).
1.4.2 Funcionamento do Arduino
O Arduino Mega 2560 é uma placa de microcontrolador baseada no ATmega2560
(datasheet). Ele possui 54 pinos de entradas/saídas digitais, 16 entradas analógicas, 4 UARTs
(portas seriais de hardware), um oscilador de cristal de 16 MHz, uma conexão USB, uma
entrada de alimentação, uma conexão ICSP e um botão de reset.
Figura 1 - Partes técnicas do microcontrolador Arduino Mega 2560.
22
1.4.3 Especificações técnicas do Arduino
Tabela 1 - Especificações técnicas do ATmega2560.
Micro controlado ATmega2560
Tensão de operação 5V
Tensão de entrada (recomendada) 7-12V
Tensão de entrada (limites) 6-20V
Pinos de entrada e saída (I/O) digitais 54 (dos quais 14 podem ser saídas PWM)
Pinos de entradas analógicas 16
Corrente DC por pino I/O 40mA
Corrente DC para pino de 3,3V 50mA
Memória Flash 256KB (dos quais 8KB são usados para o bootloader)
SRAM 8KB
EEPROM 4KB
Velocidade de Clock 16MHz
A Tabela 1 demostra as principais especificações do hardware embarcado Arduino.
Memória flash: é capaz de preservar os dados armazenados por um longo tempo sem
a presença de corrente elétrica;
EEPROM: memória não volátil, pode ser programada e apagada várias vezes,
eletricamente;
SRAM: memória de acesso aleatório que mantém os dados armazenados desde que
seja mantida sua alimentação;
Shields: são placas de circuito impresso com uma função específica.
A placa pode operar com alimentação externa entre 6 e 20 volts. No entanto, se
menos de 7 volts forem fornecidos o pino de 5V pode fornecer menos de 5 volts e a placa
pode ficar instável. Com mais de 12V o regulador de voltagem pode superaquecer e danificar
a placa. A faixa recomendável é de 7 a 12 volts.
Os pinos de alimentação são os seguintes:
23
VIN. Relacionado à entrada de voltagem da placa Arduino quando se está usando
alimentação externa (em oposição aos 5 volts fornecidos pela conexão USB ou outra
fonte de alimentação regulada). É possível fornecer alimentação através deste pino
ou acessá-la se estiver alimentando pelo conector de alimentação;
5V. Fornecimento de alimentação regulada para o microcontrolador e outros
componentes da placa;
3V3. Uma alimentação de 3,3 volts gerada pelo chip FTDI. A corrente máxima é de 50
mA;
GND. Pinos terra. Cada um dos 54 pinos digitais do Mega2560 pode ser usado como
entrada ou saída. Eles operam a 5 volts. Cada pino pode fornecer ou receber um
máximo de 40 mA e possui um resistor interno de 20-50 KΩ.
O Atmega2560 tem 256 KB de memória flash para armazenamento de código(dos
quais 8KB são usados pelo bootloader), 8 KB de SRAM e 4 KB de EEPROM
1.5 Ambiente de Desenvolvimento e seus Conceitos
Esta seção apresenta os ambientes de programação utilizados no sistema de
automação veicular.
Um IDE – Integrated Development Environment (Ambiente de desenvolvimento
integrado) - consiste em um software que contém um conjunto de funcionalidades
embutidas, cuja finalidade é prover um modo mais fácil e interativo de construir e manipular
seus programas. Entre estas ferramentas geralmente figuram:
Um editor de texto com facilidades especialmente desenhadas para a linguagem;
Um compilador (e um interpretador, no caso de Java e outras linguagens
interpretadas);
Um editor gráfico, com facilidades para criação e edição da interface gráfica do
programa a ser desenvolvido;
Um debugger, que possibilita um monitoramento mais elegante do funcionamento
do programa, facilitando a detecção e remoção dos erros.
24
1.5.1 Plataforma de desenvolvimento Arduino
O ambiente de desenvolvimento Arduino contém um editor de texto para a escrita
de código, uma área de mensagens, um console de texto, uma barra de ferramentas com
botões para variadas funções, e uma série de menus. Ele se conecta ao hardware do
Arduino, permitindo o upload de programas e a comunicação com eles.
Os programas escritos usando Arduino são chamados sketches. Essas sketches são
escritas no editor de texto, e são salvas com a extensão de “arquivo”. Elas permitem
funcionalidades como recortar/colar e procurar/substituir texto. Na área de mensagem,
temos retorno de ações como salvar e exportar, além da exibição de erros. O console mostra
a saída de texto do Arduino, incluindo mensagens de erro completas e outras informações.
O canto inferior direito mostra a board atual e a portal serial. Os botões da barra de
ferramentas permitem que você verifique e faça upload de programas, crie, abra e salve
sketches, e abra o monitor serial.
Na Figura 2 é possível observar o ambiente de programação do Arduino.
Figura 2 - Ambiente de desenvolvimento Arduino 0022.
Principais comandos disponíveis:
25
(a) Verify: Verifica se o código contém erros;
(b) Upload: Compila o código a faz o upload para o Arduino;
(c) New: Cria uma nova sketch;
(d) Open: Exibe um menu com todas as sketches no seu sketchbook. Ao clicar em
uma, a mesma será aberta na janela atual;
(e) Save: Salva sua sketch;
(f) Serial Monitor: Abre o monitor serial.
Comandos adicionais são encontrados através dos menus: File, Edit, Sketch, Tools, Help. As
funções disponíveis pelos menus File, Edit e Help são semelhantes a outros programas bem
conhecidos e, por isso, não iremos detalhá-las aqui.
Menu Sketch:
Verify/Compile - Verifica se seu código tem erros;
Import Library - Adiciona bibliotecas ao seu programa;
Show sketchfolder - Abre a pasta onde o programa está salvo;
Add File - Adiciona um arquivo fonte ao programa. O novo arquivo aparece em uma
nova aba.
Menu Tools:
Auto format - Formata o código para uma melhor leitura, alinhando as chaves e
indentando seu conteúdo;
Board - Seleciona o kit de desenvolvimento onde se deseja realizar o projeto;
Serial Port - Mostra todas as portas seriais que o computador possui;
26
Burn Bootloader - Permite gravar um bootloader no kit de desenvolvimento do
Arduino.
1.5.2 Plataforma de desenvolvimento Android
O Android é uma plataforma desenvolvida pela Google voltada para dispositivos
móveis. Em 5 de novembro de 2007, a empresa tornou pública a primeira plataforma Open
Source de desenvolvimento para dispositivos móveis baseada na plataforma Java com
sistema operacional Linux, a qual foi chamada de Android. Essa plataforma é mantida pela
OHA (Open Handset Alliance), um grupo formado por mais de 40 empresas as quais se
uniram para inovar e acelerar o desenvolvimento de aplicações, serviços, trazendo aos
consumidores uma experiência mais rica em termos de recursos, menos dispendiosa em
ternos financeiros para o mercado móvel. Pode-se dizer que a plataforma Android é a
primeira plataforma móvel completa, aberta e livre.
1.5.2.1 Estrutura geral da plataforma
Android é a plataforma Open Source para dispositivos móveis da OpenHandset
Alliance (OHA). O Android SDK é o kit de desenvolvimento que disponibiliza as ferramentas e
APIs necessárias para desenvolver aplicações para a plataforma Android, utilizando a
linguagem Java.
Recursos:
Application framework proporciona a reutilização e substituição de componentes;
Dalvik virtual machine otimizada para dispositivos móveis;
Browser Integrado baseado no webkit engine;
Gráficos Otimizados possui uma biblioteca 2D; e 3D baseada na especificação
OpenGL ES 1.0 (aceleração de hardware é opcional);
SQLite para guardar dados estruturados;
Suporte multimídia para áudio, vídeo e formatos de imagem (MPEG4, H.264, MP3,
AAC, AMR, JPG, PNG, GIF);
Telefonia GSM (dependente de hardware);
27
Bluetooth, EDGE, 3G, e WiFi (dependente de hardware);
Câmera, GPS, compasso, e acelerômetro (dependente de hardware);
Rico ambiente de desenvolvimento, incluindo um emulador de dispositivo,
ferramentas de depuração, memória, performance e um plugin para o Eclipse (ADT).
1.5.2.2 Arquitetura
Na Figura 3 é possível observar a arquitetura computacional do Android.
Figura 3 - Arquitetura Android.
1.5.2.3 Bibliotecas
- System C library – uma implementação derivada da biblioteca C padrão sistema
(libc) do BSD sintonizada para dispositivos rodando Linux;
- Media Libraries – baseado no PacketVideo’s OpenCORE; as bibliotecas suportam os
mais populares formatos de áudio e vídeo, bem como imagens estáticas;
- Surface Manager – gerencia o acesso ao subsistema de exibição bem como as
múltiplas camadas de aplicações 2D e 3D;
28
- LibWebCore – um web browser engine utilizado tanto no Android Browser quanto
para exibições web;
- SGL – o engine de gráficos 2D;
- 3D libraries – uma implementação baseada no OpenGL ES 1.0 APIs; as bibliotecas
utilizam aceleração 3D via hardware (quando disponível) ou o software de
renderização 3D altamente otimizado incluído no Android;
- FreeType – renderização de fontes bitmap e vector;
- SQLite – um poderoso e leve engine de banco de dados relacional disponível para
todas as aplicações.
1.5.3 Plataforma de desenvolvimento Eclipse
A integração entre o ambiente Eclipse e o Android através de plug-ins possibilitou
uma forma pratica e rápida de desenvolver um aplicativo pra dispositivos móveis.
O Eclipse é uma plataforma de desenvolvimento de Open Source extensível, baseada
em Java. Por si só, é simplesmente uma estrutura e um conjunto de serviços para
desenvolvimento de aplicativos e componentes de plug-ins.
O Eclipse possui um conjunto padrão de plug-ins, incluindo as amplamente
conhecidas Ferramentas de Desenvolvimento Java (JDT). Figura 4 mostra plataforma de
desenvolvimento Eclipse com plug-in Android instalado.
Figura 4 - Plataforma de desenvolvimento Eclipse com plug-in Android.
29
1.5.3.1 Arquitetura Eclipse
Na Figura 5 observar-se a arquitetura simplificada da plataforma eclipse.
Figura 5 - Arquitetura simplificada da plataforma eclipse.
As partes em azul (Help e Update) são componentes da parte principal da Rich Client
Platform (RCP) do Eclipse. Considere a RCP apenas como um conjunto de plug-ins que
podem usados para desenvolver aplicativos, como o Lotus Notes. As partes em azul claro são
opcionais (mais recomendadas) para serem incluídas em aplicativos baseados em RCP. E as
partes em cinza(Text, IDE Text, Compare, Debug, Search, Team/CVS, IDE personality e
Resources) são totalmente opcionais. A plataforma é composta por vários componentes.
Tempo de execução:
O tempo de execução é o código que define o modelo de plug-in do Eclipse, com base
na especificação de OSGi e noção de extensão e pontos de extensão. O tempo de execução
também fornece serviços adicionais como criação de log e simultaneidade.
JFace/SWT
O Standard Widget Toolkit (SWT) é um conjunto de widget que proporciona ao
Eclipse sua aparência. O JFace é simplesmente uma camada no alto do SWT que fornece
algumas classes Model-View-Controller (MVC) para simplificar o desenvolvimento de
aplicativos gráficos.
30
Workbench
O ambiente de trabalho concede ao Eclipse sua personalidade. O conceito das
visualizações, perspectivas e itens como editores são definidos nesse nível.
Ajuda (Assistência ao Usuário)
O componente do Eclipse permite que você forneça assistência a seus usuários. Isso
pode ser feito por meio do sistema de ajuda, que permite aos usuários fazer procuras na
documentação de ajuda ou usando folhas de dicas, que podem ser consideradas como listas
de tarefas interativas para usuários finais.
Update
O componente de atualização do Eclipse fornece as facilidades para permitir a
atualização dos seus aplicativos entre versões.
Team
O componente Team é composto por uma estrutura para permitir que fornecedores
se conectem nos seus próprios sistemas de controle de versão. Uma implementação
exemplar de provedor é o plug-in CVS fornecido fora da caixa do Eclipse.
1.5.3.2 Emulador Android
O kit de desenvolvimento Android é fornecido como plug-in e conta com o emulador
embutido auxiliando na criação de aplicativos para dispositivos móveis com sistema
operacional Android. A Figura 6 mostra emulador Android.
Figura 6 - Emulador Android.
31
1.6 Caracterização do Problema
O tema tratado, controle e automação de veículos, vêm sendo largamente
pesquisado em diferentes áreas pelo mundo.
A problemática proposta consiste no projeto e desenvolvimento de um sistema de
controle e automação de um carro de passeio aplicando processamento embarcado e Open
Source no projeto do sistema.
Diante da possibilidade de automação de um veículo, questiona-se a viabilidade de
automação utilizando-se um dispositivo SmartPhone. Visto que este proporcionaria total
liberdade para o usuário, questiona-se também a segurança e conforto.
O projeto SiAV possui arquitetura em blocos que pode ser gerenciado de forma
dinâmica que será apresentado de maneira mais abrangente nos capítulos seguintes.
A proposta do SiAV é tornar o veículo capaz de realizar tarefas por meio de um
Celular SmartPhone utilizando da tecnologia 3G e possibilitando comandos específicos ao
automóvel.
1.7 Projeto SiAV
O projeto SiAV teve início com o surgimento dos primeiros autômatos (ancestrais dos
atuais robôs), podemos considerar como um marco na história da humanidade a construção
da primeira máquina de calcular, criada por Pascal em 1642. A partir desta época inúmeros
autômatos foram desenvolvidos, mas foi somente a partir de 1923 que o termo “robot”
começou a ser empregado, tendo sido usado pela primeira vez por Karel Capek (Dudek
2000).
Com a evolução dos robot e o desejo de se automatizar cada vez mais os
componentes do nosso dia-a-dia, o projeto SiAV traz para o cotidiano a experiência de se
automatizar um veículo pequeno de passeio possibilitando assim um maior conforto,
segurança e praticidade ao usuário.
Este projeto foi desenvolvido em três etapas distintas. Na primeira etapa foram
identificados quais comandos deveriam ser automatizados, a partir daí projetou-se os
atuadores para efetuar o acionamento para esses comandos. Na segunda etapa definiu-se a
32
arquitetura de software e hardware livres para o controle das variáveis automatizadas. Na
terceira e ultima etapa desenvolveram-se os algoritmos de controle do sistema.
Vale ressaltar que o intuito do projeto é a utilização de dispositivos de baixo custo
buscando o desenvolvimento de um produto acessível à comercialização.
Foram projetados e construídos os circuitos eletroeletrônicos para a primeira versão
do software de controle e automação do veículo baseado em um microprocessador Atmega
2560 sobre plataforma Arduino.
Na Figura 7, observa-se o equipamento Arduino que foi utilizado no SiAV.
Figura 7 - Arduino Atmega 2560.
1.8 Motivação deste Trabalho
Atualmente, os sistemas autônomos veiculares vêm ganhando cada vez mais espaço.
Fatores relacionados à segurança e conforto são os principais motivadores, os quais têm
despertado o interesse de montadoras e laboratórios de pesquisa a redirecionarem suas
pesquisas em sistemas autônomos.
Entretanto, grande parte desses sistemas são projetados em arquiteturas de sistemas
microprocessados com diferentes conceitos (Shimazaki et al., 2004), (Wada M., 2003) e
33
(Good et al., 1988). As aplicações desenvolvidas em sua grande maioria são desenvolvidas
para carros com motores elétricos com diversos acessórios automáticos ou
semiautomáticos.
O projeto em questão, por sua vez, pode ser definido como diferenciado das
aplicações já desenvolvidas, pois possuem premissas que estabelecem a utilização de um
veículo popular, visando a obtenção de um sistema de baixo custo flexível o suficiente para
adaptar-se a diferentes modelos de carros realizando a tarefa de automação dos
equipamentos do veículo.
Os sistemas já desenvolvidos utilizam sistemas sofisticados e complexos instalados
em veículos modernos que contam com inúmeros dispositivos de controle já instalados.
Todo esse trabalho envolve um detalhado estudo para o desenvolvimento de um sistema
robusto, simples e barato que implique em modificações mínimas no veículo.
1.9 Justificativa
Na área de veículos autônomos ou automação veicular, tem aumentado a cada dia a
importância dos conceitos de segurança, conforto e eficiência. Visando maximizar cada vez
mais estes princípios, muito se tem investido em novas pesquisas dentro dos conceitos de
sistemas de apoio ao motorista e de automação de tarefas repetitivas dando maior conforto
e segurança.
Estudos mostram o aumento da utilização de sistemas eletrônicos para o controle e
monitoração de diversos dispositivos, sistemas e até tarefas. Os automóveis representam os
produtos que vêm a cada dia incorporando mais equipamentos e dispositivos
microeletrônicos, o que contribui para o aumento do consumo de semicondutores.
Os equipamentos incorporados aos automóveis representam a eletrônica embarcada
na forma de sensores, computadores de bordo, circuitos eletrônicos, freios inteligentes,
instrumentação, câmbios automáticos, entre outros (Consoni F., 2004).
Um ponto importante é que a capacidade para executar um projeto cresce mais
lentamente se comparada com o aumento da complexidade do mesmo. Este ponto se
reflete em um aumento lento da produtividade do ciclo de projeto de sistemas complexos
(Harteinsten R., 2002).
34
O mercado tem respondido de forma positiva com o crescimento de unidades
produzidas e comercializadas. Estima-se que nos próximos anos o aumento do consumo
destas tecnologias e novos conceitos em eletrônica embarcada nos veículos tragam maior
segurança e conforto ao motorista e aos ocupantes.
Torna-se cada vez maior o relacionamento de computadores e da indústria de
semicondutores com os automóveis. Esta modernização está trazendo aos motoristas e
passageiros diversos benefícios como: maior segurança ao dirigir, apoio ao motorista em
situações de emergência, limitadores e controladores de velocidade e estabilidade do
veículo e os sistemas de ajuda no estacionamento dos veículos.
Em países da Europa como a Alemanha, França e Itália existem rodovias com alto
grau de automatização atuando de forma inteligente, são as chamadas AHS – Automated
Highway Systems.
Essas rodovias, por sua vez, são equipadas com diversos dispositivos que auxiliam o
motorista no controle e condução do veículo, podendo estabelecer o controle de velocidade
eletronicamente, avisando o motorista das condições de alerta e emergência.
35
2 OBJETIVOS
2.1 Objetivos Gerais
Este trabalho tem como objetivo principal desenvolver um controlador de automação
para o veículo acionando os atuadores de acordo com as necessidades, seguindo as
especificações de arquitetura flexível em sistemas distribuídos (Bellardi, T., 2005).
A abordagem aplicada para este propósito baseia-se no projeto e implementação de
um controlador de automação embarcado em lógica configurável propiciando a um veículo
de passeio receber comandos para automação de forma segura e controlada. Por outro lado,
este trabalho também visa desenvolver uma interface entre o controlador e o operador para
o envio dos comandos.
2.2 Objetivos específicos
Estudar, projetar e implementar a programação dos módulos e seus respectivos
blocos para o controle de automação em um microcontrolador embarcado em
hardware Open Source;
Projetar e implementar os periféricos para o microcontrolador embarcado em
hardware Open Source e conectar ao barramento de comunicação;
Definir e projetar uma comunicação entre o operador e o controlador de forma
automática propiciando ao sistema receber comandos e executar as ações
necessárias para a automação do veículo.
36
3 METODOLOGIA
A metodologia aplicada neste trabalho dedicou-se ao projeto de um sistema de
controle e automação para um veículo de passeio comum a partir dos conceitos da
arquitetura flexível, modular e distribuída definida por (Bellardi, T., 2005). Esta arquitetura é
dividida em módulos a fim de propiciar futuras modificações do sistema e o acréscimo de
outras funcionalidades.
O sistema de controle e automação foi subdividido em dois módulos: módulo de
controle e automação, módulo de interface com o operador, sendo que estes serão
estudados posteriormente.
Desenvolveu-se a sistemática de controle e automação usando as ferramentas do
Arduino SDK 0.24 (Software Development Kit) para a codificação do software do
microcontrolador embarcado Arduino mega 2560 o qual é responsável por controlar os
atuadores do veículo.
O módulo de interface com o operador foi desenvolvido usando a ferramenta de
desenvolvimento Eclipse Idigo com pacote SDK Android (Software Development Kit). Para
codificação da interface utilizou-se a linguagem de programação Java.
A presente metodologia de projeto, envolvendo arquiteturas reconfiguráveis,
mostra-se promissora devido à grande flexibilidade das técnicas utilizadas. O projetista pode
modelar diversas técnicas de controle para validar desempenho e viabilidade
técnica/econômica do projeto.
37
4 SISTEMA DE AUTOMAÇÃO VEICULAR COM ARDUINO E ANDROID - Desenvolvimento
4.1 Arquitetura do Sistema
Esta seção apresenta arquitetura proposta na elaboração do controle de automação
do veículo. Sendo apresentadas partes mecânicas, eletroeletrônicas e computacionais
propostas nesses trabalhos.
Sabe-se que para o projeto de sistemas de controle o estudo da arquitetura do
sistema é um dos passos iniciais na concepção do projeto. É durante a elaboração da
arquitetura do sistema que os projetistas dedicam sua atenção para a definição da
comunicação, interação e o funcionamento entre os subsistemas.
Para a elaboração do sistema de controle e automação dedicaram-se esforços na
concepção de uma arquitetura que atendesse os requisitos de segurança, desempenho e
baixo custo.
A elaboração desse projeto passou por duas fases diferentes. Na primeira fase foram
definidas os parâmetros principais do projeto SiAV e seus objetivos. A segunda fase por sua
vez, consistiu no estudo e definição da arquitetura flexível e modular do sistema de controle.
As duas fases que antecederam esse trabalho contribuíram de forma importante para
a obtenção de resultados consideráveis em termos tecnológicos e científicos na elaboração e
implementação da arquitetura.
As implementações nessas fases realizadas trouxeram a possibilidade de se
desenvolver soluções a partir do ponto até onde essas fases alcançaram dando sequência ao
projeto SiAV em busca do objetivo principal do projeto: automação de um veículo utilizando
um celular Smartphone .
4.1.1 Arquitetura na primeira fase do projeto SiAV
Na primeira fase do projeto foram definidos os parâmetros de projeto e seu objetivo
obteve-se também os modelos de abertura de portas, capo e partida do motor.
Durante a elaboração da arquitetura do sistema foi seguido o fluxo de projeto saindo
do acionamento mecânico para a interface com o operador. Uma vez definida a arquitetura
38
de acionamento foram definidas as arquiteturas computacional e de acionamento
eletroeletrônico para o controle do veículo.
Na Figura 8 pode-se visualizar a arquitetura computacional e de acionamento
eletroeletrônico proposta.
Figura 8 - Diagrama de bloco do sistema proposto.
Nessa arquitetura do sistema proposta e implementada, o notebook é o responsável
por processar os comandos e enviar ao microcontrolador Arduino.
4.1.2 Arquitetura na segunda fase do projeto SiAV
Na segunda fase do projeto, foi definida uma arquitetura flexível para o controle da
movimentação do veículo. Inicialmente, aplicou-se a metodologia de se dividir o sistema e
organizá-lo em diferentes módulos os quais possuem funções bem específicas para a
realização das tarefas relacionadas ao controle da movimentação do veículo.
39
O desenho da arquitetura foi projetado pensando-se em quatro módulos sendo
esses: mapeamento, controle dos módulos de atuação, controle de automação e interface
com o usuário.
Essa estrutura apresentada por (Bellardi T, 2005) tem um caráter de orientar o
desenvolvimento do projeto, não consistindo em um critério rígido (podendo sofrer
modificações com os avanços do projeto).
Na Figura 9 observa-se a arquitetura detalhada do módulo de automação:
Figura 9 - Arquitetura conceitual do módulo de controle e automação.
Busca-se com a arquitetura proposta alcançar o objetivo inicial do projeto SiAV e
possibilitar assim automatizar outras tarefas (Correia A., et al., 2007a). Sendo assim, os
principais conceitos desenvolvidos nesta fase foram concentrados em duas frentes:
a) O desenvolvimento do controlador de automação em um microcontrolador
embarcado em lógica reconfigurável;
b) O projeto e desenvolvimento das placas de interface de sinais e potência.
40
4.2 Aspectos Gerais Desenvolvimento do Software de Controle
A seção Apêndices descreve a codificação dos principais módulos de controle
desenvolvidos no sistema de automação veicular.
4.2.1 Módulo controlador cliente
O sistema foi projetado e construído utilizando a ferramenta de desenvolvimento
eclipse onde foi adicionado o plug-in do ambiente de desenvolvimento Android utilizando a
linguagem de programação Java. O projeto partiu da criação de um pacote Android cujo
nome é (Self-Car) dentro do pacote foram criadas as classes; Cliente, ConexãoSocket, Envio e
Mensagem com extensão .java.
A classe Cliente é responsável por chamar os métodos necessários para iniciar
aplicação (Ver Apêndice A).
A classe ConexaoSocket é responsável por iniciar uma conexão com o servidor e
preparar o envio de mensagens (Ver Apêndice B).
A classe Envio é responsável por preparar o envio de mensagens ao servidor (Ver
Apêndice C).
A Classe Mensagem é responsável por enviar as mensagens para o servidor (Ver
Apêndice D).
4.2.1.1 Diagrama de classe do Módulo Cliente
Observa-se na Figura 10 do diagrama de classe Modulo Cliente, onde a classe Cliente
informa para classe ConexãoSocket o IP e Porta para conexão com o servidor socket
instalado no veículo, a classe Mensagem e responsável por informar as mensagem coletadas
da tela layout para classe Envio essa por sua vez envia as mensagem para o servidor socket.
41
Figura 10 - Diagrama de classe Módulo Cliente.
4.2.1.2 Layout do módulo cliente
A seguir é apresentado o layout do modulo cliente, onde temos uma breve
explicação das telas seguintes. A Figura 11 apresenta a tela principal do Android, quando
emulador é iniciado após clicar no ícone do software criado abrirá a tela de conexão com o
servidor onde se pode informar o IP e porta do servidor que estará alocado no veículo.
42
Figura 11 - Telas Emulador e Conexão com Servidor.
A Figura 12 apresenta a tela após a autenticação no servidor, mostrando os 4 botões
de automação do veículo onde os mesmos estarão desligados, após o acionamentos os
botões mudaram de status para on e sinalização verde.
Figura 12 - Layout módulo cliente.
4.2.2 Modulo controlador servidor
O sistema foi projetado e construído utilizando a ferramenta de desenvolvimento
eclipse utilizando a linguagem de programação Java. O projeto partiu da criação de um
Servidor Socket com duas classes: Servidor e ControlePorta.
A Classe Servidor é responsável por instanciar o servidor (Ver Apêndice E).
43
A Classe ControlePorta é responsável por enviar os comandos do servidor para o
controlador Arduino (Ver Apêndice F).
4.2.2.1 Diagrama de classe do Modulo Servidor
Observa-se na Figura 13, o diagrama de classe do modulo servidor onde a classe
Servidor envia comandos para a classe ControlePorta, esta por sua vez é a classe responsável
por instanciar uma comunicação com hardware Arduino e assim enviar comandos para o
mesmo.
Figura 13 - Diagrama de classe módulo servidor.
44
5 CONCLUSÃO
Neste trabalho foi desenvolvido um controlador de automação para o veículo
automotor de passeio possibilitando ao usuário a instalação de módulos de acordo com sua
necessidade, o projeto buscou possibilitar assim um maior conforto, segurança e praticidade
ao usuário.
Foram implementados a programação dos módulos e seus respectivos blocos para o
controle de automação em um microcontrolador embarcado em hardware Open Source.
Foram implementados os periféricos para o microcontrolador embarcado em
hardware Open Source e a conexão com o barramento de comunicação.
Foi projetada a comunicação entre o operador e o controlador de forma automática
propiciando ao sistema receber comandos e executar as ações necessárias para a
automação do veículo utilizando a tecnologia 3G, Android e Arduino para o sucesso deste
projeto.
5.1 Trabalhos futuros
As perspectivas de trabalhos futuros relacionados objetivam atingir um nível
funcional do sistema para atender as expectativas do projeto SiAV.
A implementação de um Módulo de mapeamento e localização do veículo utilizando
a tecnologia GPS (Global Positioning System) para monitoramento do automóvel.
A implementação de um Módulo de câmeras de vigilância integradas com o modulo
cliente para visualização instantânea do interior e exterior do veículo.
45
6 REFERÊNCIAS
ADADE FILHO, A. – Fundamentos de Robótica – Cinemática, Dinâmica e Controle de Manipuladores Robóticos. São José dos Campos, ITA, 1992. AMATO João Neto (2004) – Relatório setorial FINEP – Semicondutores –http://www.finep.gov.br/PortalDPP/45oolean45t_setorial – acessado em 2004 AMBIENTES VIRTUAIS INTERATIVOS E INTELIGENTES: Fundamentos, Implementação e Aplicações Práticas. XXIV Congresso da SBC – JAI 2004 (Jornadas de Atualização em Informática). Tutorial. Salvador, Bahia. Web. ANDEEN, G.B. (ED.) – Robot Design Handbook. NY, McGraw-Hill, 1988. BELLARDI Thiago C., (2005). Definição de uma arquitetura flexível para controle de movimentos de um veículo de passeio. Publicação DM – 002 Dissertação de mestrado apresentada no departamento de mecânica da Universidade de Brasília, novembro. BROWN S.; Vranesic Z. (2000). Fundamentals of Digital Logic with VHDL Design. McGraw Hill, Toronto. BUSHBY S. (1997). BACnet: a Standard Comunication Infrastrutures for intelligent Buildings. In: Elsevier, Automation in Construction 6, pg. 529-540. CORREIA A.; Llanos C. H. Q.; Carvalho R. W.; Alfaro S. A. (a) (2007): A Design/Testing Platform Based on Reconfigurable Architectures and Virtual Instrumentation Applied to the Hands-free Driving Automobile Problem, WSEAS transactions on systems and control. Issue 3, vol. 2, Março 2007. CORREIA A.; Llanos C. H. Q.; Carvalho R. W.; Alfaro S. A. (b) (2007): A Platform Based on Reconfigurable Architectures and Virtual Instrumentation Applied to the Driving Automobile Problem. 6th WSEAS International Conference on SIGNAL PROCESSING, ROBOTICS and AUTOMATION (ISPRA ’07). Ilha de Corfu, Grécia, Fevereiro, 2007. Pg. 242 a 248. CORREIA, A. P. Um projeto de Controle de Movimentação Veicular Projetado em um Processador Embarcado em FPGA com Ambiente de Simulação Usando Instrumentação Virtual. 2007. 178f. Dissertação (MESTRADO EM SISTEMAS MECATRÔNICOS)-Universidade de Brasília – Faculdade de Tecnologia Departamento de Engenharia Mecânica, Brasília, 2007. DEHON A. “The Density Advantage of Configurable Computing”, IEEE Computer. Vol. 33, No. 4, 2000. DEITEL,H.;DEITEL,P.C++: Como Programar.5 Edição. Editora Prentice-Hall. DEITEL,H.;DEITEL,P.J.Java: Como Programar.8 Edição. Editora Prentice-Hall.
46
DORF, R. C. (ED.) – Concise International Encyclopedia of Robotics. NY, Wiley, 1990. DUDEK, G. and Jenkin, M. (2000). Computational Principles of Mobile Robotics. Cambridge University Press, Cambridge, UK. EDK MicroBlaze tutorial – Xilinx 2005. FONSECA, E. G. P. da, Beppu, M. M. Apostila Arduino. 2010. 23 f. Apostila – Universidade Federal Fluminense Centro Tecnológico Escola de Engenharia Curso de Engenharia de Telecomunicações Programa de Educação Tutorial, Niterói, 2010. FU, K.S. et alii – Robotics: Control, Sensing, Vision and Intelligence. NY, McGraw-Hill, 1987. GARRIDO R. (2001). Automação e Controle Aplicados em Veículo de Combustão interna Convencional em Deslocamento Linear. Dissertação de mestrado UnB. GOETTING, H.H. (2001). FOX GmbH: Automatisierte Fahrzeuge. Disponível em: http://www.foxit.de. Acessado em: 11/06/2012. I.N.R.I.A institute – Disponível em: <http://www.inria.fr/index.en.html>. Acessado em 2007. KELBER Christian R., Cláudio R. Jung, Farlei Heinen (2005). Computação Embarcada; Projeto e Implementação de Veículos Autônomos Inteligentes. XXV Congresso da SBC, Janeiro. KELBER, C.R.; Dreger, R.S.; Gomes, G.K.; Webber, D.; Schirmbeck, J.; Netto, R.H. KELBER, C.R.; Osório, F.S.; Jung, C.R.; Heinen, F.J.; Dreger, R.S.; Gules, R.; Mello Jr., C.D.; Silveira, M.A.; Schumacher, W.; (2003ª) “Tecnologias para Automação Veicular – Soluções em Mecatrônica e Sistemas de Apoio ao Motorista”; Engenharia- Estudos Tecnológicos; ISSN 1517-3615, Vol. XXIII, No. 24, p.37-47. LEWIS, T. G.; El-Rewini, H. (1998). “Distributed and Parallel Computing”, Manning. L’HOTE, F. et alii – Robot Technology, Vol. 4 – Robot Components and Systems. London, Kogan Page/Prentice-Hall, 1983. Li J. H, Lee, Li, P. M. (2005) A Neural Network Adaptive Controller Design for Free- Pitch-Angle Diving Behavior of an Autonomous Underwater Vehicle. Robotics and Autonomous Systems. Elsevier, 52 pg 132 – 147 MINGJIE Lin.; Gamal A.; Chang Y.; Wong S. (2006). Performance Benefits of Monolithically Stacked 3D-FPGA. FPGA06 – USA. MOORE G. E. (1997). The Microprocessador: Engine of the Technology revolution. Communications of the AMC, Vol. 40 (2), pg. 112-114. NETO,O. M. Entendendo e Dominando Java. 2ª Edição. Editora Universo dos Livros. 2007.
47
OSÓRIO, F. S.; Heinen, F.; Fortes, L. (2002). Controle da Tarefa de Estacionamento de um Veículo Autônomo através do Aprendizado de um Autômato Finito usando uma Rede Neural J-CC. In: VII Simpósio Brasileiro de Redes Neurais, 2002, SBC – Porto de Galinhas – Recife. PATTERSON, David A.; Hennessy, John L. (2000). Organização e projeto de computadores: A interface Hardware/Software.2 Ed. Rio de Janeiro:LTC, pg. 551. PEREIRA, K. R. C. Sistema para Controle e Supervisão Remota para Automação Residencial. 2009. 37f. Trabalho de Conclusão de Curso. Natal, 2009. ROBOSOFT S.A. Automated People Transportation – Applications, Technologies and Perspectives. Sep. 2003. Disponível em: http://www.robosoft.fr/Brochures/wp-transports_EN.pdf. SANCHEZ, E. et al. (1999). “Static and Dynamic Configurable Systems”, IEEE Transactions of Computers, pp. 556-564. SHIMAZAKI Kazunori; Kimura Tomio; Yamada Satoshi (2004). Parking assisting device – Patent No US 6711473 B2 – United States SILVA, L. A. da. Apostila de Android: Programando Passo a Passo. 2010. 132 f. Apostila, Rio de Janeiro, 2010 SIPPER, M.; Sanchez, E. (2000). “Configurable Chips Meld Software and Hardware, IEEE Computer, pp. 120-121. SÖHNITZ, I. (2001); “Querregelung eines autonomen Strassenfahrzeugs”; Forschritt- Berichte VDI, Reihe 8, Nr. 882. SÖHNITZ, I., Schwarze, K., (1999) “Lateral Control of an Autonomous Vehicle: Design and First Practical Results”, In Proceeding of the IEEE International Conference on Intelligent Transportation Systems. Tokyo, Japan; 5-8 October. STEVEN E. Shaladover; Charles A. Desoer (1991). Automatic Vehicle Control Developments in the PATH Program. IEEE Transaction on Vehicle Technology, Vol., 40, No 1, Fevereiro. TANAKA Yuu; Iwata Yoshifumi; Satonaka Hisashi; Endo Tomohiko; Kubota Yuichi; Matsui Akira; Iwakiri Hideyuki; Sugiyama Toru; Kawakami Seiji; Iwazaki Katsuhiko; Kataoka Hiroaki (2006): Vehicle backward movement assist device and vehicle parking assist device – Patent No 7039504 – United States TOYOTA MOTOR CORPORATION. The PM concept vehicle disponível em: <http://www.toyota.com/vehicles/future/pm.html>. – Acessado em:10/11/2011. TURLEY, J. (1998). “Triscend E5 Reconfigures Microcontrollers”, Microprocessor Report, Nov. 16, pg. 12-13.
48
WILLIANS R. (2006). Projeto de um Sistema Embarcado em Arquitetura Reconfigurável e instrumentação Virtual Aplicados a Veículos Autônomos – Trabalho de Graduação – UnB. WOLF, W. (1994). “Modern VLSI Design: A system Approach”, Englewood Cliffs, Prentice Hall. Xilinx : Spartan-3 Starter Kit Board User Guide. UG130 (v1.1) Maio 2005. YABARRENA, Jean Mimar Santa Cruz (2006). Tecnologias system on chip e CAN em sistemas de controle distribuído. Dissertação de mestrado – USP. YANG E., Gu, D., Mita, T., Hu, H (2004). Nonlinear Tracking Control of A Car-Likemobile Robot via Dynamic Feedback Linearization. Control 2004, University of Bath, UK, Setembro.
49
APÊNDICES
APÊNDICE A- Classe Cliente
package br.Self.Car; import java.net.InetAddress; import java.net.NetworkInterface; import java.net.SocketException; import java.util.Enumeration; import br.Self.Car.R; import br.Self.Car.ConexaoSocket; import br.Self.Car.Mensagem; import android.app.Activity; import android.content.Intent; import android.os.Bundle; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.EditText; import android.widget.TextView; import android.widget.Toast; public class Cliente extends Activity implements OnClickListener { /** * @uml.property name=”btnConectar” * @uml.associationEnd */ private Button btnConectar; /** * @uml.property name=”lbIp” * @uml.associationEnd */ private TextView lbIp; /** * @uml.property name=”edIp” * @uml.associationEnd */ private EditText edIp; /** * @uml.property name=”edPorta” * @uml.associationEnd */ private EditText edPorta; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // Recupera componenentes da tela btnConectar = (Button) findViewById(R.id.btnConectar); btnConectar.setOnClickListener(this); edIp = (EditText) findViewById(R.id.edIp); edPorta = (EditText) findViewById(R.id.edPorta); lbIp = (TextView) findViewById(R.id.lbIp); lbIp.setText(getLocalIpAddress()); } public void onClick(View view) { if (view == btnConectar) { // Clicou no botão Conectar try {
50
// Tenta iniciar uma conexão com o Servidor de Socket ConexaoSocket connection = ConexaoSocket.createConnection(edIp.getText(). toString(), edPorta.getText().toString()); connection.connect(); // Inicia tela para envio de mensagens startActivity(new Intent(this, Mensagem.class)); } catch (Exception e) { // Mostra erro na tela Toast.makeText(this, “Não foi possível conectar” + e.getMessage(), Toast.LENGTH_LONG).show(); } } } /** * * Método para recuperar ip do aparelho */ public String getLocalIpAddress() { try { for (Enumeration<NetworkInterface> en = NetworkInterface .getNetworkInterfaces(); en.hasMoreElements();) { NetworkInterface intf = en.nextElement(); for (Enumeration<InetAddress> enumIpAddr = intf .getInetAddresses(); enumIpAddr.hasMoreElements();) { InetAddress inetAddress = enumIpAddr.nextElement(); if (!inetAddress.isLoopbackAddress()) { return inetAddress.getHostAddress().toString(); } } } } catch (SocketException ex) { } return null; } }
51
APÊNDICE B – Classe ConexaoSocket
package br.Self.Car; import java.io.DataOutputStream; import java.net.Socket; import android.os.Handler; import android.os.Message; public class ConexaoSocket { private static ConexaoSocket connection; /** * @uml.property name=”porta” */ private int porta; /** * @uml.property name=”host” */ private String host; /** * @uml.property name=”socket” */ private Socket socket; /** * @uml.property name=”sender” * @uml.associationEnd */ private Envio sender; public static final int CONNECTED = 1; public static final int ERROR = 2; public static final int SENDING_MESSAGE = 3; public static final int DISCONNECTED = 4; /** * @uml.property name=”msg” * @uml.associationEnd */ private Message msg; /** * @uml.property name=”out” */ private DataOutputStream out; /** * @uml.property name=”handler” * @uml.associationEnd */ private Handler handler; // Handle para notificações na tela private ConexaoSocket(String host, String porta) { this.host = host; this.porta = Integer.parseInt(porta); } // Método que cria Objecto ConnectionSocket public static ConexaoSocket createConnection(String host, String porta) { connection = new ConexaoSocket(host, porta); return connection; } // Retorna conexão atual public static ConexaoSocket getCurentConnection() { return connection;
52
} // Conecta com o Servidor public void connect() throws Exception { this.socket = new Socket(host, porta); out = new DataOutputStream(socket.getOutputStream()); } // Inicia Thread para envio de mensagens public void startSender(Handler handler) { sender = new Envio (out, handler); new Thread(sender).start(); this.handler = handler; } // Método set mensagem para envio public void senMessage(String mensagem) { sender.setMessage(mensagem); } // Método para 52cole52tar dados do Servidor public void disconnect() throws Exception { sender.disconnect(); socket.close(); if (handler != null) { msg = new Message(); msg.arg1 = ConexaoSocket.DISCONNECTED; handler.sendMessage(msg); } } }
53
APÊNDICE C – Classe Envio
package br.Self.Car; import java.io.DataOutputStream; import java.io.IOException; import android.os.Handler; import android.os.Message; class Envio implements Runnable { /** * @uml.property name=”out” */ private DataOutputStream out; /** * @uml.property name=”running” */ private 53oolean running = true; /** * @uml.property name=”handler” * @uml.associationEnd multiplicity=”(1 1)” */ private Handler handler; /** * @uml.property name=”msg” * @uml.associationEnd */ private Message msg; /** * @uml.property name=”sendMessage” */ private String sendMessage; public Envio (DataOutputStream out, Handler handler) { this.out = out; this.handler = handler; } public void run() { while (running) {// Enquanto estiver executando try { if (sendMessage != null) { // Se existir uma mensagem para // enviar msg = new Message(); msg.arg1 = ConexaoSocket.SENDING_MESSAGE; handler.sendMessage(msg); // Notifica Handler out.writeUTF(sendMessage); // Escreve mensagem out.flush(); sendMessage = null; // Seta nulo na mensagem } } catch (IOException e) { e.printStackTrace(); msg = new Message(); msg.arg1 = ConexaoSocket.ERROR; msg.obj = e.getMessage(); handler.sendMessage(msg); running = false; } } try {
54
out.close(); } catch (IOException e) { e.printStackTrace(); } } /** * @return * @uml.property name=”running” */ public 54oolean isRunning() { return running; } /** * @param running * @uml.property name=”running” */ public void setRunning(54oolean running) { this.running = running; } public void stop() { running = false; } public void setMessage(String message) { this.sendMessage = message; } public void disconnect() throws Exception { msg = new Message(); msg.arg1 = ConexaoSocket.DISCONNECTED; handler.sendMessage(msg); // Notifica Handler running = false; out.close(); } }
55
APÊNDICE D – Classe Mensagem
package br.Self.Car; import android.app.Activity; import android.os.Bundle; import android.os.Handler; import android.view.View; import android.widget.Toast; import android.widget.ToggleButton; import android.widget.Button; public class Mensagem extends Activity { /** * @uml.property name="handler" * @uml.associationEnd multiplicity="(1 1)" */ private Handler handler = new Handler() { public void handleMessage(android.os.Message msg) { // Verifica mensagem do Handler e mostra na tela synchronized (msg) { switch (msg.arg1) { case ConexaoSocket.CONNECTED: break; case ConexaoSocket.SENDING_MESSAGE: break; case ConexaoSocket.ERROR: break; case ConexaoSocket.DISCONNECTED: break; } } }; }; //Cria e instância os botões do tipo ToggleButton e seta a view tela1. @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.tela1); Button butDesconectar = (Button) findViewById(R.id.butDesconectar); butDesconectar.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { // Método que verifica se a seleção foi marcada. if (((Button) v).isClickable()) try { ConexaoSocket.getCurentConnection().disconnect(); } catch (Exception e) { // TODO Auto-generated catch block e.toString( ); } } }); ToggleButton butmotor = (ToggleButton) findViewById(R.id.butmotor); butmotor.setOnClickListener(new View.OnClickListener() { public void onClick(View v)
56
{ // Método que verifica se a seleção foi marcada. if (((ToggleButton) v).isChecked()) ConexaoSocket.getCurentConnection().senMessage("motor ligado"); else ConexaoSocket.getCurentConnection().senMessage("motor desligado"); } }); ToggleButton butporta = (ToggleButton) findViewById(R.id.butportas); butporta.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { // Método que verifica se a seleção foi marcada. if (((ToggleButton) v).isChecked()) ConexaoSocket.getCurentConnection().senMessage("Porta aberta"); else ConexaoSocket.getCurentConnection().senMessage("Porta fechada"); } }); ToggleButton butcapo = (ToggleButton) findViewById(R.id.butcapo); butcapo.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { // Método que verifica se a seleção foi marcada. if (((ToggleButton) v).isChecked()) ConexaoSocket.getCurentConnection().senMessage("Capô aberto"); else ConexaoSocket.getCurentConnection().senMessage("Capô fechado"); } }); try { // Recupera Conexão atual ConexaoSocket.getCurentConnection().startSender(handler); } catch (Exception e) { Toast .makeText(this,"Não foi possível iniciar o Serviço de Mensagens.",Toast.LENGTH_LONG).show(); finish(); } } }
57
APÊNDICE E - Classe Servidor
package com.sevidor; import java.io.DataInputStream; import java.net.InetAddress; import java.net.ServerSocket; import java.net.Socket; public class Servidor { private static boolean executando = true; private static String mensagem; private static final int PORTA = 1234; private static ControlePorta arduino; public void Controller(){ arduino = new ControlePorta(); arduino.initSerial(); } public static void main(String[] args) { try { ServerSocket server = new ServerSocket(1234); InetAddress addr = InetAddress.getLocalHost(); System.out.println("----------- SERVIDOR CONECTADO "+ addr.getHostAddress() + " PORTA " + PORTA + " -----------"); System.out.println("Esperando Conexões."); Socket socket = server.accept(); System.out.println("Sevidor-> Conectou Ip " + socket.getInetAddress().getHostAddress()); DataInputStream in = new DataInputStream(socket.getInputStream()); try { } // } mensagem); } System.out.println("Servidor-> Finalizado 1 "); in.close(); socket.close(); //server.close(); } catch (Exception e) { System.out.println("Servidor-> Finalizado 2 "); socket.close(); server.close(); } } catch (Exception e) { e.printStackTrace(); } } }
58
APÊNDICE F – Classe ControlePorta
Package com.sevidor; import gnu.io.CommPortIdentifier; import gnu.io.NoSuchPortException; import gnu.io.SerialPort; import java.io.IOException; import java.io.OutputStream; public class ControlePorta { private OutputStream serialOut; public void initSerial() { try { try { } { } } catch (Exception e) { e.printStackTrace(); } } public void close(){ try { serialOut.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } public void enviaDados(int 58oole){ try { { } } }
