Embed Size (px)
Citation preview
UNIVERSIDADE REGIONAL DE BLUMENAU
CENTRO DE CIÊNCIAS EXATAS E NATURAIS
CURSO DE CIÊNCIAS DA COMPUTAÇÃO – BACHARELADO
CONTROLE DE TRAÇÃO E DIREÇÃO DE UM VEÍCULO
AUTÔNOMO NÃO TRIPULADO
CARLA REAL AMORIM CARDOSO
BLUMENAU 2009
2009/1-04
CARLA REAL AMORIM CARDOSO
CONTROLE DE TRAÇÃO E DIREÇÃO DE UM VEÍCULO
AUTÔNOMO NÃO TRIPULADO
Trabalho de Conclusão de Curso submetido à Universidade Regional de Blumenau para a obtenção dos créditos na disciplina Trabalho de Conclusão de Curso II do curso de Ciências da Computação — Bacharelado.
Prof. Antônio Carlos Tavares - Orientador
BLUMENAU 2009
2009/1-04
CONTROLE DE TRAÇÃO E DIREÇÃO DE UM VEÍCULO
AUTÔNOMO NÃO TRIPULADO
Por
CARLA REAL AMORIM CARDOSO
Trabalho aprovado para obtenção dos créditos na disciplina de Trabalho de Conclusão de Curso II, pela banca examinadora formada por:
______________________________________________________ Presidente: Prof. Antônio Carlos Tavares, Msc – Orientador, FURB
______________________________________________________ Membro: Prof. Mauro Marcelo Mattos, Dr – FURB
______________________________________________________ Membro: Prof. Miguel Alexandre Wisintainer, Msc – FURB
Blumenau, 04 de agosto de 2009
Dedico este trabalho a minha família, especialmente a meu filho. Dedico também aos amigos que me incentivaram nos momentos difíceis e foram de grande importância para que este trabalho chegasse ao fim.
AGRADECIMENTOS
A Deus, que ouviu e atendeu muitas preces sempre e mais ainda nesse período de
dedicação e estudo.
À minha família que esteve sempre presente, principalmente a meu pai por ter
confeccionado alguns dos sensores.
Ao professor Miguel por toda disponibilidade, esforço e pelos milhares de protótipos
que desenvolveu para ajudar.
Ao meu orientador, Tavares, por toda paciência, pelos incentivos e ajuda em
momentos de dificuldade. E por ter acreditado na conclusão deste trabalho.
Ao Sr. Vieira da loja Proservice, que cedeu o carrinho e preparou grande parte das
adaptações mecânicas necessárias. Obrigada por ter investido seu trabalho e tempo.
Seja a mudança que quer ver no mundo.
Gandhi
RESUMO
Este trabalho apresenta o desenvolvimento de um sistema de computação embarcada que automatiza as funções mecânicas de um veículo elétrico disponibilizando comandos de software para sua locomoção. A implementação foi feita utilizando a linguagem Java e o controle dos motores conta com o microcontrolador PIC18F252. A comunicação entre o computador e os dispositivos é feita via USB através do CY7C63001A utilizando a biblioteca DelcomDLL.dll disponibilizada pela empresa Delcom Engineering.
Palavras-chave: Navegação robótica. Engenharia de controle. Motor elétrico.
ABSTRACT
This work presents the development of a computational embedded system to control the mechanics functions of an electric vehicle making available software commands for the movement. The implementation was done using the Java language and the engine control uses a PIC18F252 microcontroller. The USB communication between computer and devices uses a CY7C63001A with DelcomDLL.dll library released by Delcom Engineering Inc.
Key-words: Robotic navigation. Control engineering. Electric engine.
LISTA DE ILUSTRAÇÕES
Figura 1 – Elementos básicos de um sistema em malha fechada .............................................17
Quadro 1 – Equação de controle proporcional .........................................................................19
Quadro 2 – Equação de controle integral .................................................................................19
Quadro 3 – Equação de controle derivativo .............................................................................20
Figura 2 – Pinos do microcontrolador DIP20...........................................................................22
Quadro 4 – Descrição dos pinos...............................................................................................22
Figura 3 – Exemplo de chave óptica ........................................................................................25
Figura 4 – Encoder rotativo......................................................................................................27
Figura 5 – Encoder regular.......................................................................................................27
Figura 6 – Encoder regular defasado........................................................................................28
Figura 7 – Encoder absoluto.....................................................................................................28
Figura 8 – Funcionamento de um motor simples .....................................................................29
Figura 9 – Formato de onda PWM ...........................................................................................30
Figura 10 – Adaptação do veículo............................................................................................34
Figura 11 – Rosca da direção (rodas dianteiras).......................................................................34
Figura 12 – Encoder .................................................................................................................35
Figura 13 – Esquema eletrônico ...............................................................................................36
Figura 14 – Esquema eletrônico ...............................................................................................37
Figura 15 – Diagrama de classes ..............................................................................................38
Figura 16 – Diagrama de atividades .........................................................................................39
Figura 17 – Diagrama de sequência .........................................................................................40
Quadro 5 – Classe de interface com a biblioteca DelcomDLL.dll ...........................................42
Quadro 6 – Algoritmo de controle proporcional (P) ................................................................43
Quadro 7 – Algoritmo de controle proporcional integral (PI)..................................................44
Quadro 8 – Algoritmo de controle proporcional derivativo (PD) ............................................45
Quadro 9 – Algoritmo de controle proporcional integral derivativo (PID)..............................46
Quadro 10 – Algoritmo de decisão de parada ..........................................................................47
Figura 18 – Tela principal ........................................................................................................47
Quadro 11 – Lista de comandos disponíveis ............................................................................48
Figura 19 – Roletes testes para testes de velocidade ................................................................48
Figura 20 – Controle proporcional com ganho equivalente a 0,5 (P).......................................49
Figura 21 – Controle proporcional com ganho equivalente a 1 (P)..........................................49
Figura 22 – Controle proporcional com ganho equivalente a 2 (P)..........................................50
Figura 23 – Controle proporcional e integral (PI) ....................................................................50
Figura 24 – Controle proporcional e derivativo (PD)...............................................................51
Figura 25 – Controle proporcional, integral e derivativo (PID) ...............................................51
Figura 26 – Teste de distância ..................................................................................................52
Quadro 12 – Explicação e protótipo das funções utilizadas da DelcomDLL.dll ................58
Quadro 13 – Funções de escrita................................................................................................60
Quadro 14 – Funções de escrita................................................................................................61
Quadro 15 – Funções de escrita................................................................................................62
Quadro 16 – Funções de leitura................................................................................................63
Quadro 17 – Funções de leitura................................................................................................64
LISTA DE SIGLAS
A/D – Analógico/Digital
ABS – Anti Blocking System
API – Application Programming Interface
CC – Corrente Contínua
DC - Direct Current
DLL – Dynamic Link Library
EEPROM – Electrically Erasable Programmable Read-only Memory
Gbps – GigaBits Por Segundo
Hz – HertZ
I2C - Inter-Intergrated Circuit
JNA – Java Native Access
JNI – Java Native Interface
kHz - KiloHertZ
Mbps – MegaBits Por Segundo
P – lei de controle Proporcional
PD – lei de controle Proporcional mais Derivativo
PI – lei de controle Proporcional mais Integral
PID – lei de controle Proporcional mais Integral mais Derivativo
PWM – Pulse Width Modulation
RAM – Random Access Memory
RF – Requisito Funcional
RISC – Reduced Instruction Set Computer
RNF – Requisito Não-Funcional
RPS – Rotações Por Segundo
TCS – Torque Control System
UML – Unified Modeling Language
USB – Universal Serial Bus
SUMÁRIO
1 INTRODUÇÃO..................................................................................................................13
1.1 OBJETIVOS DO TRABALHO ........................................................................................13
1.2 ESTRUTURA DO TRABALHO ......................................................................................14
2 FUNDAMENTAÇÃO TEÓRICA....................................................................................15
2.1 SISTEMAS EMBARCADOS...........................................................................................15
2.2 VEÍCULOS AUTOMATIZADOS EXISTENTES...........................................................16
2.3 AUTOMAÇÃO E CONTROLE .......................................................................................17
2.3.1 Controlador .....................................................................................................................18
2.3.2 Leis de controle ...............................................................................................................19
2.4 MICROCONTROLADORES ...........................................................................................21
2.5 DELCOM DRIVER USB..................................................................................................22
2.5.1 USB.................................................................................................................................24
2.6 SENSORES E ATUADORES ..........................................................................................25
2.7 MOTORES ELÉTRICOS .................................................................................................29
2.7.1 PWM ...............................................................................................................................30
2.8 TRABALHOS CORRELATOS........................................................................................30
3 DESENVOLVIMENTO....................................................................................................32
3.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO.......................32
3.2 ESPECIFICAÇÃO ............................................................................................................33
3.2.1 Especificação do veículo.................................................................................................33
3.2.2 Especificação do hardware..............................................................................................35
3.2.3 Especificação do software...............................................................................................38
3.3 IMPLEMENTAÇÃO ........................................................................................................41
3.3.1 Técnicas e ferramentas utilizadas....................................................................................41
3.3.2 Operacionalidade da implementação ..............................................................................47
3.4 RESULTADOS E DISCUSSÃO ......................................................................................48
4 CONCLUSÕES..................................................................................................................53
4.1 EXTENSÕES ....................................................................................................................54
REFERÊNCIAS BIBLIOGRÁFICAS .................................................................................55
ANEXO A – Funções do driver utilizadas ............................................................................58
ANEXO B – Formato do pacote de dados e estrutura do Delcom driver USB ................59
13
1 INTRODUÇÃO
A automação tem contribuído, em diversos setores da atividade humana, para a
construção de equipamentos que visam conforto e facilidade para as pessoas. Nos anos 80, o
desenvolvimento da tecnologia dos microprocessadores impulsionou o estudo de robôs
móveis, abrindo um grande leque de possibilidades para a utilização de sistemas de
computação embarcada (COCOTA JUNIOR, 2005, p. 38).
Pesquisas em robótica móvel têm sido realizadas em busca de benefícios tais como
segurança e redução de acidentes no trânsito, assistência a pessoas com dificuldades motoras,
melhoria de processo em áreas como mineração, transporte de cargas, agricultura, exploração
espacial, manuseio de materiais perigosos, etc.
Já existem atualmente veículos com circuitos eletrônicos para controle de algumas de
suas funções mecânicas, mas pode-se dizer que os veículos existentes ainda têm sua
autonomia limitada, necessitando de comandos enviados a distância por seres humanos. A
dificuldade para utilização de robôs móveis completamente autônomos reside no fato de que
ambientes reais são desconhecidos e estão em constante mudança.
Neste contexto desenvolveu-se um sistema de computação embarcada que automatiza
as principais funções mecânicas de um veículo elétrico disponibilizando comandos de
software para sua locomoção. Estes comandos servirão como base para que futuras pesquisas
possam desenvolver módulos de controle inteligente que venham a conferir total autonomia
ao veículo.
O desenvolvimento deste trabalho implica na adaptação de um carro elétrico com o uso
de microcontroladores e motores de corrente contínua. O software, que se integra com estes
dispositivos, contêm algoritmos de controle num sistema de malha fechada com o intuito de
verificar a margem de erro existente entre o verdadeiro movimento do veículo e a velocidade
e direcionamento esperados. Esta verificação é realizada em tempo real e serve de orientação
para ajustes no movimento.
1.1 OBJETIVOS DO TRABALHO
O objetivo deste trabalho é desenvolver um sistema que controle os movimentos de um
14
veículo elétrico de forma autônoma, para que este possa receber comandos de algum outro
software sem necessidade de intervenção humana.
Os objetivos específicos do trabalho são:
a) disponibilizar a estrutura de adaptação do veículo;
b) desenvolver um software responsável pela tração e direção do veículo;
c) calibrar o movimento esperado com o realizado;
d) efetuar o controle em tempo real;
e) disponibilizar uma lista documentada com os comandos automatizados para o
veículo.
1.2 ESTRUTURA DO TRABALHO
O capítulo dois apresenta a fundamentação teórica necessária para o desenvolvimento
do presente trabalho, estando estruturado da seguinte forma: Sistemas embarcados, Veículos
automatizados existentes, Automação e controle, Microcontroladores, Delcom Driver USB,
Sensores e atuadores, Motores elétricos e Trabalhos correlatos.
No capítulo três são apresentados os principais requisitos do protótipo, a especificação
da estrutura do veículo, do hardware e do software. Em seguida é apresentada a
implementação, que abrange as técnicas e ferramentas utilizadas e a operacionalidade da
implementação. Ao final deste capítulo são expostos os resultados e discussão.
Por fim, o capítulo quatro apresenta as conclusões obtidas com o desenvolvimento
deste trabalho e sugestões para sua extensão.
15
2 FUNDAMENTAÇÃO TEÓRICA
Neste capítulo são apresentados alguns conceitos teóricos relacionados ao trabalho.
São abordados os seguintes tópicos: Sistemas embarcados, Veículos automatizados existentes,
Automação e controle, Microcontroladores, Delcom Driver USB, Sensores e atuadores e
Motores elétricos. Por fim, são apresentados os trabalhos correlatos.
2.1 SISTEMAS EMBARCADOS
Sistemas embarcados são sistemas de computação com propósitos específicos que
geralmente utilizam microprocessadores e fazem parte de uma máquina ou de um sistema
mais amplo. Seus requisitos incluem reação a eventos externos em tempo real, adaptação as
restrições de tamanho e peso, aspectos de confiabilidade e segurança. Como exemplos de
aplicação de sistemas embarcados, podem ser citados telefones celulares, equipamentos
médicos especializados, alguns equipamentos de instrumentação e sistemas de controle
automotivo (SILVA, 2001, p. 12).
Nas últimas décadas, diversas soluções eletrônicas envolvendo sistemas embarcados
vêm sendo desenvolvidas e implementadas nos veículos automotores agregando a esses,
aspectos como segurança, conforto e estabilidade. Pode-se citar exemplos como freios Anti
Blocking System (ABS)1 e sistema de controle de torque (Torque Control System - TCS)2, que
atuam automaticamente, quando o veículo encontra-se em condições extremas, procurando
minimizar, dessa forma, a ocorrência de acidentes (JUNG, 2005, p. 1366).
Jung et al. (2005, p. 1365) explicam que os sistemas mecatrônicos embarcados
consistem nos conjuntos eletromecânicos disponíveis num veículo, responsáveis por alguma
função específica no seu funcionamento. Estes sistemas geralmente baseiam-se em
informações internas e externas captadas através de sensores instalados no veículo com a
finalidade de conhecer o seu estado e as condições do ambiente ao seu redor. Entre os
sistemas embarcados mais conhecidos destacam-se o sistema de injeção de combustível,
1 “Impede o bloqueio das rodas durante uma freada, evitando que o veículo derrape.” (JUNG, 2005, p. 1366). 2 “Sistema eletrônico de controle do torque realizado por cada uma das rodas de tração, que evita que a roda “patine”, garantindo, assim, a dinâmica do veículo em arrancadas e curvas.” (JUNG. 2005, p.1367).
16
sistema de freio e de posicionamento angular da barra de direção. Jung et al. (2005, p. 1366)
afirmam ainda que cada um destes subsistemas é controlado por uma unidade eletrônica, que
se comunica com as outras através de uma rede.
2.2 VEÍCULOS AUTOMATIZADOS EXISTENTES
Já existem no mundo vários veículos com funções autônomas e inteligentes que visam
desde o apoio ao motorista até a realização de tarefas mais complexas. Entre eles estão
modelos comerciais como o Segway (SEGWAY, 2009) e o Toyota Prius (GRABIANOWSKI,
2007).
O Segway é um veículo elétrico com duas rodas paralelas dotado de auto-equilíbrio.
Basta uma inclinação do corpo do condutor para que ele se movimente para frente ou para
trás. Seu sistema embarcado possui uma tecnologia denominada estabilização dinâmica.
Quando se desloca, cinco micro-giroscópios e dois acelerômetros estudam as mudanças no
terreno e a posição do corpo do condutor, cem vezes por segundo. Esse equipamento utiliza
duas baterias Li-ion, que lhe permitem uma autonomia de cerca de trinta e cinco quilômetros
e uma velocidade máxima de 20 km/h. O Segway foi inventado pelo americano Dean Kamen
que o apresentou publicamente em dezembro de 2001. É classificado como meio de transporte
pessoal e sua utilização é direcionada para a mobilidade urbana (SEGWAY, 2009).
O Prius é um carro vendido nos Estados Unidos que possui um módulo automatizado
para estacionar. O assistente para estacionamento possui sensores ultra-sônicos para detectar
veículos parados próximo a ele e poder estimar o tamanho da vaga, bem como selecionar a
melhor posição de estacionamento para o motorista. O carro se move para entrar ou sair da
vaga posicionando-se sem o auxílio do motorista (GRABIANOWSKI, 2007).
Os sistemas apresentados acima baseiam-se em informações internas e externas ao
veículo captadas através de sensores específicos. Porém nestes dois exemplos a presença do
condutor ainda se faz necessária para complementar e fornecer informações adicionais sobre o
ambiente.
17
2.3 AUTOMAÇÃO E CONTROLE
A base do sistema de automação veicular é composta por soluções em controle de subsistemas eletromecânicos, muitas vezes invisíveis ao motorista, como por exemplo, os sistemas de controle da injeção eletrônica, do câmbio automático e da direção eletricamente assistida. (...) No topo da estrutura de controle encontram-se as soluções de computação aplicada em sistemas embarcados. (JUNG, 2005, p. 1374).
Para Bolton (1995, p. 01) o termo sistema é usado para descrever uma série de
componentes que interagem em torno de uma condição limite imaginária e somente a entrada
e a saída são de interesse, ou seja, o aspecto importante de um sistema é a relação entre as
entradas e as saídas. Um sistema pode ser chamado de sistema de controle quando sua saída é
controlada para assumir um valor particular ou seguir uma determinada entrada.
Um sistema em malha fechada é um sistema de controle que conhece por medição o
valor real do sinal de saída e utiliza este valor para ajustar o sinal de entrada fazendo com que
a saída fique com um valor cada vez mais próximo ao desejado. Ele é constituído por
subsistemas básicos conforme pode ser visto na Figura 1. Uma característica necessária a esse
tipo de sistema é a realimentação (BOLTON, 1995, p. 11).
Fonte: adaptado de Bolton (1995, p. 11).
Figura 1 – Elementos básicos de um sistema em malha fechada
18
Realimentação é a forma pela qual o sinal relacionado com a situação real é retornado
ao sistema para ser comparado com o sinal de referência. O sinal realimentado pode ser o
próprio sinal de saída ou uma função do sinal de saída e suas derivadas (OGATA, 1993, p.
03). É também chamada de retroação e pode ser realizada sob forma contínua ou descontínua
no tempo. O controle contínuo implica em uma resposta continuamente enviada de volta e
comparada com o sinal de referência na entrada do sistema de controle. Em uma das formas
do controle descontínuo, os sinais de referência e resposta são periodicamente amostrados e
comparados. Este tipo é comumente chamado de sistema de controle a dados discretos ou
sistema de controle discreto amostrado a malha fechada (D’AZZO; HOUPIS, 1988, p. 06).
De acordo com Ogata (1993, p. 03), nos sistemas de controle realimentados o sinal de
erro atuante, que é a diferença entre o sinal de entrada e o sinal realimentado, é introduzido no
controlador de modo a reduzir o erro e trazer a saída do sistema a um valor desejado. O termo
controle de malha fechada sempre implica o uso de ação de controle realimentado a fim de
reduzir o erro do sistema. Uma vantagem deste tipo de controle é o fato de que o uso da
realimentação torna a resposta do sistema relativamente insensível a distúrbios externos e
variações internas nos parâmetros do sistema. É, portanto, possível usar componentes de
baixo custo e sem muita precisão para obter o controle preciso de um determinado processo.
2.3.1 Controlador
Os sistemas em malha fechada, conforme descrito acima, possuem um controlador do
qual fazem parte o elemento de controle e o elemento de correção. O controlador tem como
entrada o sinal de erro e gera uma saída que se torna a entrada para o elemento corretivo. O
uso de um computador digital como um controlador em um sistema de controle realimentado
apresenta vantagens sobre o controlador analógico porque variações na lei de controle de um
controlador analógico implicam em variações de componentes físicos, enquanto variações na
lei de controle em um controlador digital podem frequentemente ser obtidas por mudanças no
software, isto é, mudanças em uma ou mais linhas de um programa (BOLTON, 1995, p. 435).
Um computador digital requer a entrada de sinais na forma digital. Entretanto, a planta
a ser controlada tem sinais analógicos, que variam continuamente com o tempo. Esses sinais
devem ser convertidos para a forma digital. Para isso o sinal deve ser amostrado em
intervalos, cada amostra sendo então convertida na forma digital. Assim sendo, o controlador
digital pode ser descrito como um sistema de dados amostrados (BOLTON, 1995, p. 435).
19
Segundo Bolton (1995, p. 436), o processo de amostragem de dados é onde o
conversor Analógico/Digital (A/D) amostra sinais analógicos. Geralmente, a amostragem
ocorre em intervalos de tempo regulares. O elemento de amostragem percebe o valor do sinal
por um curto período de tempo em cada período de amostragem e o ignora pelo resto do
período.
2.3.2 Leis de controle
De acordo com Bolton (1995, p. 340), a relação entre a saída e a entrada do
controlador é chamada lei de controle. Controladores digitais podem ser usados para
implementar os tipos de leis de controle usadas para controladores analógicos. Existem três
formas desta lei: proporcional, integral e derivativa.
No controle proporcional apresentado no Quadro 1, a saída do controlador é
diretamente proporcional ao sinal de erro, que é a diferença entre a entrada e a realimentação.
Neste caso a saída do controlador depende apenas da amplitude do erro no instante de tempo.
O controlador é um amplificador com um ganho constante (BOLTON, 1995, p.340).
Saída = Kp.e
Kp – constante de ganho proporcional
e – sinal de erro
Fonte: adaptado de Bolton (1995, p. 340). Quadro 1 – Equação de controle proporcional
Note que, sendo um amplificador do sinal de erro, sempre tem que haver um erro para
manter acionado o atuador. Isso limita a precisão do controle proporcional, que não consegue
manter a variável controlada no valor desejado.
Para o controle integral, a saída do controlador é proporcional à integral do sinal de
erro com o tempo (BOLTON, 1995, p.344). A equação pode ser vista no Quadro 2.
Ki – constante de ganho integral
∫ – integral entre 0 e t
e – sinal de erro
Fonte: adaptado de Bolton (1995, p. 344). Quadro 2 – Equação de controle integral
20
A integral entre 0 e t é o somatório dos produtos dos valores instantâneos da grandeza
de entrada por pequenos intervalos de tempo, desde o instante inicial até o final. O que
corresponde a área sob a curva do erro entre 0 e t. Assim quando aparece o sinal de erro, a
área sob a curva aumenta em uma razão regular e a saída do controlador deve também
aumentar em uma razão regular. A saída em qualquer instante de tempo é proporcional ao
somatório dos resultados em instantes anteriores (BOLTON, 1995, p.344). De acordo com
Ogata (1993, p. 149), a ação de controle integral é muitas vezes denominada controle de
restabelecimento.
No controle derivativo, a saída do controlador é proporcional à taxa de variação do
erro com o tempo. Sua equação está disposta no Quadro 3.
Kd – constante de ganho derivativo
e – sinal de erro
Fonte: adaptado de Bolton (1995, p. 352). Quadro 3 – Equação de controle derivativo
Assim que o sinal de erro aparece, a saída do controlador pode tornar-se grande, tendo
em vista que a saída é proporcional à taxa de variação do sinal de erro e não ao erro
propriamente dito. Entretanto, se for um erro constante (sem variações), não existe ação
corretiva, mesmo que ele seja grande. Por ser insensível a sinais de erro constantes ou de
variação lenta o controle derivativo não é usado sozinho, mas combinado com outras formas
de controle (BOLTON, 1995, p. 352).
Segundo Bolton (1995, p. 340), em alguns sistemas é necessário melhorar o
desempenho do controlador, o que é conseguido introduzindo-se elementos adicionais
chamados compensadores nos sistemas de controle. Essa alteração é chamada de
compensação. Isso pode ser feito somando-se os métodos de controle. Se um controlador é
puramente proporcional, então, por exemplo, um controlador proporcional mais integral é um
controlador proporcional com um compensador integral (BOLTON, 1995, p. 367).
É comum utilizar os controles somados, por exemplo, Proporcional mais Integral
(conhecido como controlador PI), Proporcional mais Derivativo (PD) ou um controlador
Proporcional mais Integral mais Derivativo (PID) também conhecido como controlador de
três termos. Neste último a ação combinada possui as vantagens de cada uma das três ações de
controle individuais (OGATA, 1993, p. 150).
21
2.4 MICROCONTROLADORES
O controle digital por meio de microprocessadores e microcontroladores tem sido cada
vez mais usado em sistemas de controle (BOLTON, 1995, p. 23).
Os microcontroladores são componentes inteligentes que consistem em um circuito
processador que possui entradas, saídas e uma memória (BRAGA, 2002, p. 02). Trata-se de
dispositivos programáveis e que, portanto, não realizam tarefas sem a presença de um
programa executado internamente (SOARES, 2004, p. 13). O que diferencia os diversos tipos
de microcontroladores é sua capacidade de memória, a arquitetura, a velocidade e a
alimentação (BRAGA, 2002, p. 03).
A Microchip Technology possui uma linha de microcontroladores muito popular,
denominada PIC. Os microcontroladores PIC foram os primeiros a utilizar as arquiteturas
RISC e Harvard. O que lhes permitiu diferenciar-se de outros microcontroladores em relação
a velocidade de trabalho (TAVERNIER, 1995, p. 02).
RISC significa Reduced Instruction Set Computer e é uma arquitetura em que o
microcontrolador trabalha utilizando poucas instruções básicas combinadas conforme a
necessidade (BRAGA, 2002, p. 03). Na arquitetura Harvard a memória de dados e de
programa estão em barramentos separados. Isso possibilita acessos concorrentes à memória de
dados e à memória de programa, o que melhora a performance do dispositivo (MICROCHIP
TECHNOLOGY, 2006).
O PIC18F252 pertence a uma família de microcontroladores que possui instruções em
código de máquina otimizadas para serem usadas com compiladores de linguagem C. Possui
vinte e oito pinos e é composto de uma memória de programa com 32 kbytes, memória RAM
com 1536 bytes e memória EEPROM interna com 256 bytes (MICROCHIP TECHNOLOGY,
2006).
O CY7C63001A-PC, desenvolvido pela empresa Cypress Semiconductors
Corporation, pertence a uma família de microcontroladores com suporte à comunicação USB.
Possui vinte pinos, tem trinta e cinco instruções especificas para aplicações USB, 128 bytes
de memória RAM e memória EEPROM interna com 4 kbytes. Assim como os
microcontroladores PIC o CY7C63001A-PC também utiliza arquitetura Harvard (CYPRESS
SEMICONDUCTORS CORPORATION, 2002).
22
2.5 DELCOM DRIVER USB
A empresa Delcom Engineering comercializa microcontroladores previamente
programados para facilitar aos desenvolvedores de software a conexão e controle de
periféricos USB. Tais componentes são baseados nas famílias CY7C63xxx e CY7C637xx da
Cypress Semiconductors e dão suporte à conectividade USB versão 1.1 (DELCOM
ENGINEERING, 2007b, p. 03).
São oferecidas as bibliotecas Delcomdll.dll em linguagens C e Visual Basic, exemplos
nessas duas linguagens e alguns manuais, entre eles o USB I/O Data Sheet e o Delcom DLL
Manual. Até o momento da conclusão deste trabalho não havia exemplos de utilização deste
dispositivo em linguagem Java. A biblioteca serve para todos os produtos que utilizam o
driver Delcom USB e pode ser usada em Windows 98, Windows ME, Windows 2000 e
Windows XP (DELCOM ENGINEERING, 2007a, p.03 ).
O microcontrolador CY7C63001A-PC também conhecido como USB I/O DIP20
possui vinte pinos conforme a Figura 2. A descrição desses pinos pode ser encontrada no
Quadro 4.
Fonte: Delcom Engineering (2007b, p. 03).
Figura 2 – Pinos do microcontrolador DIP20
Fonte: Delcom Engineering (2007b, p. 04).
Quadro 4 – Descrição dos pinos
23
O Delcom driver USB fornece comandos de entrada e saída de 8 bits assim como set e
reset individual por pino. As funções utilizadas do driver, com seus respectivos protótipos
estão no ANEXO A. No ANEXO B está uma parte do manual citando a estrutura packet e os
comandos de dados. Uma das características desse componente é a comunicação I2C3.
A biblioteca DelcomDLL.dll para acesso ao driver foi escrita em linguagem C. Para
utilizá-la junto à linguagem Java é necessária a utilização de APIs responsáveis pelo
mapeamento dos tipos de variáveis e estruturas que diferem entre as duas linguagens. Com
este objetivo podemos citar as APIs Java Native Interface (JNI) e Java Native Access (JNA).
A JNI é um padrão de programação de interface para escrever métodos nativos Java e
embutir a máquina virtual Java em aplicações nativas. O objetivo principal é a
compatibilidade binária de bibliotecas de métodos nativos com as implementações da
máquina virtual Java em uma determinada plataforma (SUN MICROSYSTEMS, 2003).
A JNI possibilita que código Java rode na máquina virtual Java para interoperar com
aplicações e bibliotecas escritas em outras linguagens de programação, tais como C, C++, e
assembly. Os programadores podem escrever uma versão da aplicação nativa ou da biblioteca
e esperar que funcione com todas as máquinas virtuais Java com suporte a JNI (SUN
MICROSYSTEMS, 2003).
A JNA fornece, para programas Java, acesso fácil a bibliotecas nativas (denominadas
DLLs no Windows) sem ter que escrever nada além de código Java, ou seja não é necessário
nenhum código JNI ou nativo. O acesso é dinâmico em tempo de execução e sem geração de
código (JAVANET, 2007).
A JNA possibilita chamadas diretas de funções nativas usando o formato padrão de
chamadas de métodos em Java. Esta biblioteca usa um pequeno stub4 da biblioteca nativa para
invocar dinamicamente o código nativo. O desenvolvedor utiliza uma interface em Java para
descrever as funções e estruturas da biblioteca nativa em questão. Isso facilita muito para se
aproveitar características de plataformas nativas sem ter o trabalho de configurar e construir
código JNI (JAVANET, 2007).
3 I2C (Inter-Intergrated Circuit) significa Circuito Inter-integrado e é um barramento serial desenvolvido pela Philips que é usado para conectar periféricos de baixa velocidade a uma placa mãe, a um sistema embarcado ou a um telefone celular (I2C, 2009). 4 Partes (fragmentos) de algoritmos que provêm a abstração de uma chamada (local) de procedimento (método) fazendo a ligação deste com o mecanismo de comunicação. O stub é parte do código que faz a chamada remota, é utilizado no cliente e no servidor (STUB, 2009).
24
2.5.1 USB
USB é a sigla para Universal Serial Bus. Trata-se de uma tecnologia que simplificou a
conexão de aparelhos como câmeras digitais, mouses, teclados, impressoras, entre outros ao
computador, evitando assim o uso de um tipo específico de conector para cada dispositivo
(ALECRIM, 2009).
Antigamente, conectar dispositivos ao computador era uma tarefa difícil devido a
grande variedade de cabos e conectores ou a ausência deles, no caso de ligações internas no
computador. Baseando-se nessas situações, a indústria entendeu a necessidade de criar um
padrão para facilitar a conexão de dispositivos ao computador. Dessa forma, em 1995, um
conjunto de empresa formou um consórcio para estabelecer esse padrão. Surgia então o USB
Implementers Fórum e pouco tempo depois as primeiras especificações comerciais do padrão
que ficou conhecido como USB (ALECRIM, 2009).
O USB oferece vantagens como: plug and play5, alimentação elétrica, conexão de até
127 aparelhos ao mesmo tempo, ampla compatibilidade, Hot-swappable6, possibilidade de
utilizar cabos com até cinco metros de comprimento (ALECRIM, 2009).
Segundo Alecrim (2009), a comunicação entre os dispositivos é feita através de um
protocolo. Nele o computador ou o equipamento hospedeiro, que recebe as conexões, emite
um sinal para encontrar os dispositivos conectados e estabelece um endereço para cada um
deles. Uma vez estabelecida a comunicação, o hospedeiro recebe a informação de que tipo de
conexão o dispositivo conectado utiliza.
Assim como em outras tecnologias, o padrão USB passa periodicamente por revisões
em suas especificações. A primeira versão que se tornou padrão foi a 1.1, lançada em
setembro de 1998. Ela contém praticamente todas as características listadas acima, no entanto,
sua velocidade de transmissão de dados nas conexões mais lentas é de até 1,5 Mbps. Porém,
nas conexões mais rápidas, esse valor é de até 12 Mbps (ALECRIM, 2009).
Para conexões mais rápidas, em abril de 2000 surgiu o USB 2.0, que é o padrão de
mercado atualmente. Essa versão chegou ao mercado oferecendo a velocidade de 480 Mbps.
O padrão de conexão continua sendo o mesmo da versão anterior e é compatível com os
dispositivos USB 1.1. Mais uma vantagem em relação à versão 2.0 é que os fabricantes
5 Plug and Play refere-se a dispositivos que tem sua conexão com o computador pré-configurada. Basta conectar e utilizar. 6 Hot-swappable significa que os dispositivos em padrão USB podem ser conectados e desconectados a qualquer momento, sem necessidade de reiniciar o computador.
25
puderam adotar o padrão em seus produtos sem a obrigatoriedade de pagar licenças de uso da
tecnologia. Apesar de todas as vantagens da versão 2.0, o padrão USB continua sendo
revisado o que deu espaço ao USB 3.0. Essa versão teve suas especificações definidas no final
do ano 2008 e promete velocidade de transmissão de até 4,8 Gbps (ALECRIM, 2009).
2.6 SENSORES E ATUADORES
Sensores são dispositivos que mudam seu comportamento sob a ação de uma grandeza
física, podendo fornecer diretamente ou indiretamente um sinal que indica esta grandeza. O
sinal de um sensor pode ser usado para detectar e corrigir desvios em sistemas de controle, e
nos instrumentos de medição (RUEDA; SANTOS; RABELO, 2006). Dentro de um sistema
controlado o sensor é um elemento de medida que converte a variável de saída em uma outra
variável adequada ao sistema, tal como um deslocamento, uma pressão ou uma voltagem
(OGATA, 1993, p. 146).
De acordo com Braga (2008), os sensores fotoelétricos são encontrados em uma
infinidade de formatos, indo desde simples elementos sensíveis à luz que operam com a
iluminação ambiente, até as chaves ópticas que possuem suas próprias fontes de luz
integradas. Estas últimas são extremamente rápidas e têm a vantagem de não utilizarem
contatos mecânicos que podem desgastar-se e ainda apresentarem problemas de repiques
(BRAGA, 2007).
Uma chave óptica típica é um dispositivo em que existe uma fonte emissora,
normalmente um LED infra-vermelho, e um receptor, geralmente um fototransistor, conforme
mostra a Figura 3. O dispositivo é montado de tal forma que entre o emissor e o receptor
existe uma fenda onde pode ser introduzido um objeto. A introdução desse objeto interrompe
o feixe de radiação do emissor, provocando uma mudança de estado do circuito (BRAGA,
2007).
Fonte: Braga (2007).
Figura 3 – Exemplo de chave óptica
26
Segundo Gonçalves (2003, p. 05), sensores ópticos podem ser usados para a
construção de medidores de velocidade. Há dois tipos básicos de sensores ópticos: de reflexão
e de interrupção de luz. Nos dois casos um disco com um furo é posicionado entre a fonte de
luz e o receptor. Esse disco gira e a cada passagem pelo furo o feixe de luz é alterado (a luz
passa pelo furo ou a reflexão é interrompida) e o sensor gera um pulso elétrico. A freqüência
destes pulsos é igual à velocidade, em Rotações Por Segundo (RPS), nos dois tipos.
As vantagens destes sensores são o menor tamanho e custo, a maior durabilidade e a
leitura à distância. Costumam ser usados em sistemas de controle e tacômetros portáteis
(GONÇALVES, 2003, p. 05).
Sensores ópticos também podem ser usados na composição de encoders. Os encoders
são transdutores de movimento capazes de converter movimentos lineares ou angulares em
uma série de pulsos digitais elétricos que podem ser usados para determinar velocidade, taxa
de aceleração, distância, rotação, posição ou direção (BRUSAMELLO, 2004, p. 04).
Conforme Brusamello (2004, p. 04), encoders possuem internamente um ou mais
discos perfurados denominados máscaras. Os furos na máscara, que permitem, ou não, a
passagem de um feixe de luz infravermelha, gerado por um emissor que se encontra de um
dos lados do disco e captado por um receptor que se encontra do outro lado do disco, este,
com o apoio de um circuito eletrônico gera um pulso. Dessa forma a velocidade ou
posicionamento é registrado contando-se o número de pulsos gerados.
A principal diferença entre um encoder e um sensor óptico com um disco é que no
primeiro os furos são colocados de forma que é possível identificar a posição e o sentido da
rotação do motor. O princípio de funcionamento de um encoder rotativo pode ser visto na
Figura 4.
De acordo com Brusamello (2004, p. 06), há diferentes tipos de encoders usados para
realimentação: encoder regular, encoder regular defasado e encoder absoluto.
27
Fonte: Brusamello (2004, p. 05).
Figura 4 – Encoder rotativo
O encoder regular é apresentado na Figura 5. Ele é composto por um disco perfurado,
um emissor de luz e um foto transistor. Nele a velocidade é determinada pela freqüência dos
pulsos enquanto a quantidade de pulsos determina a posição (BRUSAMELLO, 2004, p. 06).
Fonte: Brusamello (2004, p. 06).
Figura 5 – Encoder regular
28
Já o encoder regular defasado, Figura 6, possui os furos deslocados em duas filas para
que o computador possa determinar também o sentido de rotação (BRUSAMELLO, 2004, p.
07).
Fonte: Brusamello (2004, p. 07).
Figura 6 – Encoder regular defasado
A Figura 7 mostra um encoder absoluto. Ele é diferente dos demais, pois possui vários
sensores ópticos. Esses sensores são combinados entre si e geram um código que é capaz de
identificar com precisão posição do disco (BRUSAMELLO, 2004, p. 07).
Fonte: Brusamello (2004, p. 08).
Figura 7 – Encoder absoluto
Além de encoders e sensores, os atuadores são elementos presentes em sistemas de
malha fechada. Um atuador é um dispositivo que realiza ações atendendo a comandos gerados
por um controlador. É chamado assim, pois atua diretamente no processo, modificando as
condições do sistema (ATUADOR, 2009).
29
2.7 MOTORES ELÉTRICOS
Um motor simples consiste de uma bobina que gira entre dois ímãs permanentes. Figura 8 (a) Os pólos magnéticos da bobina (representados como ímã) são atraídos pelos pólos opostos dos ímãs fixos. Figura 8 (b) A bobina gira para levar esses pólos magnéticos o mais perto possível um do outro mas, Figura 8 (c) ao chegar nessa posição o sentido da corrente é invertido e Figura 8 (d) agora os pólos que se defrontam se repelem, continuando a impulsionar o rotor. (FERRAZ NETTO, 2005).
Fonte: Ferraz Netto (2005).
Figura 8 – Funcionamento de um motor simples
Motores elétricos são atuadores encontrados nas mais variadas formas e tamanhos,
cada qual apropriado a sua tarefa, dependendo de quanto torque ou potência precise
desenvolver. Alguns deles operam com corrente contínua (CC / DC) e podem ser alimentados
por pilhas, por baterias ou por fontes de alimentação (FERRAZ NETTO, 2005).
Motores de corrente contínua geralmente são bidirecionais, ou seja, você pode operar o
motor em uma direção, pará-lo, e alterar a direção (MCCOMB, 1987, P. 83). O sentido de
rotação depende das assimetrias do motor e do sentido da corrente elétrica, invertendo-se o
sentido da corrente o motor começará a girar em sentido contrário (FERRAZ NETTO, 2005).
O rotor de um motor de corrente contínua gira com velocidade angular proporcional à
tensão aplicada em suas bobinas. Em geral, ao colocar uma carga no motor, isto é ligá-lo a
algo que deve ser movimentado, sua rotação não tende a variar muito, mas sim, aumenta a
intensidade de corrente de alimentação. Para alterar a velocidade é necessário alterar a tensão
aplicada ao motor (FERRAZ NETTO, 2005).
30
2.7.1 PWM
Circuitos digitais só produzem dois valores: ligado e desligado. Já circuitos analógicos
podem ter uma infinidade de variações. Por exemplo, em um circuito digital só podemos ligar
ou desligar uma lâmpada, enquanto que em um circuito analógico podemos controlar em
infinitos gradientes o brilho da lâmpada desde o seu estado total de apagamento até o seu
brilho máximo (TORRES, 2005).
PWM significa Pulse Width Modulation (modulação por largura de pulso) e é uma
técnica utilizada para que um circuito digital, que só tem dois estados, possa controlar um
circuito analógico que pode possuir uma infinidade de estados. Ou seja, o PWM é uma forma
para conversão digital/analógico que utiliza apenas um bit. Nele é gerada uma forma de onda
quadrada onde o tempo em que esta forma fica em alta define o valor da saída (TORRES,
2005).
Esta técnica é a base para os mais populares circuitos de controle de velocidade.
Repare na Figura 9 que a freqüência é sempre a mesma, o que se altera é o tempo em que o
motor recebe tensão total (MCCOMB, 1987, p. 102).
Fonte: Mccomb (1987, p. 104).
Figura 9 – Formato de onda PWM
2.8 TRABALHOS CORRELATOS
Heinen (2002, p. 02) desenvolveu um sistema de controle para robôs móveis
31
autônomos, capaz de navegar em um ambiente dinâmico e adaptar-se a diferentes condições.
O sistema utiliza inteligência artificial para calcular um plano até o objetivo, evitando colisões
com obstáculos conhecidos, estáticos ou móveis e obstáculos imprevistos. Para localizar o
robô, a ferramenta dispõe de módulos que monitoram o ambiente e adaptam o mapa ao
perceber alguma alteração no ambiente. As estimativas de posição são dadas pelo módulo
localizador que se baseia nas informações sensoriais e num mapa. O localizador é capaz de
manter a estimativa da posição correta do robô no ambiente, da posição global ou detectar
uma estimativa de posição incorreta e se relocalizar no ambiente. Este módulo possui um
papel de destaque no sistema de controle para a navegação do robô móvel autônomo.
Estevam (2003, p. 45) apresenta o protótipo de um veículo autônomo móvel capaz de
encontrar sua trajetória a partir de imagens capturadas por uma câmera digital. O veículo
consegue locomover-se de forma independente num ambiente estático e segue uma trajetória
pré-definida por uma linha (técnica de line tracking). Para montagem do protótipo foi
utilizado um suporte mecânico dotado de três rodas, sendo que as duas rodas traseiras são
tracionadas de forma independente. A integração das partes mecânicas foi controlada por um
microcontrolador pertencente a um kit de desenvolvimento programável.
A empresa Toyota produz o automóvel Prius. De acordo com Griecco (2006), este
carro é um modelo híbrido que trabalha com um motor a explosão e outro elétrico. Quem
coordena a atuação dos dois motores é o Power Control Unit (PCU) ou unidade de controle
de força, considerado o cérebro do carro. Menos poluente e com baixo consumo de
combustível teve seu primeiro modelo lançado em 1997. Em setembro de 2003 a Toyota
lançou para o Prius o primeiro sistema inteligente de assistência para estacionamento. Sua
tecnologia dá suporte a operações de manobra para estacionar em vagas paralelas. Dois anos
mais tarde este sistema foi complementado com uma câmera no pára-choque traseiro do
automóvel para auxiliar o motorista a detectar veículos e obstáculos atrás do carro em um
monitor colorido (TOYOTA MOTOR EUROPE, 2006).
Atualmente, o assistente para estacionamento possui sensores ultra-sônicos para
detectar veículos estacionados próximo ao Prius e poder estimar o tamanho da vaga, bem
como selecionar a melhor posição de estacionamento para o motorista. O carro se move para
entrar ou sair da vaga posicionando-se sem o auxílio do motorista (GRABIANOWSKI, 2007).
32
3 DESENVOLVIMENTO
Este capítulo está dividido da seguinte forma:
a) definição dos requisitos: detalha os requisitos funcionais e não funcionais do
software;
b) especificação: nesta seção são apresentadas a especificação do veículo, do
hardware de adaptação e do software;
c) implementação: esta seção aborda as técnicas e ferramentas utilizadas no
desenvolvimento deste trabalho, assim como apresenta trechos do código fonte
desenvolvido. Também é demonstrada a operacionalidade da implementação,
através de um estudo de caso;
d) resultados e discussões: ao fim são apresentadas as dificuldades e conquistas
realizadas através do desenvolvimento deste projeto.
3.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO
Abaixo são detalhados os Requisitos Funcionais (RF) e Requisitos Não-Funcionais
(RNF) do projeto.
Os RF e RNF do software são:
a) permitir a inclinação das rodas de acordo com um valor definido em graus (RF);
b) permitir o deslocamento do veículo em dois sentidos, avanço e recuo (RF);
c) implementar o controle em malha fechada da angulação da barra de direção (RF);
d) implementar o controle em malha fechada da velocidade (RF);
e) monitorar a distância percorrida (RF);
f) monitorar a velocidade em tempo real (RF);
g) permitir a entrada do valor desejado para a velocidade (RF);
h) permitir a entrada do valor desejado para a direção (RF);
i) parar o veículo em caso do comando não ser executado corretamente após ser
enviado pela terceira vez, no caso da margem de erro ser acima da tolerância (RF);
j) utilizar metros para a medida de distâncias (RNF);
k) utilizar graus para a medida de inclinação (RNF);
33
l) utilizar metros por segundo (m/s) para a medida de velocidade (RNF);
m) ser implementado em Java utilizando o ambiente Eclipse (RNF).
3.2 ESPECIFICAÇÃO
O sistema disponibilizará comandos para que o veículo possa movimentar-se. Para
questões de teste as informações de distância a percorrer, velocidade e inclinação das rodas
serão solicitadas através de uma tela, porém a intenção é que esses comandos sejam utilizados
por outros módulos que venham a integrar o software.
O movimento de avanço e recuo se dará por dois motores elétricos de corrente
contínua acoplados às rodas traseiras. Um terceiro motor acionará a rosca da direção no eixo
dianteiro. As rodas possuem sensores para contagem de giros, para que o programa possa
avaliar o movimento real que está sendo executado. Se houver desvio, acima da tolerância, do
movimento desejado em relação à resposta mecânica o veículo pára. A cada novo comando o
objetivo é recalculado para uma resposta ideal.
O hardware foi especificado através da ferramenta Protel99. Para especificar o sistema
foi utilizada a ferramenta Enterprise Architect, onde foram modelados os diagramas UML.
3.2.1 Especificação do veículo
Para criação do protótipo foi utilizado um carro elétrico infantil. A Figura 10 mostra as
partes que foram adaptadas para o controle do veículo.
34
Figura 10 – Adaptação do veículo
Foi escolhido um carro elétrico pela facilidade de adaptação para o trabalho proposto.
Ele possui dois motores de corrente contínua que tracionam as rodas traseiras. Em cada pneu
há um sensor para auxiliar na verificação de movimento, distância percorrida e velocidade. O
eixo dianteiro recebeu uma rosca com um motor para os movimentos de inclinação das rodas.
Essa rosca, ilustrada na Figura 11, também recebeu um sensor que irá auxiliar o programa a
reconhecer o ângulo da inclinação.
Figura 11 – Rosca da direção (rodas dianteiras)
O controle do veículo é feito pelo computador central através de dois dispositivos
distintos: um para a tração (rodas traseiras) e outro para a direção (rodas dianteiras). A
comunicação entre o computador central e os dispositivos é via USB. O hardware responsável
pela tração comandará os motores de cada roda separadamente. Sua função é manter a
velocidade correta, iniciar ou finalizar o movimento. Já a parte responsável pela direção deve
apenas garantir a inclinação desejada. Esta placa também conta com sensores para verificação
35
do movimento das rodas que o programa poderá utilizar para confirmar a informação recebida
pelos sensores das rodas traseiras.
A Figura 12 apresenta o modelo dos sensores acoplados aos pneus. São discos
perfurados produzidos com placas de polipropileno que é um material resistente e firme. Não
há problema de desgaste desta peça, pois o disco não recebe pressão nem toca a chave óptica
utilizada para leitura.
Figura 12 – Encoder
3.2.2 Especificação do hardware
O circuito eletrônico para especificação do hardware foi desenhado através da
ferramenta Protel99. Ele é apresentado na Figura 13 e na Figura 14. Nestas figuras foram
criadas duas marcações destacando os elementos de maior relevância para o projeto. Ao todo
foram utilizadas duas placas com esta configuração.
Este desenho derivou do esquema eletrônico do componente L298 da empresa
STMicroelectronics. Esse componente foi substituído, pois não foi capaz de suportar a
corrente de 19 Amperes exigida pelo projeto.
Na marcação A encontra-se o CY7C63001A, que é o responsável pela comunicação
USB entre o computador central e os dispositivos controladores. Através dele é possível ligar,
desligar, selecionar o sentido e a energia disponibilizada para dois motores, além de permitir a
leitura de até três sensores.
Na marcação B está o PIC18F252, ele serve de suporte ao chip da Cypress ampliando
36
a freqüência do pulso PWM enviado aos motores de 100Hz para 2kHz. Ele também armazena
os contadores dos sensores para facilitar o processo de leitura. O circuito e o programa para o
PIC foram desenvolvidos pelo professor Miguel A. Wisintainer.
Figura 13 – Esquema eletrônico
37
Figura 14 – Esquema eletrônico
38
3.2.3 Especificação do software
A especificação do software é apresentada na Figura 15, na Figura 16 e na Figura 17,
através dos diagramas de classes, de atividades e de sequência da UML. A ferramenta
utilizada para especificação foi o Enterprise Architect.
A Figura 15 apresenta a estrutura de classes do programa que controla o veículo. A
classe de controle atuará em dois dispositivos diferentes. A classe de dispositivo se
comunicará com o hardware através da porta USB. Para que essa comunicação fosse possível
em linguagem Java, foram criadas as classes de interface com a biblioteca DelcomDLL,
descrita na seção 2.5, escrita em linguagem C.
class Classes
Dispositivo
- nome: String
- hUsb: Pointer
- numSerial: int
- versaoFirmware: byte
- dataFirmware: String
- majorCmd: byte
- minorCmd: byte
- dataLSB: byte
- dataMSB: byte
- lenght: short
- extData: byte[]
+ close() : void
+ setPWM() : void
+ setPWMmotor1() : void
+ setPWMmotor2() : void
+ l igaMotor1() : void
+ l igaMotor2() : void
+ desligaMotor1() : void
+ desligaMotor2() : void
+ direitaMotor1() : void
+ direitaMotor2() : void
+ esquerdaMotor1() : void
+ esquerdaMotor2() : void
+ selecionaSensor() : void
+ leSensor() : void
+ zerarDispositivo() : void
UsbIO
- l ib: InterfaceDelcomDLL
- deviceNamesArray: DeviceNameStruct
+ iniDevice() : int
+ getDeviceName() : String
+ openDevice() : Pointer
+ closeDevice() : void
+ getSerialnum() : int
+ getFirmwareVersion() : byte
+ getFirmwareDate() : String
+ sendPacket() : void
InterfaceDelcomDLL
Dev iceNameStruct
Controle
- dispTracao: Dispositivo
- dispDirecao: Dispositivo
- roda: double
- furosEncoder: int
- tempoAmostragem: int
- distanciaPercorrida: double
- parar: boolean
- velocidadeReal: double
- anguloAtual: double
- distanciaDesejada: double
- velocidadeDesejada: double
- anguloDesejado: double
- distanciaTotal: double
- velocidadeMax: double
- velocidadeMin: double
- emMovimento: boolean
+ sentidoAvanco() : void
+ sentidoRecuo() : void
+ calcDistanciaAmostragem() : void
+ calcParar() : void
+ pararVeiculo() : void
+ zerarSensores() : void
+ calcVelocidadeReal() : void
+ calcControle() : void
+ incl inaEsquerda() : void
+ incl inaDireita() : void
+ reiniciaDirecao() : void
+ calcDirecao() : void
+ encerrar() : void
+ calcPararDirecao() : void
PacketStruct
1112
Figura 15 – Diagrama de classes
Já na Figura 16 está descrita a interação do usuário com o sistema. O diagrama
apresenta o momento da definição dos valores para o movimento do automóvel. A qualquer
momento podem ser incluídas novas informações e o sistema recalculará o movimento, do
ponto da alteração em diante.
Na Figura 17 é apresentado o diagrama de sequência que também representa o
momento em que o usuário define os valores do percurso, porém neste estão exemplificados
os principais métodos do sistema e as classes de interface com a biblioteca utilizada.
39
act Ativ idades
início
Ligar o carro
Definir informações de direção
início
Usuário digita ângulo das
rodas dianteiras
valor correto?
Apresenta
mensagem: "Valor
incorreto".
final
Definir informações de tração
início
Usuário digita distância a
percorrer
Usuário digita velocidade
desejada
distância > 0Apresenta mensagem: "A
distância deve ser maior
que zero"
velocidade entre
maxima e minima
Apresenta mensagem:
"Velocidade inválida"
final
Usuário opta por
parar o veículo
Inicia o mov imento
final
Veículo para após
percorrer a distância
informada
Sistema inclina
rodas dianteiras
Usuário seleciona
direção
veículo está em
movimento?
direção é igual a que
está sendo realizada?
Apresenta mensagem: "O
veículo deve estar parado
para alterar a direção"
não sim
sim
sim
não
não
não
sim
sim
não
Figura 16 – Diagrama de atividades
40
sd Sequencia
Usuário ou software
InterfaceDelcomDLLInterface Controle Dispositivo UsbIO
loop
[whi le !(parar)]
loop
Liga o carro()iniciaControle()
iniciaUsbIO()
iniciaDispDirecao()
iniciaDispTracao()
Seleciona sentido()
sentidoAvanco()dispTracao.direi taM1()
sendPacket()sendPacket()
dispTracao.direi taM2()
sendPacket()sendPacket()
Digi ta velocidade desejada()setVelocidadeDesejada()
Digita distancia desejada()
setDistanciaDesejada()
Digi ta inclinacao desejada()
setAnguloDesejado()
dispDirecao.ligaM1()
sendPacket()sendPacket()
dispDirecao.setPwm()sendPacket()
sendPacket()
calcPararDirecao()
dispDirecao.desligaM1()
sendPacket()sendPacket()
Seleciona andar()
andar()
calcControle()
dispTracao.setPwm()
sendPacket()sendPacket()
Seleciona parar()
pararVeiculo()
setPwm(0)sendPacket()
sendPacket()
Seleciona fechar()
encerrar()
dispTracao.close()sendPacket()
sendPacket()
dispDirecao.close()sendPacket()
sendPacket()
Figura 17 – Diagrama de sequência
41
3.3 IMPLEMENTAÇÃO
A seguir são mostradas as técnicas e ferramentas utilizadas no desenvolvimento deste
protótipo, são apresentados trechos do código fonte desenvolvido. Também é demonstrada a
operacionalidade da implementação através de um estudo de caso.
3.3.1 Técnicas e ferramentas utilizadas
Na implementação do software foi utilizada a linguagem de programação Java através
do ambiente de desenvolvimento Eclipse 3.2. Para utilizar o programa embutido no
microcontrolador da Cypress foi utilizada a biblioteca DelcomDLL.dll fornecida pela empresa
Delcom Engineering. No desenvolvimento do software foram utilizadas as seguintes funções
do microcontrolador:
a) encontrar dispositivos USB;
b) abrir a comunicação com os dispositivos encontrados;
c) ler o nome do dispositivo;
d) ler o número de série do dispositivo;
e) ler a versão do firmware;
f) ler a data do firmware;
g) enviar pacote de dados para escrita no barramento I2C com o valor para PWM;
h) receber pacote de dados para leitura do barramento I2C com a contagem de pulsos
do sensor.
Para utilizar estas funções foi implementada uma interface com a biblioteca para que o
programa em linguagem Java pudesse se comunicar com a biblioteca desenvolvida em
linguagem C. Nesse caso foi utilizada uma API denominada JNA para viabilizar a integração.
Uma das classes da interface pode ser vista no Quadro 5.
Para controlar a velocidade do carro foram implementados os algoritmos da engenharia
de controle descritos na seção 2.3. Conforme os dados são inseridos na tela os métodos vão
sendo chamados para executar os movimentos no veículo. Todos os dados informados vão
para a classe de controle responsável pela comparação e manutenção do movimento real em
relação ao desejado.
42
package delcom;
import com.sun.jna.Library;
import com.sun.jna.Pointer;
public interface InterfaceDelcomDLL extends Library{
//Common functions
public int DelcomGetNthDevice(int type, int nth, byte[] name);
public int DelcomScanDevices(int type, DeviceNamesStruct[] deviceName, int
max);
public int DelcomReadDeviceSerialNum(String name, int hUsb);
public Pointer DelcomOpenDevice(String name, int mode);
public int DelcomCloseDevice(Pointer hUsb);
public int DelcomSendPacket(Pointer hUsb, PacketStruct send, PacketStruct
receive);
}
Quadro 5 – Classe de interface com a biblioteca DelcomDLL.dll
O controle da velocidade é feito em malha fechada, portanto, a realimentação depende
da contagem dos pulsos gerados pelos sensores instalados nas rodas traseiras. A contagem é
feita pelo microcontrolador baseada num PIC18F252. A partir do número de pulsos e das
dimensões da roda, é calculada a velocidade real e comparada com o valor desejado,
determinando erro. O valor do erro é utilizado para realimentar o sistema. É calculada então a
nova entrada visando reduzir o erro e atingir a velocidade desejada, sendo então determinada
uma nova saída do PWM.
Foram implementados quatro algoritmos de controle, proporcional, proporcional-
derivativo, proporcional-integral, proporcional-integral-derivativo, conforme descritos na
seção 2.3.2. Esses algoritmos estão apresentados nos quadros a seguir (Quadro 6, Quadro 7,
Quadro 8, Quadro 9). As vantagens e diferenças encontradas entre eles são comentadas mais
adiante.
O Quadro 6 demonstra o controle proporcional. Nele a saída é amplificada sempre
proporcionalmente ao valor do erro encontrado. O erro é a diferença entre a velocidade
desejada e a velocidade realimentada através dos sensores. Para que o controle funcione o
sinal de entrada e o de saída, ou seja, o erro e o valor calculado para o ajuste devem estar na
mesma unidade de medida. Considerando isso, o algoritmo foi implementado de forma que a
velocidade e o PWM estejam sempre em valor proporcional em vez de unidades. O tempo de
amostragem usado é de um segundo. A variável de ganho proporcional kp foi ajustada através
de testes.
43
public void calcControleProporcional(){
//a saída é proporcional ao sinal de erro
// o controlador é simplesmente um amplificador
//Saída = kp*e (pode também ter uma constante chamada Bias)
double kp = 0.8;
double erro;
double saidaP;
int valorAjuste;
int PWM = 0;
parar = false;
while (!parar){
try {
Thread.sleep(tempoAmostragem*1000);
} catch (Exception e) {
e.printStackTrace();
}
erro = velocidadeDesejada - calcVelocidadeReal();
saidaP = kp*porcentagemVelocidade(erro);
valorAjuste = (int) PWMporcentagem(saidaP);
PWM += valorAjuste;
if(PWM > 255){PWM = 255;}else {
if (PWM<0){PWM = 0;}
}
setPWMtracao(PWM);
calcParar();
}
pararVeiculo();
}
Quadro 6 – Algoritmo de controle proporcional (P)
No Quadro 7 é apresentado o cálculo do controle proporcional somado ao controle
integral. O cálculo proporcional é o mesmo apresentado no Quadro 6. O cálculo integral é o
somatório dos valores de desvio. Assim como o controle proporcional o integral também
possui uma variável de ganho que deve ser ajustada de acordo com testes.
44
public void calcControleProporcionalIntegral(){
double kp = 1;
double ki = 1;
double erroAtual = 0;
double erroAnterior = 0;
int dt = 0;
double integralAtual=0;
double integralAnterior=0;
double saidaI;
double saidaP;
int valorAjuste;
int PWM = 0;
parar = false;
while (!parar){
try {
Thread.sleep(tempoAmostragem*1000);
} catch (Exception e) {
e.printStackTrace();
}
dt++;//conta o tempo para o cálculo
erroAtual = velocidadeDesejada - calcVelocidadeReal();
//calculo proporcional
saidaP = kp*porcentagemVelocidade(erroAtual);
//calculo integral
integralAtual = (erroAtual+erroAnterior)/2*dt;//soma dos erros
multiplicados pelo tempo
integralAtual += integralAnterior;//área sob a curva integral
saidaI = integralAtual *ki;
valorAjuste = (int) PWMporcentagem(saidaP+saidaI);
PWM += valorAjuste;
if(PWM > 255){PWM = 255;}else {
if (PWM<0){PWM = 0;}
}
setPWMtracao(PWM);
//para o próximo loop
erroAnterior = erroAtual;
integralAnterior = integralAtual;
calcParar();
}
pararVeiculo();
}
Quadro 7 – Algoritmo de controle proporcional integral (PI)
O Quadro 8 mostra o controle proporcional somado ao controle derivativo. A derivada
do sinal de erro em relação ao tempo é multiplicada pela constante de ganho derivativo. Como
as outras constantes de ganho, esta também recebe um ajuste manual até que a função fique
com uma resposta adequada.
45
public void calcControleProporcionalDerivativo(){
double kp = 1;
double kd = 1;
int dt = 0;
double erroAtual = 0;
double erroAnterior = 0;
double saidaP;
double saidaD;
int valorAjuste;
int PWM = 0;
parar = false;
while (!parar){
try {
Thread.sleep(tempoAmostragem*1000);
} catch (Exception e) {
e.printStackTrace();
}
dt++;
erroAtual = velocidadeDesejada - calcVelocidadeReal();
//controle proporcional
saidaP = kp*porcentagemVelocidade(erroAtual);
//controle derivativo
saidaD = (erroAtual - erroAnterior)/dt * kd;
valorAjuste = (int) PWMporcentagem(saidaP+saidaD);
PWM += valorAjuste;
if(PWM > 255){PWM = 255;}else {
if (PWM<0){PWM = 0;}
}
setPWMtracao(PWM);
//para o próximo loop
erroAnterior = erroAtual;
calcParar();
}
pararVeiculo();
}
Quadro 8 – Algoritmo de controle proporcional derivativo (PD)
No Quadro 9 está o algoritmo de controle que utiliza as três técnicas em conjunto. A
combinação da ação proporcional, integral e derivativa tende a produzir um controlador mais
robusto e confiável, portanto a aplicação de testes é o único meio de afirmar qual algoritmo é
o mais adequado para cada sistema.
46
public void calcControleProporcionalIntegralDevirativo(){
double kp = 0.8;
double ki = 1;
double kd = 1;
double erroAtual = 0;
double erroAnterior = 0;
int dt = 0;
double integralAtual=0;
double integralAnterior=0;
double saidaI;
double saidaP;
double saidaD;
int valorAjuste;
int PWM = 0;
parar = false;
while (!parar){
try {
Thread.sleep(tempoAmostragem*1000);
} catch (Exception e) {
e.printStackTrace();
}
dt++;//conta o tempo para o cálculo
erroAtual = velocidadeDesejada - calcVelocidadeReal();
//calculo proporcional
saidaP = kp*porcentagemVelocidade(erroAtual);
//calculo integral
integralAtual = (erroAtual+erroAnterior)/2*dt;//soma dos erros
multiplicados pelo tempo
integralAtual += integralAnterior;//área sob a curva integral
saidaI = integralAtual *ki;
//controle derivativo
saidaD = (erroAtual - erroAnterior)/dt * kd;
valorAjuste = (int) PWMporcentagem(saidaP+saidaI+saidaD);
PWM += valorAjuste;
if(PWM > 255){PWM = 255;}else {
if (PWM<0){PWM = 0;}
}
setPWMtracao(PWM);
//para o próximo loop
erroAnterior = erroAtual;
integralAnterior = integralAtual;
calcParar();
}
pararVeiculo();
}
Quadro 9 – Algoritmo de controle proporcional integral derivativo (PID)
A verificação da distância percorrida também depende da contagem dos sensores. É
comparada a distância desejada com a percorrida levando-se em consideração o tempo de
amostragem e a velocidade executada no momento para decidir a parada do veículo. A
distância percorrida é zerada sempre que um novo valor é informado, porém a distância total é
conservada caso seja necessária para fins estatísticos. O algoritmo de decisão de parada é
apresentado no Quadro 10.
47
public void calcParar(){
if(distanciaPercorrida >= (distanciaDesejada - velocidadeReal)){
parar = true;
}
}
Quadro 10 – Algoritmo de decisão de parada
Para controlar a direção é possível selecionar a direção em que as rodas devem ser
inclinadas. Elas serão movimentadas continuamente até que o usuário selecione a opção parar.
3.3.2 Operacionalidade da implementação
Esta seção descreve o funcionamento do protótipo através de um estudo de caso. Para
utilizar o carro é necessário ligá-lo a uma bateria de 12 volts e iniciar o programa do
computador central. Ao iniciar o programa será apresentada uma tela conforme a Figura 18
onde se podem configurar as seguintes informações: sentido do movimento (avanço ou
recuo), velocidade desejada e distância a percorrer. Também é possível inclinar as rodas
dianteiras continuamente e solicitar sua parada controlando visualmente a posição desejada.
Da mesma forma é possível solicitar o movimento do veículo sem a necessidade de indicar
uma distância a percorrer (distância zero), neste caso a parada deve ser solicitada, pois não
será calculada pelo algoritmo de controle.
Figura 18 – Tela principal
Caso o usuário não queira utilizar a tela estão disponíveis os comandos de software
descritos no Quadro 11.
48
andar(int sentido, double distanciaD,
double velocidadeD)
Sentido pode ser 1 (avanço) ou 0
(recuo).
parar() Pára o veículo enviando o valor
zero para PWM na entrada do
circuito de potência.
inclinarDireita() Inclina a direção para a direita.
inclinarEsquerda() Inclina a direção para a
esquerda.
pararDirecao() Pára e desliga o motor da
direção.
Quadro 11 – Lista de comandos disponíveis
3.4 RESULTADOS E DISCUSSÃO
Inicialmente para a interface entre o programa em Java e a biblioteca DelcomDLL.dll
foi utilizada a API JNI, porém esta demonstrou pouca abstração sendo que havia necessidade
de se implementar uma nova biblioteca além da classe de interface. Sua utilização demandou
muito trabalho além de ser lenta.
Quanto aos algoritmos de controle pesquisados e implementados foram obtidos os
resultados apresentados abaixo, tornando possível uma comparação entre eles e a escolha da
lei de controle mais adequada para o protótipo. A comparação foi feita tendo por base o tempo
em que cada algoritmo levou para atingir estabilidade para manter a velocidade desejada.
Os testes de velocidade foram realizados com o veículo sobre um par de roletes
(Figura 19) de modo que as rodas pudessem girar livremente sem que houvesse deslocamento.
Inicialmente foi planejado efetuar testes com as rodas suspensas, porém essa hipótese foi
rejeitada pelo fato de que neste tipo de teste não estaria sendo considerado o peso do veículo.
Figura 19 – Roletes testes para testes de velocidade
A Figura 20, a Figura 21 e a Figura 22 representam o controle proporcional. Ao
49
comparar as três percebe-se bem o efeito causado pelo ajuste da sintonia do ganho
proporcional.
Na Figura 20 é apresentado o gráfico da velocidade obtido com o controle
proporcional com Kp = 0.5. O intervalo entre o valor desejado (2 m/s) e o ajuste é chamado
de banda proporcional. Quando a banda proporcional é grande o processo tende a se
estabilizar. Neste caso a estabilidade foi alcançada em sete segundos.
Figura 20 – Controle proporcional com ganho equivalente a 0,5 (P)
A Figura 21 apresenta o gráfico da velocidade obtido com controle proporcional com
KP = 1. Reduzindo a banda proporcional o processo apresentou maior dificuldade para
alcançar o valor desejado e a estabilidade foi comprometida, embora com pouca oscilação.
Este ajuste tornou o processo mais lento. Podemos dizer que a estabilidade foi alcançada em
dez segundos.
Figura 21 – Controle proporcional com ganho equivalente a 1 (P)
50
A Figura 22 apresenta o gráfico da velocidade obtido com controle proporcional com
KP = 2. Nesse caso a banda proporcional ficou extremamente reduzida e o algoritmo
apresentou-se completamente instável. O valor desejado não foi alcançado.
Figura 22 – Controle proporcional com ganho equivalente a 2 (P)
O algoritmo de controle proporcional somado ao integral apresentou o resultado
expresso na Figura 23. A variável de ganho proporcional foi ajustada ao valor 0,8 e a de
ganho integral ao valor 1. Contou-se em torno de onze segundos para atingir a estabilidade.
Figura 23 – Controle proporcional e integral (PI)
O algoritmo de controle proporcional somado ao derivativo apresentou o resultado
ilustrado na Figura 24. A variável de ganho proporcional foi ajustada ao valor 0,8 e a de
ganho derivativo ao valor 1. Esse processo apenas considera e corrige erros quando ocorre a
51
variação no desvio. Caso ocorra a ausência de variação, ou seja, nenhum erro ou erros
consecutivos com valores idênticos o controle pára de atuar. Por esse motivo a linha
permaneceu completamente estável ao atingir o valor desejado. Contou-se menos de oito
segundos para atingir a estabilidade.
Figura 24 – Controle proporcional e derivativo (PD)
O algoritmo de controle proporcional somado ao integral e ao derivativo apresentou o
resultado expresso na Figura 25. A variável de ganho proporcional foi ajustada ao valor 0,8, a
de ganho integral ao valor 1 e a de ganho derivativo também ao valor 1. A estabilidade ficou
um pouco comprometida e não foi alcançada dentro dos 15 segundos utilizados como base
para os testes.
Figura 25 – Controle proporcional, integral e derivativo (PID)
52
A intenção era controlar o carro nos sentidos de avanço e recuo, porém um dos
motores de tração apresentou um problema fazendo com que esse pudesse apenas avançar. De
todo modo os algoritmos de controle estão implementados e assim que o motor for trocado ou
o problema corrigido será possível executar testes com esta funcionalidade.
Foram efetuados alguns testes de deslocamento. Nesse momento foi verificado que não
era possível controlar corretamente a direção das rodas dianteiras. Por limitações na estrutura
do veículo não foi possível alinhar as rodas para frente e os ângulos de inclinação eram muito
pequenos e diferentes ao virá-las totalmente para a direita e totalmente para a esquerda. Uma
folga nas rodas junto ao eixo causou essa dificuldade no alinhamento.
Os testes de deslocamento foram utilizados para verificar se o algoritmo de parada
estava adequado. Foi colada uma trena no piso para marcar as distâncias (Figura 26). Nesse
teste foi visto que com velocidades mais altas a precisão é melhor. O erro mínimo percebido
foi de dez centímetros em relação a distância desejada e o máximo foi de um metro.
Figura 26 – Teste de distância
Foram encontradas dificuldades quanto ao microcontrolador CY7C63001A-PC
utilizado. Uma limitação no programa embutido ocasionou a necessidade de uma
implementação maior de hardware e de um programa para o PIC para que a leitura de dados
via I2C pudesse ser feita corretamente. Este motivo limitou o tempo de desenvolvimento do
projeto em relação a quantidade de sensores.
53
4 CONCLUSÕES
Este trabalho apresentou o protótipo de um veículo com controle autônomo de
velocidade e distância percorrida. Este estudo tende a auxiliar no desenvolvimento de
controles para outros tipos de robôs e veículos. Como foi visto no presente trabalho, veículos
automatizados são desenvolvidos para os mais diversos propósitos e a aplicação de técnicas
de controle podem contribuir para o desenvolvimento de novos veículos. Os objetivos do
trabalho foram quase totalmente atingidos, com exceção da calibragem da direção.
As ferramentas utilizadas foram adequadas para o desenvolvimento e para os testes. O
microcontrolador da Cypress e o driver USB facilitaram o controle dos motores. A
comunicação entre a aplicação Java e dispositivo depende da biblioteca DelcomDLL.dll
disponível em linguagem C, o que exigiu o desenvolvimento de uma interface implementada
com o auxílio da API JNA que proporcionou a comunicação correta com o driver. Com o
mesmo propósito inicialmente foram feitas tentativas de implementação no padrão JNI. Este
padrão não foi adequado devido a sua complexidade e demasiado consumo de tempo de
programação.
O veículo utilizou dois motores de corrente contínua para tração. Porém os motores
são diferentes, sendo um de 12 Volts e o outro de 6 Volts. O ideal seria que os dois fossem
iguais. Para alimentação dos motores foram usadas duas baterias de 6 Volts ligadas em série
enquanto a alimentação do circuito eletrônico é feita através da porta USB do computador
central.
A principal vantagem deste projeto é a aplicação das técnicas de controle para
manutenção da velocidade em tempo real. Num ambiente real existem variações como atrito e
outros ruídos que podem causar interferência na velocidade. Esses ruídos foram simulados
nos testes adicionando peso ao veículo ou suspendendo as rodas de tração, então percebeu-se
que os algoritmos de controle buscam sempre a estabilidade.
A limitação observada foi em relação a montagem do protótipo. A rosca de direção
está muito fina o que causa lentidão para inclinar as rodas. Também as peças plásticas
utilizadas nos eixos que prendem os pneus dianteiros não são adequadas, o que inviabilizou o
controle automático da direção.
54
4.1 EXTENSÕES
Como sugestão para futuros trabalhos pode-se citar as seguintes extensões e
aprimoramentos:
a) aprimorar o mecanismo, permitindo o controle da direção;
b) incluir sensores para detecção de obstáculos;
c) criar módulo de auto-estacionamento;
d) desenvolvimento de módulo de reconhecimento de rota usando um gps.
55
REFERÊNCIAS BIBLIOGRÁFICAS
ALECRIM, E. Tecnologia USB. São Paulo, 2009. Disponível em: <http://www.infowester.com/usb.php >. Acesso em: 20 maio 2009.
API. In: WIKIPÉDIA, a enciclopédia livre. [S.l.]: Wikimedia Foundation, 2009. Disponível em: <http://pt.wikipedia.org/wiki/API>. Acesso em: 28 maio 2009.
ATUADOR. In: WIKIPÉDIA, a enciclopédia livre. [S.l.]: Wikimedia Foundation, 2009. Disponível em: <http://pt.wikipedia.org/wiki/Atuador>. Acesso em: 06 ago. 2009.
BOLTON, W. Engenharia de controle. Tradução Valceres Vieira Rocha e Silva. São Paulo: Makron Books, 1995.
BRAGA, N. C. Dez Circuitos com chaves ópticas. São Paulo, out. 2007. Não paginado. Disponível em: <http://www.sabereletronica.com.br/secoes/leitura/11>. Acesso em: 20 maio 2009.
_____. Microssensores fotoelétricos. São Paulo, mar. 2008. Não paginado. Disponível em: <http://www.sabereletronica.com.br/secoes/leitura/667>. Acesso em: 20 maio 2009.
_____. Conheça os microcontroladores pic. Eletrônica Total, São Paulo, n. 85, p. 2-4, jul. 2002.
BRUSAMELLO, V. et al. Encoder. Caxias do Sul, jun. 2004. Disponível em: <www.ucs.br/ccet/demc/vjbrusam/inst/enc3.pdf>. Acesso em: 29 maio 2009.
COCOTA JUNIOR, J. A. N. Veículo mecatrônico autônomo 1. Mecatrônica Fácil, São Paulo, v. 1, n. 22, p. 38-43, jun. 2005.
CYPRESS SEMICONDUCTORS CORPORATION. CY7C63000A, CY7C63001A, CY7C63100A, CY7C63101A: universal serial bus microcontroller. San Jose, 2002. Disponível em: <http://www.alldatasheet.com/datasheet-pdf/pdf/89903/CYPRESS/CY7C63001A-PC.html>. Acesso em: 11 fev. 2009.
D’AZZO, J. J.; HOUPIS, C. H. Análise e projeto de sistemas de controle lineares. 2. ed. Tradução Bernardo Severo da Silva Filho. Rio de Janeiro: Guanabara, 1988.
DELCOM ENGINEERING. Delcom dll manual. New York, 2007a. Disponível em: <http://www.delcomproducts.com/tech.asp>. Acesso em: 11 fev. 2009
_____. USB i/o data sheet. New York, 2007b. Disponível em: <http://www.delcomproducts.com/tech.asp>. Acesso em: 11 fev. 2009
56
ESTEVAM, L. A. Protótipo de um veículo autônomo terrestre dotado de um sistema óptico para rastreamento de trajetória, 2003. 71 f. Trabalho de Conclusão de Curso (Bacharelado em Ciências da Computação) - Centro de Ciências Exatas e Naturais, Universidade Regional de Blumenau, Blumenau.
FERRAZ NETTO, L. Motores elétricos. [Barretos], [2005]. Disponível em: <http://www.feiradeciencias.com.br/sala22/motor_teoria1.asp>. Acesso em: 09 maio 2009.
GONÇALVES, L. M. G. Sensores. Natal, 2003. Disponível em: <http://www.dca.ufrn.br/~lmarcos/courses/robotica/notes/sensores.doc>. Acesso em: 07 maio 2009.
GRABIANOWSKI, E. How self-parking cars work. Atlanta, [2007?]. Disponível em: <http://auto.howstuffworks.com/self-parking-car.htm>. Acesso em: 18 set. 2008.
GRIECCO, A. Toyota prius. São Paulo, 2006. Disponível em: <http://quatrorodas.abril.com.br/carros/impressoes/conteudo_142483.shtml>. Acesso em: 16 set. 2008.
HEINEN, J. F. Sistema de controle híbrido para robôs móveis autônomos. 2002. 130 f. Dissertação (Mestrado em Computação Aplicada) – Centro de Ciências Exatas e Tecnológicas, Universidade do Vale do Rio dos Sinos, São Leopoldo.
I2C. In: WIKIPÉDIA, a enciclopédia livre. [S.l.]: Wikimedia Foundation, 2009. Disponível em: <http://pt.wikipedia.org/wiki/I%C2%B2C>. Acesso em: 31 maio 2009.
JAVANET: the source for java technology collaboration. [S.l.], [2007?]. Disponível em: <https://jna.dev.java.net/>. Acesso em: 25 mar. 2009.
SUN MICROSYSTEMS. Java native interface. [S.l.], [2003?]. Disponível em: <http://java.sun.com/j2se/1.4.2/docs/guide/jni/>. Acesso em: 15 fev. 2009.
JUNG, C. R. et al. Computação embarcada: projeto e implementação de veículos autônomos inteligentes. In: CONGRESSO DA SOCEIDADE BRASIELIRA DE COMPUTAÇÃO, 25., 2005, São Leopoldo. Anais eletrônicos..., [S.l.]: Sociedade Brasileira de Computação, 2005. p. 1358-1406. Disponível em: <www.sbc.org.br/bibliotecadigital/download.php?paper=138>. Acesso em: 14 set. 2008.
MCCOMB, G. The robot builder´s bonanza: 99 inexpensive robotics projects. New York: Tab Books, 1987.
MICROCHIP TECHNOLOGY. PIC18F252. Chandler, 2006. Disponível em: <http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en010276>. Acesso em: 21 maio 2009.
OGATA, K. Engenharia de controle moderno. 2. ed. Tradução Ivan José de Albuquerque. Rio de Janeiro: Prentice Hall, 1993.
57
RUEDA, T. C.; SANTOS, L. M.; RABELO, G. F. Controle automático do nível de poeira baseado em microcontrolador. INFOCOMP Journal of Computer Science, Lavras, v. 5, n. 1, mar. 2006. Não paginado. Disponível em: <http://www.dcc.ufla.br/infocomp/artigos/v5.1/art08.pdf>. Acesso em: 07 maio 2009.
SEGWAY. In: WIKIPÉDIA, a enciclopédia livre. [S.l.]: Wikimedia Foundation, 2009. Disponível em: <http://pt.wikipedia.org/wiki/Segway>. Acesso em: 03 jun. 2009.
SILVA, W. J. Tecnologia java para sistemas embarcados, 2001. 69 f. Trabalho de Conclusão de Curso (Bacharelado em Ciências da Computação) - Centro de Informática, Universidade Federal de Pernambuco, Pernambuco.
SOARES, M. J. Microcontroladores pic: dicas para montagens com sucesso. Eletrônica Total, São Paulo, n.98, p. 12-15, jul. 2004.
STUB. In: WIKIPÉDIA, a enciclopédia livre. [S.l.]: Wikimedia Foundation, 2009. Disponível em: <http://pt.wikipedia.org/wiki/Stub>. Acesso em: 18 jun. 2009.
TAVERNIER, C. Microcontroladores Pic. 2. ed. Tradução María José Gómez Cano. Madri: Paraninfo, 1995.
TORRES, G. PWM. [S.l.], 2005. Disponível em: <http://www.clubedohardware.com.br/printterm/77>. Acesso em: 01 set. 2008.
TOYOTA MOTOR EUROPE. Intelligent park assist. [S.l.], [2006?]. Disponível em: <http://www.toyota.eu/06_Safety/03_understanding_active_safety/01_parking_assist.aspx>. Acesso em: 18 set. 2008.
58
ANEXO A – Funções do driver utilizadas
As funções utilizadas do driver, com seus respectivos protótipos estão no Quadro 12.
DelcomGetNthDevice – Esta função retorna uma string com todos os dispositivos encontrados. O primeiro parâmetro informa à DLL que tipo de dispositivo está sendo procurado. Um valor de 1 buscará por todos os dispositivos USBIODS, um valor 2 buscará todos os dispositivos USBDELVI e um valor de 3 procurará por todos os dispositivos do tipo USBNDSPY. A função retorna verdadeiro se o dispositivo foi encontrado, senão retorna falso. O segundo parâmetro é um índice, que inicia em zero, para a lista de dispositivos que você deseja abrir. Marcar este parâmetro como zero irá tentar abrir o dispositivo correspondente na lista. O valor um tentará abrir o segundo dispositivo da lista e assim por diante. O terceiro parâmetro é um ponteiro para uma string de caracteres que deve ser pré-alocada e deve ter pelo menos 512 bytes de tamanho. Em caso de sucesso o nome do dispositivo deve retornar para o usuário para ser usado no comando DelcomOpenDevice(). C: DWORD DelcomGetNthDevice( DWORD Type, DWORD Nth, LPSTR Name); DelcomScanDevices – Esta função retorna um array com os nomes dos dispositivos em formato string e só está disponível para aplicações em linguagem C. O primeiro parâmetro informa à DLL que tipo de dispositivo está sendo procurado. Um valor de zero buscará por todos os dispositivos USBIODS e o valor 1 buscará por todos os dispositivos USBDELVI. A função retorna um inteiro representando o número de dispositivos encontrados. Se nenhum dispositivo for encontrado retorna o valor zero. O segundo parâmetro é um ponteiro para um array de strings. A função retorna os nomes dos dispositivos nesse array. Esse array deve ser declarado nas aplicações de chamada. As strings devem ter ao menos 512 bytes de tamanho. O terceiro parâmetro informa à função quão grande é o array. Esse valor deve ser no mínimo 1. A função apenas irá preencher o array até esse valor. Você pode marcar o tamanho do array e esse valor ou pode usar a função DelcomGetDeviceCount() para encontrar o número de dispositivos presentes antes de declarar o tamanho do array e esse valor. A aplicação usará os nomes dos dispositivos retornados para abrir as comunicações com os dispositivos USB. C: DWORD DelcomScanDevices( DWORD type, DeviceNameStruct[], DWORD Max); DelcomReadDeviceSerialNum – Esta função retorna o número serial para um dispositivo USB. A função tem dois modos. Pode ler o número serial do dispositivo USB dado o handle do dispositivo ou pode usar o nome do dispositivo USB. O primeiro parâmetro é uma string contento o nome do dispositivo e o segundo parâmetro é um hadle para o dispositivo. O parâmetro não usado deve ser marcado como NULL ou zero. Em caso de sucesso a função retorna o número serial do dispositivo. C: DWORD DelcomReadDeviceSerialNum(LPSTR Name, HANDLE hUsb); DelcomOpenDevice – Esta função abre o dispositivo usb e retorna um handle para o dispositivo. O primeiro parâmetro passado é uma string contendo um nome válido de um dispositivo USB retornado da função DelcomSanDevices(). Em caso de sucesso a função irá retornar um handle para o dispositivo USB. Este handle é então usado para todas as comunicações com o dispositivo USB. O segundo parâmetro é para uso futuro e deve ser enviado como zero para compatibilidade futura. Se a função falhar, um valor zero é retornado. C: HANDLE DelcomOpenDevice(LPSTR Name , DWORD Mode); DelcomCloseDevice – Esta função fecha a comunicação com o dispositivo USB e libera todo recurso utilizado pelo dispositivo. O dispositivo USB deve ser fechado após a aplicação parar de se comunicar com o dispositivo. Se o dispositivo USB não foi fechado quando a aplicação terminar, o dispositivo não poderá ser aberto novamente. Para retornar desta condição reinicie o dispositivo USB. C: DWORD DelcomCloseDevice(HANDLE hUsb); DelcomSendPacket – Esta função envia e recebe um pacote de dados do dispositivo USB. O dispositivo já deve estar aberto. O primeiro parâmetro passado é um handle para o dispositivo USB. O segundo parâmetro é um pacote de dados para enviar ao dispositivo e o último parâmetro é o pacote de dados a receber do dispositivo. O pacote de dados recebidos só é necessário quando o comando for do tipo leitura. Quando não passar um pacote de recebimento marque o último parâmetro como NULL ou zero. Em caso de sucesso a função retorna zero e retornará diferente de zero em caso de erro. O pacote de envio pode ter de 8 até 16 bytes de tamanho. O pacote de recebimento é sempre de 8 bytes. Veja o manual do dispositivo USB para mais informações no formato do pacote de dados e estrutura. C: DWORD DelcomSendPacket( HANDLE, pPacketStruct, pPacketStruct);
Fonte: adaptado de Delcom Engineering (2007a, p. 07). Quadro 12 – Explicação e protótipo das funções utilizadas da DelcomDLL.dll
59
ANEXO B – Formato do pacote de dados e estrutura do Delcom driver USB
As informações abaixo fazem parte da documentação do driver USB presente no
dispositivo utilizado para este projeto. Mais informações podem ser encontradas no manual
completo denominado USB I/O Data Sheet (DELCOM ENGINEERING, 2007b, p. 07).
Command Packet Format:
a) recipient byte always 8 for the USB IO device;
b) device model byte always 18 for the USB IO device;
c) major command byte see below;
d) minor command byte see below;
e) data LSB byte see below;
f) data MSB byte see below;
g) length short (2 bytes) length of dataextension;
h) dataextension 0-8 bytes – (optional) version 5 and up.
O Quadro 13, o Quadro 14 e o Quadro 15 apresentam o formato das funções de escrita
I2C. Já o Quadro 16 e o Quadro 17 apresentam os formatos das funções de leitura.
60
Fonte: Delcom Engineering (2007b, p. 08).
Quadro 13 – Funções de escrita
61
Fonte: Delcom Engineering (2007b, p. 09).
Quadro 14 – Funções de escrita
62
Fonte: Delcom Engineering (2007b, p. 10).
Quadro 15 – Funções de escrita
63
Fonte: Delcom Engineering (2007b, p. 11).
Quadro 16 – Funções de leitura
64
Fonte: Delcom Engineering (2007b, p. 12).
Quadro 17 – Funções de leitura
