Embed Size (px)
Citation preview
UNIVERSIDADE DO VALE DO ITAJAÍ
CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
VEÍCULO AUTÔNOMO USANDO ARDUINO
por
Rodrigo Hoepers
Itajaí (SC), julho de 2012
ii
UNIVERSIDADE DO VALE DO ITAJAÍ
CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
VEÍCULO AUTÔNOMO USANDO ARDUINO
Área de Robótica
por
Rodrigo Hoepers
Relatório apresentado à Banca Examinadora
do Trabalho Técnico-científico de Conclusão
do Curso de Ciência da Computação para
análise e aprovação.
Orientador: Adhemar Maria do Valle Filho,
Dr.
Itajaí (SC), julho de 2012
iii
A Deus.
Aos meus pais Jaime Hoepers e Eulália Maria Hoepers por toda educação,
pela paciência nesse período importante de minha vida,
aos meus irmãos Jean e Graziela,
aos meus sobrinhos,
e aos amigos que me apoiaram de alguma forma.
iv
AGRADECIMENTOS
A Deus, por tudo;
Ao meu pai Jaime Hoepers, que sempre acreditou em mim;
A minha mãe Eulália Maria Hoepers, pela paciência;
Aos meus irmãos Jean e Graziela, pelo apoio;
Aos meus sobrinhos Lucas, Gustavo e Amanda, que mesmo não entendendo muito me
apoiaram;
Ao meu amigo Evandro Correia, pelo interesse e disponibilização de seu tempo em
ajudar na adaptação do Veículo Autônomo;
Ao meu amigo Éderson Recalcatti, por passar de alguma forma um pouco de seu vasto
conhecimento em eletrônica, ajudando na proteção do circuito eletrônico do Veículo
Autônomo;
Ao meu orientador, professor Adhemar, pelo incentivo, pela confiança e
principalmente pela paciência;
Ao professor Rudimar Luís Scaranto Dazzi por ceder gentilmente o carro modelo
usado nesse projeto.
Enfim, a todos os amigos que direta ou indiretamente incentivaram e acreditaram na
execução desse projeto.
v
RESUMO
HOEPERS, Rodrigo. Veículo Autônomo usando Arduino. Itajaí, 2012. 88. Trabalho
Técnico-científico de Conclusão de Curso (Graduação em Ciência da Computação) – Centro
de Ciências Tecnológicas da Terra e do Mar, Universidade do Vale do Itajaí, Itajaí, 2012.
A área de robótica é uma das que mais apresenta avanços no mundo, tanto para projetos de
utilidade civil quanto militar. Uma subárea em constante ascensão no meio robótico são os
veículos autônomos que podem ter inteligência ou não. Veículos autônomos tornam a vida
das pessoas mais confortáveis e seguras, apresentando propostas interessantes como, por
exemplo, defender nossas fronteiras, bem como veículos que seguem a premissa da segurança
nas estradas, controlando velocidade, aproximação de outros veículos e acionamento de
freios, independentemente do comando do motorista. A proposta desse Trabalho Técnico-
científico de Conclusão de Curso é adaptar a um veículo uma placa com um microcontrolador
e controlar a sua trajetória. A parte eletrônica é composta de uma placa da plataforma
Arduino, junto com sensores de proximidade e servomotor para controlar a direção, adaptados
a um carrinho de controle remoto. Este carrinho já contém o motor onde será controlada sua
velocidade. A lógica é aproximar do obstáculo, diminuir a velocidade e efetuar a curva.
Fatores relacionado ao tempo gasto na adaptação do carrinho e criação do circuito eletrônico
impediram o desenvolvimento do controlador Fuzzy, ficando apenas em simulações realizada
no FuzzyCLIPS, onde os resultados gerados são inseridos manualmente no sketch do
Arduino. Os resultados gerados a partir das simulações foram capazes de fazer o veículo
funcionar de forma adequada.
Palavras-chave: Veículo Autônomo. Lógica Fuzzy. Arduino.
vi
ABSTRACT
The robotics subjects is one of the most presents advances in the world, both for projects in
civil and military utility. A steady rise in sub-area in the middle are the robotic autonomous
vehicles that may have intelligence or not. Autonomous vehicles make people's lives more
comfortable and secure, with interesting proposals, eg, defend our borders, as well
as vehicles that follow the premise of road safety, controlling speed, approach of
other vehicles and drive brakes, regardless of command of the driver. The purpose of
this work Completion of course is to adapt a vehicle a plate with a microcontroller
and control your trajectory. The electronics consists of a board Arduino platform, along
with proximity sensors and servo to control the direction and adapted to a remote control
car. This car already has the engine where its speed is controlled. The logic is closer to
the obstacle, slow down and make the curve. The control of autonomous vehicle was based
on artificial intelligence technique called fuzzy logic. Factors related to time spent on
adapting the vehicle the creation of the electronic circuit prevented the development of the
fuzzy controller, leaving only the FuzzyCLIPS performed simulations where the results
generated are manually inserted into the Arduino sketch. The generated results from
simulations were able to make the vehicle function properly.
Keywords: Autonomous Robot. Fuzzy Logic. Arduino.
vii
LISTA DE FIGURAS
Figura 1. Visão frontal Arduino Uno........................................................................................ 15
Figura 2. Controlador Fuzzy ..................................................................................................... 20 Figura 3. Classificação para variável linguística distância. ...................................................... 21 Figura 4. Diagrama de blocos do sistema. ................................................................................ 25 Figura 5. Função de Pertinência para Distância. ...................................................................... 28 Figura 6. Função de Pertinência para Velocidade Translação.................................................. 28
Figura 7. Função de Pertinência para Velocidade Rotação. ..................................................... 29
Figura 8. Simulação da tomada de decisão ao detectar objeto. ................................................ 31
Figura 9. Fluxograma do programa. ......................................................................................... 32 Figura 10. Visão geral do veículo robô. ................................................................................... 33 Figura 11. Raios infravermelhos partindo dos sensores posicionados no veículo. .................. 35 Figura 12. Sensor infravermelho conectado ao Arduino. ......................................................... 35 Figura 13. Relação tensão e distância para objeto refletido. .................................................... 36
Figura 14. Servomotor ligado ao Arduino. ............................................................................... 39 Figura 15. Movimento servomotor em função do sinal recebido. ............................................ 40 Figura 16. Controle de um motor de corrente contínua no Arduino. ....................................... 41 Figura 17. Controle de dois motores (shield) no Arduino. ....................................................... 42
Figura 18. Visão frontal original do carrinho. .......................................................................... 43
Figura 19. Servo fixado na madeira parafusada e o isopor colado nas laterais. ....................... 44 Figura 20. Mostra a peça que segura a barra de direção fixada com um pino. ........................ 45 Figura 21. Servomotor com a sua extremidade parafusada na madeira. .................................. 45
Figura 22. Visão dos horns (peça na cor vermelha) parafusados e com os sensores colados em
cima. ................................................................................................................................. 46
Figura 23. Base de isopor montada para apoiar a protoboard. ................................................ 47 Figura 24. Visão do veículo adaptado. ..................................................................................... 47 Figura 25. Esquemático do circuito. ......................................................................................... 48
Figura 26. Regra 2 baseada na Lógica Fuzzy. .......................................................................... 50 Figura 27. Regra 5 baseada na Lógica Fuzzy. .......................................................................... 50 Figura 28. Regra 7 baseada na Lógica Fuzzy. .......................................................................... 50
Figura 29. Valores para as variáveis linguísticas referentes aos sensores de distância. ........... 52 Figura 30. Valores para a variável linguística de saída referente à velocidade. ....................... 53
Figura 31. Valores para a variável linguística de saída referente à direção. ............................ 53 Figura 32. Tela principal do FuzzyCLIPS após carregar o arquivo. ........................................ 55
Figura 33. Tela de fatos. ........................................................................................................... 56 Figura 34. Tela de Agenda. ...................................................................................................... 56 Figura 35. Detecção de obstáculos considerados distantes. ..................................................... 57
Figura 36. Fatos antes da defuzzificação. ................................................................................. 57 Figura 37. Caso 1 - Tela com resultados da saída. ................................................................... 58
Figura 38. Detecção de obstáculo próximo. ............................................................................. 59 Figura 39. Fatos antes da defuzzificação. ................................................................................. 59 Figura 40. Caso 2 - Tela com resultados da saída. ................................................................... 60
Figura 41. Detecção de obstáculo próxima à direita. ............................................................... 61 Figura 42. Fatos antes da defuzzificação. ................................................................................. 61
Figura 43. Caso 3 - Tela com resultados da saída. ................................................................... 62
viii
LISTA DE TABELAS
Tabela 1. Especificação Arduino Uno ...................................................................................... 16
Tabela 2. Exemplo de controle ................................................................................................. 25 Tabela 3. Base de Regras .......................................................................................................... 29 Tabela 4. Variáveis Linguísticas de Entrada ............................................................................ 51 Tabela 5. Variáveis Linguísticas de Saída ................................................................................ 52 Tabela 6. Projeto Base de Regras ............................................................................................. 54
ix
LISTA DE EQUAÇÕES
Equação 1 ................................................................................................................................. 37
Equação 2 ................................................................................................................................. 37 Equação 3 ................................................................................................................................. 38 Equação 4 ................................................................................................................................. 38
x
LISTA DE ABREVIATURAS E SIGLAS
A/D Analógico/Digital
CI Circuito Integrado
COG Center Of Gravity
DC Direct Current (Corrente Contínua)
DIY Do It Yourself
IR Infrared (Infravermelho)
JIRA Japan Industrial Robot Association
LED Light Emitting Diode (Diodo Emissor de Luz)
MOM Middle Of Maximum
PWM Pulse Width Modulation (Modulação por Largura de Pulso)
RIA Robot Institute of America
TCC Trabalho de Conclusão de Curso
UNIVALI Universidade do Vale do Itajaí
xi
SUMÁRIO
1 INTRODUÇÃO ...................................................................................... 1
1.1 PROBLEMATIZAÇÃO ..................................................................................... 2
1.1.1 Formulação do Problema ............................................................................... 2
1.1.2 Solução Proposta ............................................................................................. 2
1.2 OBJETIVOS ........................................................................................................ 3
1.2.1 Objetivo Geral ................................................................................................. 3
1.2.2 Objetivos Específicos ...................................................................................... 3
1.3 METODOLOGIA ............................................................................................... 3
1.4 ESTRUTURA DO TRABALHO ....................................................................... 5
2 FUNDAMENTAÇÃO TEÓRICA ........................................................ 6
2.1 BREVE HISTÓRICO SOBRE ROBÔS ........................................................... 6
2.2 DEFINIÇÕES ...................................................................................................... 7
2.2.1 Robô Móvel Autônomo ................................................................................... 8
2.3 SENSORES .......................................................................................................... 9
2.3.1 Sensores Infravermelho ................................................................................ 10
2.4 ATUADORES .................................................................................................... 11
2.5 MICROCONTROLADORES.......................................................................... 12
2.6 ARDUINO .......................................................................................................... 12
2.6.1 Alimentação ................................................................................................... 15
2.6.2 Memória ......................................................................................................... 15
2.6.3 Entrada e Saída ............................................................................................. 16
2.7 LÓGICA FUZZY ............................................................................................... 18
2.7.1 Função de Pertinência .................................................................................. 18
2.7.2 Variáveis Linguísticas ................................................................................... 19
2.7.3 Controlador Fuzzy ........................................................................................ 20
2.8 CONTROLADORES ........................................................................................ 23
2.9 TRABALHOS SIMILARES ............................................................................ 24
2.9.1 Montagem de um robô autônomo usando Lógica Fuzzy ........................... 24
2.9.2 Autonomous Robot Obstacle Avoidance using a Fuzzy Logic Control
Scheme ........................................................................................................................ 26
2.9.3 Desenvolvimento de um robô autônomo que desvia de obstáculo –
RADO – I .................................................................................................................... 30
3 DESENVOLVIMENTO ...................................................................... 33
3.1 REQUISITOS FUNCIONAIS ......................................................................... 33
3.2 FUNCIONAMENTO DO VEÍCULO AUTÔNOMO .................................... 34
3.3 PERCEPÇÃO DO AMBIENTE ...................................................................... 34
3.3.1 Funcionamento do Sensor Infravermelho .................................................. 35
3.3.2 Cálculo da Distância ..................................................................................... 37
3.4 ATUADOR SERVOMOTOR .......................................................................... 38
3.4.1 Funcionamento Servomotor ......................................................................... 39
xii
3.5 ATUADOR CC E O CONTROLADOR ......................................................... 41
3.5.1 Controlador de Motores ............................................................................... 42
3.6 ATUADOR SERVOMOTOR .......................................................................... 43
3.6.1 Montagem e Adaptação do Carrinho .......................................................... 43
3.7 MONTAGEM ELETRÔNICA ........................................................................ 48
3.8 PARTES PRINCIPAIS DO SKETCH DO VEÍCULO AUTÔNOMO ........ 49
3.9 CONTROLADOR FUZZY ............................................................................... 51
3.9.1 Variáveis Linguísticas ................................................................................... 51
3.9.2 Regras Fuzzy ................................................................................................. 53
3.9.3 Defuzzificação ................................................................................................ 54
3.10 FERRAMENTA FUZZYCLIPS ...................................................................... 54
3.10.1 Simulações ...................................................................................................... 55
3.10.2 Caso 1 ............................................................................................................. 57
3.10.3 Caso 2 ............................................................................................................. 58
3.10.4 Caso 3 ............................................................................................................. 60
4 CONCLUSÕES .................................................................................... 63
4.1 TRABALHOS FUTUROS ............................................................................... 64
APÊNDICE A. SKETCH DO VEÍCULO AUTÔNOMO .................... 70
1 INTRODUÇÃO
Com a evolução da tecnologia a exposição da vida humana frente aos perigos pode ser
minimizada com o uso de veículos autônomos. Alguns exemplos podem ser encontrados em
veículos para vigiar fronteiras, averiguar vazamentos radioativos, desarmamento de bombas e
exploração de petróleo preservando assim a vida humana.
Este trabalho faz uso de um veículo autônomo explorando o seu controle de direção e
velocidade usando para isso de conhecimentos adquiridos durante o curso de Ciência da
Computação além de outros conhecimentos que exploram áreas correlatas à Informática.
Na área da Computação o sistema para controle de direção e velocidade e a parte que
vai controlar os sensores para desvios de obstáculos, será baseado em conceitos de
inteligência artificial na área de Lógica Fuzzy.
Na área do sistema embarcado, mais especificamente a parte do hardware que envolve
os servomecanismos e sensores, os servos irão controlar a direção, atuando sobre o
mecanismo de dar direção às rodas, e os sensores irão fazer a varredura do ambiente onde o
carro irá se locomover. O controle sobre os sensores e sobre os servos será feito utilizando
uma plataforma open-source de computação física baseada em um microcontrolador a bordo
de uma placa simples, além de um ambiente de desenvolvimento multiplataforma para
escrever softwares para a placa. Esta placa pode ser utilizada para desenvolver objetos
autônomos ou iterativos (como um sistema de controle que necessita de acesso aos objetos do
mundo físico), tomando as entradas a partir de uma variedade de sensores ou switches e
controlando atuadores como LEDs, servo-motores, relés ou outros tipos de saída (BENTES,
2011).
Esta plataforma é chamada Arduino e está difundida por todo o mundo, sendo que é
utilizada por vários tipos de pessoas segundo a homepage dos desenvolvedores (ARDUINO,
2011). É uma plataforma de protótipos eletrônicos de código e hardware aberto baseada em
hardware e software flexível. Um dos fatores que influenciou na escolha desta placa é seu
valor acessível em montar ou adquirir uma placa pronta. Isto permite que os apaixonados pela
robótica ingressem nessa área sem precisar desembolsar valores exorbitantes (RODRIGO,
2011).
Outro fator para a escolha é a utilização do Arduíno em várias competições, uma das
quais é realizada pela grande varejista norte americana de componentes eletrônicos, SparkFun
Electronics a qual criou a SparkFun’s Autonomous Vehicle Competition (SPARKFUN 1,
2
2011). Neste evento uma das categorias consiste em veículos terrestres autônomos utilizando
carrinhos tendo como objetivo cruzar a linha de chegada desviando dos oponentes e/ou
obstáculos que possa ter no percurso (MAUSHAMMER, 2009).
Outra competição existente nos Estados Unidos, porém com automóveis reais
adaptados para funcionar de forma autônoma é o DARPA Urban Challenge (Desafio Urbano
DARPA). Ele é promovido pela Defense Advanced Research Projects Agency - DARPA
(Agência para Projetos de Pesquisa Avançada de Defesa), e o veículo precisa andar num
ambiente simulando as ruas de uma cidade possuindo até mesmo pedestres para chegar mais
perto da realidade (DARPA, 2007).
Além de se mostrar uma área em ascensão e que nos remete a um futuro próximo com
novos desafios, este trabalho justifica-se como Trabalho de Conclusão de Curso para o curso
de Ciência da Computação, com a intenção de desenvolver um veículo autônomo com
conceitos apreendidos na disciplina de Inteligência Artificial e a pesquisa por novos conceitos
que não fazem parte da ementa do curso, mas que com isso, tenta instigar o desenvolvimento
de outros projetos na área, como competições robóticas inexistente na universidade.
1.1 PROBLEMATIZAÇÃO
1.1.1 Formulação do Problema
Um grande problema detectado neste projeto se refere à integração hardware software.
A adaptação de um carro de controle remoto, colocando sensores, servo e a placa de controle
propriamente dita. O microcontrolador Atmega encontrado em placas da plataforma Arduino
o qual necessita de eficácia e tempo de resposta aceitável para o correto processamento dos
sensores infravermelhos para o desvio de obstáculos encontrados no percurso, além de possuir
uma característica marcante que denota a prática Do It Yourself (Faça você mesmo) que diz
respeito à capacidade de qualquer pessoa construir ou reparar algo por conta própria.
1.1.2 Solução Proposta
Analisando os problemas descritos acima, surgiu à ideia de adaptar um carrinho de
brinquedo de controle remoto para se tornar autônomo baseando-se na técnica de Inteligência
Artificial, a Lógica Fuzzy.
3
1.2 OBJETIVOS
1.2.1 Objetivo Geral
O objetivo geral deste trabalho foi construir um controlador Fuzzy, baseado na
plataforma Arduino para o controle de um Veículo Autônomo (modelo).
1.2.2 Objetivos Específicos
Foram considerados objetivos específicos para este trabalho:
Adaptação do carro modelo;
Embarcar o hardware Arduino no carro modelo utilizado;
Implementar um controlador Fuzzy para o Arduino;
Ajustar a integração dos componentes; e
Testar e avaliar o Veículo Autônomo gerado.
1.3 Metodologia
A metodologia utilizada para a realização do presente projeto foi dividida em etapas
para melhor compreensão, que estão listadas abaixo:
Fundamentação Teórica: Constituiu em pesquisar e estudar os conceitos necessários.
Fornecer uma introdução a robôs, juntamente com conceitos de robôs e robótica
móvel;
Fornecer uma introdução sobre sensores, abordando o sensor infravermelho;
Fornecer uma introdução sobre atuadores;
Fornecer uma introdução sobre microcontroladores;
Fornecer uma visão sobre conjuntos Fuzzy;
Fornecer uma breve introdução sobre controladores; e
Apresentar Trabalhos Similares.
Desenvolvimento: Como não se trata da modelagem de um software como na maioria dos
Trabalhos de Conclusão de Curso, esta etapa apresenta a modelagem usada para o trabalho
proposto.
4
Visão geral do veículo autônomo;
Requisitos Funcionais;
Funcionamento de sensores infravermelho e principalmente como é realizado o
cálculo da distância;
Fornece o funcionamento dos atuadores, abordando o servomotor e o motor de
corrente contínua bem como seu controlador; e
Fornece a etapa de montagem do veículo autônomo;
Montagem eletrônica na protoboard;
Apresenta trechos do sketch de controle; e
Fornece uma modelagem para o controlador Fuzzy.
Documentação: Ao longo do projeto foram registrados todos os processos executados
desde o levantamento do problema, a fundamentação teórica e a modelagem.
5
1.4 Estrutura do trabalho
No primeiro capítulo é apresentada uma introdução sobre o projeto, fazendo uma
descrição geral do trabalho, identificando o problema e a solução, os objetivos gerais e
específicos a serem alcançados e a metodologia utilizada.
No segundo capítulo será apresentada a Fundamentação Teórica onde são abordados
alguns conceitos sobre robô, definição e robô móvel autônomo além dos conceitos fornecidos
para sensores, atuadores, microcontroladores, conjuntos Fuzzy e controladores. Nesta etapa é
abordado três soluções similares a este projeto.
O terceiro capítulo compreende o Desenvolvimento, onde serão abordadas informações
relevantes desde a adaptação do carrinho de controle remoto a sua montagem eletrônica.
O quarto capítulo apresenta a Conclusão e um subcapítulo apresentando sugestões para
Trabalhos Futuros levantados no decorrer do desenvolvimento.
2 FUNDAMENTAÇÃO TEÓRICA
A fundamentação deste trabalho aborda os seguintes conceitos: Breve Histórico sobre
Robôs, Definição de Robô, Sensores, Atuadores, Microcontroladores, Arduino, Lógica Fuzzy
e Trabalhos Similares.
2.1 Breve Histórico sobre Robôs
Segundo Jácobo (2001), desde o período do antigo Egito, aproximadamente 3000 A.C,
o homem buscou formas de auxílio em seu trabalho. Neste período foram construídos relógio
de água para orientar o homem no tempo e figuras articuladas usadas em peça de teatro.
Segundo Jácobo (2001), ao longo do período da Revolução Industrial iniciada na
Inglaterra a partir do século XVIII onde trouxe como fator sociológico o surgimento das
fábricas, o qual resultou na divisão de três fases da revolução. A terceira fase a qual está em
processo até os dias de hoje foi pensada como saída econômica da grande crise do Petróleo,
onde no período é inserida a robotização do processo produtivo.
No século XX o primeiro a utilizar a palavra “robô” (robota) foi o teatrólogo tcheco
Karel Capek na sua publicação “Os Robôs Universais de Roussum”, cujo significado é
servidão ou trabalho forçado (JÁCOBO, 2001).
A partir da Revolução Industrial, foram empregados vários esforços no sentido de
criar mecanismos que aumentasse a produtividade humana, em outras palavras, mecanismos
que façam pelo homem os trabalhos rotineiros, pesados, cansativos e porque não
considerarmos como trabalhos entediantes (BERTO, 2007).
No início desenvolver estes mecanismos foi difícil. Ao longo dos anos, com a
crescente evolução surgiram os computadores digitais o qual trouxe avanços significativos, o
que fez com que inúmeras aplicações fizessem com que mais recursos fossem voltados a área
despertando assim o grande interesse dos pesquisadores (BERTO, 2007).
Segundo Berto (2007), ultimamente, além das pesquisas na área tecnológica onde
geralmente são desenvolvidos robôs para auxiliar os trabalhadores nos mais variados setores
de uma indústria torna-se primordial em diversas tarefas realizadas pelos humanos, facilitando
seu trabalho e garantindo um aumento significativo em sua produtividade tornando a relação
custo/benefício atraente a indústria.
Os robôs foram classificados conforme seu surgimento tal como ocorreu com os
computadores:
7
Primeira Geração - Robôs Manipuladores: Inaugurando a geração da robótica
industrial Joseph Engelberger cria na década de 60 o Unimate, um braço robô para
auxílio na linha de montagem da General Motors executando tarefas desagradáveis
para seres humanos (UNIMATE, 1961 apud ROTTAVA DA SILVA, 2003).
Segunda Geração - Robôs Móveis: São robôs mais sofisticados capaz de se locomover
no ambiente com obstáculos parcialmente conhecidos como é o caso do robô Hilare
criado nos laboratórios de Toulouse na França equipado com sensores ultrassônicos e
telemetria laser, (HILARE, 1977 apud HEINEN, 2002).
Terceira Geração - Robôs Inteligentes: São robôs capazes de se adaptar ás
modificações do ambiente mediante sistemas de controle, percepção, comunicação e
decisão sendo capazes de “interagir” com o meio ambiente para a realização da tarefa
(HALFPAP; CORRÊA DE SOUZA; ALVES, 2007).
Segundo Jácobo (2001) a Terceira Geração é considerada pela maioria dos autores os
robôs que são capazes de operar de forma autônoma num ambiente hostil possuindo assim a
seguinte divisão como referência: Robôs Autônomos, Robôs Autônomos Inteligentes e Robôs
Móveis Autônomos. Hoje esta geração de robôs é dedicada a fazer tarefas especializadas em
ambientes desestruturados.
Segundo Berto (2007) os robôs móveis apresentam basicamente três formas de
locomoção, podendo usar somente uma ou também uma versão híbrida dessas configurações.
Estas formas são: dispositivo articulado de rotação (rodas), corpos articulados e pernas, para
determinar a forma de locomoção do robô devem ser levantados a sua finalidade, o tipo de
terreno em que vai atuar, a fonte de alimentação e sua autonomia.
2.2 Definições
Abaixo serão apresentadas definições sobre robô pela JIRA (Japan Industrial Robot
Association) e a RIA (Robot Institute of America).
Definição da JIRA: O robô é definido como um sistema mecânico que possui
movimentos flexíveis análogos aos movimentos orgânicos, e combina esses
8
movimentos com funções inteligentes e ações semelhantes as do humano. Neste
contexto, função inteligente significa o seguinte: decisão, reconhecimento, adaptação
ou aprendizagem (BERTO, 2007).
Definição do RIA: O robô é definido como um dispositivo mecânico programável para
execução de algumas tarefas de manipulação ou locomoção sob controle automático.
Robô industrial é um manipulador multifuncional e reprogramável projetado para
movimentar materiais, peças e ferramentas ou dispositivos especiais, conforme
programação prévia, de modo a executar uma variedade de tarefas (BERTO, 2007).
2.2.1 Robô Móvel Autônomo
Muir (1988, apud SILVA 2008) define um robô móvel como “um robô capaz de se
locomover sobre uma superfície somente através da atuação de rodas montadas no robô e em
contato com a superfície”. As rodas permitem um deslocamento relativo entre o seu eixo e a
superfície sobre o qual se espera ter um único ponto de contato com rolamento puro.
Segundo Silva (2008) um robô móvel atual possui sensores como câmera (visão),
infravermelho, sonar, tato, toque, sistemas de navegação inercial, etc. Estes sensores auxiliam
o robô na percepção do ambiente possuindo certo grau de “conhecimento” sobre o meio em
que atua, possuem sistemas de controle muitas vezes tão sofisticados que apoiam na
capacidade de decisão permitindo que se cumpra uma tarefa de forma parcial ou totalmente
autônoma.
De acordo com Silva Oliveira (2008) na presença de tais sensores permite ao robô
fazer uso da interação com o meio, auxiliando na percepção e até mesmo permitindo construir
o modelo do local onde está inserido, juntamente com os movimentos desenvolvidos,
facilitando na tomada de decisão de ações pertinente a tarefa.
Segundo Jácobo (2001) a estratégia de decisão e percepção pode ser considerada de
três formas:
Estratégia reativa: o comportamento do robô depende dos estímulos gerados pela
reação provenientes da leitura dos sensores no ambiente;
Estratégia deliberada: as informações do ambiente são previamente processadas e a
tarefa e o comportamento do robô são da mesma forma, previamente determinadas; e
Estratégia híbrida: junção das estratégias anteriores.
9
O veículo proposto neste trabalho enquadra-se na estratégia reativa e sua categoria
pertence à de Robô Móvel Autônomo, dado suas características que será montado em uma
plataforma com rodas permitindo se mover de forma autônoma “percebendo” o ambiente, lido
com auxilio de sensores posicionados na parte da frente do veículo.
2.3 Sensores
Falar de robótica sem ao menos citar os sensores é algo praticamente impossível no
meio robótico, será abordado uma introdução sobre esses dispositivos e sobre sensores
infravermelhos, em específico os mesmos utilizados nesse trabalho.
Segundo NETO; LUCENA; BERGAMIN (2003) sensores são dispositivos que
mudam seu estado sob a incidência de alguma grandeza física tornando capaz de “perceber”
as alterações e assim convertendo em sinais elétricos. Estes sensores vão dos mais simples,
tais como interruptor de limites, quanto aos mais sofisticados, como sistemas de visão de
máquina. (SOUZA FILHO, 2009). Estes dispositivos na robótica de forma geral podem ser
classificados em:
Sensores de tato: São sensores que reagem aos estímulos exercidos à força de contato
com outro objeto. Alguns desses dispositivos são sofisticados o bastante a ponto de
permitir medir o nível da força aplicado;
Sensores de proximidade e distância: Sensores de proximidade indicam quando um
objeto está próximo, porém antes que o contato se realize, já quando a distância pode
ser detectada o dispositivo é chamado de sensor de alcance;
Sensores de tipos diversos: Esta categoria incluem os outros tipos de dispositivos
usados na robótica, tais como, de pressão, temperatura, de gases entre outros
fenômenos; e
Sensores de visão de máquina: Sistema de visão de máquina é capaz de visualizar o
ambiente de forma a extrair informações e com isso conseguir se orientar. Esses
sistemas são utilizados na robótica para diversas tarefas das quais podemos citar a
realização de inspeções, reconhecimentos de peça entre outras tarefas similares.
10
Com uma variedade desses tipos de sensores disponível no mercado e a um preço
acessível, hoje praticamente qualquer projeto robótico se utiliza desses dispositivos para
“perceber” o ambiente e atuar sob o mesmo.
2.3.1 Sensores Infravermelho
Segundo Bressiani et al (2006), sensores infravermelhos são dispositivos que
funcionam geralmente por variação de tensão ou corrente para detecção da distância do objeto
(obstáculo) ou detecção por interrupção, onde são emitidas ondas infravermelhas invisíveis ao
olho humano.
Estes sensores podem ser divididos basicamente em dois grupos principais: os
passivos e os ativos. Os passivos são caracterizados por não possuir o componente emissor
infravermelho, possuindo apenas o componente receptor, “percebendo” apenas a
movimentação em seu local de atuação, já os ativos são caracterizados por possuir um
emissor, o qual envia ondas infravermelhas e o receptor que capta essa onda emitida, esses
por sua vez subdividem-se de acordo com seu funcionamento em três grupos principais, sendo
os sistemas por barreira, difusão e reflexão (BRESSIANI et al, 2006):
Sistemas por barreira: no sistema por barreira de irradiação infravermelha o
emissor é alinhado de forma a posicionar de frente a um receptor
infravermelho em uma distância pré-determinada de acordo com cada tipo de
sensor, sendo detectado quando houver uma interrupção entre o emissor e o
receptor;
Sistemas por difusão: nestes sistemas os raios infravermelhos são emitidos
diretamente no objeto pelo emissor retornando um feixe de luz ao receptor que
por sua vez conseguirá calcular a distância de acordo com tempo de resposta
entre a emissão e recepção; e
Sistemas por reflexão: em sistemas por reflexão os raios infravermelhos são
emitidos em direção a um espelho prismático, quando houver uma interrupção
dos raios infravermelho com alguma barreira (objeto) ou o espelho for retirado,
11
com isso é possível detectar a obstrução sendo que o receptor não receberá
mais o sinal.
Ainda Bressiani et al (2006) cita que os sistemas por difusão e reflexão caracterizam
por seus emissores e receptores estarem juntos no mesmo invólucro.
O veículo autônomo a ser desenvolvido utiliza sensores de distância infravermelhos
ativos por difusão, o qual foi escolhido o tipo de longo alcance que possui um perímetro de
atuação adequado para este trabalho. Esses sensores por sua vez alimentarão o sistema de
controle Fuzzy permitindo atuar no meio, seja controlando sua velocidade, e/ou determinar
seu ângulo de direção evitando assim os obstáculos a sua frente.
2.4 Atuadores
Outro dispositivo imprescindível na robótica são os atuadores que trabalham em conjunto
com sensores e o sistema de controle. Os atuadores são dispositivos que fornecem a força
motriz efetiva para as juntas do robô (SOUZA FILHO, 2009). Em outras palavras, são
dispositivos que permitem o robô executar a ação proveniente do processamento de seu
sistema de controle resultando em movimentos como: mover-se a frente, virar a direita, virar a
esquerda, etc. Geralmente sua força vem de algum dos três tipos de fontes: ar comprimido,
fluído sob pressão ou eletricidade, respectivamente atuadores pneumáticos, hidráulicos ou
elétricos (SOUZA FILHO, 2009):
Atuadores pneumáticos e hidráulicos: Esses tipos de atuadores funcionam pelo
movimento dos fluídos e são amplamente utilizados na indústria (RICARDO DA
SILVA, 2008). Nos pneumáticos, o fluído é o ar comprimido, nos hidráulicos o fluído
é geralmente óleo pressurizado (SOUZA FILHO, 2009).
Atuadores elétricos: Esse tipo de atuador é cada vez mais adotado em projetos de
robótica devido a suas características crescentes de evolução. O atuador elétrico
funciona empregando energia elétrica para gerar movimento (COELHO, 2010). Esses
dispositivos permitem realizar suas tarefas com um grau satisfatório de controle e com
o mínimo de manutenção. Na robótica existe uma grande variedade desses tipos de
atuadores, contudo os mais comuns encontrados nos robôs são os motores de passo e
os servomotores (SOUZA FILHO, 2009).
12
2.5 Microcontroladores
Nos dias de hoje é comum estarmos rodeados de aparelhos que usam
microcontroladores, porém não nos damos conta onde são encontrados. Esses “cérebros” de
tamanho diminuto, porém com grande poder de controle, são comumente encontrados em
aparelhos como micro-ondas, televisores, smartphones, automóveis e na robótica (PALPITE
DIGITAL, 2007).
Microcontroladores são circuitos integrados programáveis que possui arquitetura de
um microcomputador, porém baseado numa arquitetura RISC (Reduced Instruction Set
Computing) como a própria tradução sugere, conjunto de instruções de computação reduzida,
os microcontroladores possuem basicamente três características que fazem sucesso na
indústria, são eles: tamanho reduzido, preço acessível e menor consumo de energia
(ROBÓTICA LIVRE, 2011).
Nos microcontroladores Atmega da fabricante Atmel utilizados pelo Arduino, o qual
neste trabalho será usado o modelo Uno que embarca um microcontrolador ATmega328,
possui basicamente a CPU (Central Processing Unit), memórias (RAM, ROM, EEPROM),
pino digitais de entrada e saída, pinos analógicos, pinos PWM (Pulse Width Module),
conversor de sinal analógico/digital, etc (ARDUINO, 2011).
2.6 Arduino
Segundo Werneck (2009) a plataforma Arduino busca atingir um grande número de
pessoas, entusiastas de eletrônica ou hobbystas para desenvolver projetos com qualidade,
porém de uma forma fácil e de valor acessível. Essa plataforma beneficia um grande número
de pessoas, com conhecimento em programação, mas sem conhecimento em eletrônica, que
podem realizar experimentos num equipamento prático. Também as pessoas que tem
conhecimento em eletrônica, mas não conhecem programação podem realizar experimentos
de alto nível. Esta plataforma procura atingir os leigos que tem o desejo de criar algo e podem
chegar a experimentos funcionais com facilidade, partindo do zero.
Segundo Werneck (2009), existe outras plataformas de microcontroladores criadas
com o mesmo objetivo, mas não mantendo o foco em características como facilidade de uso e
preço acessível como o Arduino.
13
Arduino é uma plataforma de computação física open-source baseado em uma simples
placa com entradas e saídas e um ambiente de desenvolvimento que implementa a linguagem
Processing/Wiring. Este ambiente de desenvolvimento é multiplataforma podendo criar as
rotinas para Windows, Linux e Mac OS X. Sua linguagem de programação se assemelha
bastante com a linguagem C++, porém o Arduino segue uma forma simplificada (ARDUINO,
2011). Um programa típico no Arduino consiste basicamente em duas funções, o “void
setup()” que executa toda vez que o Arduino é ligado ou reiniciado, e a função “void loop()”
que conforme o nome sugere é uma rotina de loop realizando sua execução de forma repetida
no microcontrolador, essas funções formam a estrutura básica de um programa Arduino,
existem inúmeras outras que fazem a leitura/escrita dos pinos digitais e analógicos (GIOPPO
et al, 2009).
A plataforma Arduino pode ser utilizada para desenvolver objetos autônomos ou
iterativos (como um sistema de controle que necessita de acesso aos objetos do mundo físico),
tomando as entradas a partir de uma variedade de sensores ou switches e controlando
atuadores como LEDs, servomotores, relés ou outros tipos de saída (BENTES, 2011).
Atualmente a plataforma Arduino esta difundida por todo o mundo, sendo que esta é
utilizada por vários tipos de pessoas segundo a Homepage (ARDUINO, 2011). É destinado a
artistas, designers, hobbistas, e qualquer pessoa interessada em criar objetos ou ambientes
interativos. Um dos fatores que assegurou o sucesso do Arduino deve-se ao valor acessível em
montar ou adquirir uma placa pronta, permitindo que os admiradores da robótica ingressassem
nessa área de forma facilitada não desembolsando valores exorbitantes como outras soluções
existentes no mercado (RODRIGO, 2011).
Por se tratar de hardware e software livre existem inúmeros tipos de placas disponíveis
no mercado bem como seus esquemas eletrônicos para quem tem noções de eletrônica consiga
construir sua própria placa de forma a reduzir ainda mais seu custo, ou poder optar por
comprar uma placa já montada, pronta (ARDUINO, 2011).
Abaixo seguem uma lista com algumas plataformas Arduino:
Arduino Uno: Placa baseada no ATmega328, contêm tudo que precisa para
suportar este microcontrolador, simplesmente plugue no USB ou alguma fonte
12v para começar.
LilyPad Arduino: Uma placa circular enxuta, projetada para ser costurada em
roupas ou outras aplicações que envolvem tecido.
14
Arduino Nano: É uma placa pequena, completa e amigável baseada
originalmente no ATmega168, possuindo semelhanças ao Arduino
Duemilanove.
Arduino Diecimila: Placa Arduino baseada no microcontrolador ATmega168,
possui metade dos recursos de memória flash, SRAM e EEPROM comparado
ao Arduino Uno.
Arduino Mini: Placa Arduino baseada originalmente nas especificações do
microcontrolador ATmega168, porém suporta somente 9v de corrente de
entrada.
Arduino BT: Placa Arduino baseado nas especificações do microcontrolador
ATmega328 com a diferença de possuir em seu circuito um módulo bluetooth
integrado.
Arduino Duemilanove: Placa Arduino lançada em 2009 é baseada no
microcontrolador ATmega168.
Como é possível notar existem várias soluções de placas Arduino, cada uma com suas
características específicas servindo a propósitos diferentes. Anteriormente, foram mostradas
apenas alguns modelos de placas, nos focaremos em características do Arduino Uno o qual
será usado nesse projeto. Esta placa foi selecionada por simplesmente ser a mais atual no
momento, possui características semelhantes à placa de geração anterior a Duemilanove e
facilmente são encontrados sketchs (programas escritos no ambiente de programação do
Arduino) compatíveis com esta versão. Na Figura 1 é apresentada a placa Arduino com as
descrições dos componentes que a mesma possui, desde a alimentação aos pinos de entrada e
saída. Nas subseções abaixo serão apresentada maiores detalhes da placa.
15
Figura 1. Visão frontal Arduino Uno.
Fonte: (ARDUINO, 2011).
2.6.1 Alimentação
De acordo com Arduino (2011), a placa Uno pode ser alimentada tanto pela porta USB
(USB Plug) quanto por uma fonte externa de alimentação (External Power Suply), sendo feito
uma seleção automática do tipo de alimentação. A alimentação externa pode ser feita de duas
formas, através de bateria ou adaptador AC-DC.
Segundo Arduino (2011), na alimentação com fonte externa a placa pode suportar de 6
a 20 volts, porém recomenda-se uma alimentação entre 7 e 12 volts, para evitar instabilidade
na placa ao fornecer menos energia e evitar queimar o dispositivo fornecendo energia acima
do recomendado.
2.6.2 Memória
Segundo Arduino (2011), o microcontrolador ATmega328 usado pelo Arduino Uno
possui 32 KB de memória, reservando desse total 0,5 KB para o bootloader (gerenciador de
boot ou pequeno software instalado no microcontrolador responsável por gerenciar a
execução dos programas em determinados ciclos de tempo), possui também 2 KB de SRAM e
1 KB de memória EEPROM, esta última pode ser manipulada usando a biblioteca de mesmo
nome.
16
A pouca capacidade de memória disponível para gravar os sketchs é notável, porém
sua limitação, quando necessário, pode ser resolvida estendendo sua capacidade de
armazenamento com uso de uma Shield de MicroSD.
2.6.3 Entrada e Saída
De acordo com Arduino (2011), o modelo Uno possui 14 pinos digitais podendo ser de
entrada ou saída bastando definir na função “void setup()” do programa a que se destina o
pino, dentre esses pinos o Arduino possui 6 entradas analógicas nomeados de A0 a A5,
possuindo também alguns pinos com funções especificas, como exemplo o pino 13 do LED
(Light Emitting Diode, ou, diodo emissor de luz).
O Arduino possui pinos para entrada e saída digital e para entrada analógica
permitindo um número considerável de possibilidades de controle para prototipagem rápida e
de valor aceitável. Deste total 6 destes pinos podem ser usados como saídas PWM (Pulse
Width Modulation).
Segundo o site oficial (ARDUINO, 2011) PWM ou modulação de largura de pulso
consiste em uma técnica para ter resultados analógicos com significado digital. O controle
digital é usado para criar uma onda quadrada, variando o sinal entre o ligado e desligado. Este
padrão de ligado-desligado pode simular voltagens completas entre 5 e 0 volts, obtida através
da mudança da porção do tempo gasta no sinal de ligado versus o tempo gasto no sinal de
desligado. A duração desse "tempo" é chamada de largura de pulso. Para obter essa variação
de valores analógicos, você muda, ou modula, a largura de pulso. Se você repetir este padrão
entre o ligado e desligado suficientemente rápido com um LED, por exemplo, o resultado é
como se o sinal variasse a voltagem entre 0 e 5 volts controlando o brilho do LED. Na Tabela
1 é apresentada a especificação para a placa Arduino Uno:
Tabela 1. Especificação Arduino Uno
Fonte: adaptado de (ARDUINO, 2011)
Características Descrição
Microcontrolador ATmega328
Tensão de funcionamento 5V
Tensão de entrada
(recomendado)
7-12V
Tensão de entrada (limites) 6-20V
Pinos de E/S digitais 14 (dos quais 6 são saída PWM)
Pinos de entrada analógica 6
17
Corrente DC por pino de E/S 40 mA
Corrente DC para pino 3.3V 50 mA
Memória Flash 32 KB (ATmega328), dos quais 0,5 são utilizado pelo
gerenciador de boot
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega 328)
Clock 16MHz
O Arduino possui uma comunidade ativa que trabalha em sua evolução agregando
novas funcionalidades ao projeto. Comumente são encontrados dispositivos que se encaixam
na placa Arduino de forma a permitir novas possibilidades e facilitar a vida dos projetistas em
seus protótipos. Esses dispositivos são chamados de Shields, abrem novos horizontes aos
desenvolvedores agregando novas funcionalidades ao Arduino.
Existe inúmeros Shields criado para usar em conjunto com o Arduino, os mais comuns
são: (SPARKFUN, 2011).
Ethernet: Permite que um Arduino seja conectado a internet utilizando uma
biblioteca de rede que suporta tanto TCP (Transmission Control Protocol)
como UDP (User Datagram Protocol);
Kit Joystick: Permite dotar o Arduino com um joystick se encaixando sobre o
mesmo transformando em um controle simples, contando com 4 botões e 1 de
seleção do joystick, as possibilidades são inúmeras com este shield;
MicroSD: Este permite ampliar a capacidade de memória usada pelo projeto ou
pode funcionar como registrador de logs onde se queira gravar determinas
informações, como exemplo a leitura de um sensor;
Ardumoto: Este permite ao Arduino controlar dois motores de corrente
contínua (DC), agilizando projetos de robótica que envolve este tipo de
controle; e
Wifly: Este shield permite ao Arduino conectar a redes sem fio (Wireless)
usando o protocolo 802.11 b/g, facilitando os projetos que envolvem conexão
sem fio.
18
2.7 Lógica Fuzzy
A Lógica Fuzzy ou Lógica Nebulosa é baseada na teoria dos conjuntos, diferente da
Lógica Clássica onde se tem valores totalmente verdadeiros ou totalmente falsos. Ela é capaz
de atribuir valores intermediários entre 0 (zero) e 1 (um) o que leva a ser parcialmente
verdadeira ou parcialmente falsa.
Esta Lógica trata de um raciocínio que busca classificar em números uma determinada
realidade ou situação, que trabalha com muitas variáveis incertas e vagas, a fim de facilitar o
trabalho ou manipulação dos computadores (KOHAGURA, 2007). A Lógica Fuzzy é
considerada imprecisa, pois trabalha com aproximações de dados vagos (KOHAGURA,
2007). Através de uma determinada regra, que varia para qual fim a Lógica Fuzzy é utilizada,
os dados coletados caracterizados como incertos são analisados de acordo com a regra
implementada e aproximados por números para possibilitar a interpretação das máquinas e
computadores.
Segundo Kohagura (2007), os conceitos dos conjuntos da Lógica Fuzzy foram criados
pelo professor da Universidade da Califórnia em Berkeley Lofti Asker Zadeh a partir de 1965
para tratar do aspecto impreciso da informação. A proposta de Zadeh trata os valores
intermediários que existem ao longo do 0 (zero) e 1 (um) definindo assim um “grau de
pertinência” (usado pela Função de Pertinência) para que a mudança entre o pertinente e ou
não pertinente dos elementos de um conjunto ocorra de forma gradual e não de forma brusca
como na Lógica Clássica.
2.7.1 Função de Pertinência
Segundo Cruz (2009) a função que define o grau de pertinência de um elemento em
um determinado conjunto Fuzzy denomina-se Função de Pertinência ou Função de
Associação, estes elementos podem pertencer a vários conjuntos com determinado grau de
pertinência.
O grau de pertinência não está definido num modelo formal dos conjuntos Fuzzy, esse
se dá através de testes realizados para encontrar a melhor função que se adeque a situação a
qual se queira aplicar, permitindo que especifiquemos os possíveis valores para um
determinado conjunto.
19
Formalmente, um conjunto Fuzzy A do universo de discurso U é definido por uma
função de pertinência µA: U → [0, 1]. Essa função associa cada elemento de x em U o grau
µA (x) com o qual x pertence a A. A função de pertinência µA (x) indica o grau de quão
compatível x é no conjunto expresso por A.
2.7.2 Variáveis Linguísticas
Segundo Barros e Bassanezi (2006) uma variável linguística x no Universo U é uma
variável cujos valores assumidos por ela são subconjuntos Fuzzy de U.
Segundo Barros e Bassanezi (2006) define uma variável linguística como sendo uma
representação de uma classe de palavra enquanto seus valores são adjetivos o qual são os
possíveis valores permitidos para a variável. Tomemos “como exemplo a variável
“velocidade” a qual pode assumir os valores “devagar”, “média” ou rápida”.
Segundo Zimmermann (1991, apud Cruz 2009), formalmente uma variável linguística
está formada pela quíntupla {X, T(X), U, G, M} onde a definição para cada elemento segue
abaixo:
X = Nome do conjunto para a variável linguística.
T(X) = Conjunto de termos linguísticos sendo os adjetivos e/ou atributos.
U = Universo de discurso apresentando a faixa de valores.
G = Regra sintática para composição dos termos linguísticos.
M = Regra semântica que associa cada termo linguístico de G a um conjunto Fuzzy.
Um exemplo segue abaixo usando a definição acima aplicando aos valores para a
quíntupla.
X: Velocidade;
T(Velocidade): {Devagar, Média, Rápida};
U: [0,1];
G: Devagar [X: 0,0 a 0,5]; Média [X: 0,3 a 0,7]; Rápida [X: 0,7 a 1,0];
M: µDevagar, µMedia, µRapida;
20
2.7.3 Controlador Fuzzy
Um controlador Fuzzy é basicamente o processo de inferência em conjuntos Fuzzy.
Neste processo basicamente estão envolvidos a etapa de fuzzificação, máquina de inferência
(inferindo na base de regras) e defuzzificação (ENOMOTO, 2010), conforme exemplifica
Figura 3.
Figura 2. Controlador Fuzzy.
Fonte: adaptado de Tarig (2001).
2.7.3.1 Fuzzificação
Segundo Cruz (2009) neste processo são utilizadas às funções de pertinência para
mapear os valores de entradas numéricas em representações linguísticas dos conjuntos Fuzzy,
esta etapa também executa a adequação dos dados de entrada reais para manipulação da
máquina de inferência. Essas funções de pertinência podem ser definidas por intermédio das
funções como: Gaussianas, Singletons, Sigmoides, porém as mais usadas são Triangulares
e/ou Trapezoidais, essas últimas demonstradas na Figura 3.
21
Figura 3. Classificação para variável linguística distância.
Fonte: (CRUZ, 2009).
2.7.3.2 Base de Regras
Segundo Barros e Bassanezi (2006) a base de regras Fuzzy consiste em proposições
formadas por uma coleção de regras SE-ENTÃO, tendo o formato abaixo:
SE “condição” ENTÃO “ação”
Nas proposições Fuzzy cada condição (antecedentes) e cada ação (consequentes) são
valores assumidos por variáveis linguísticas os quais são modelados por conjuntos Fuzzy
(BARROS; BASSANEZI, 2006).
Segundo Cruz (2009) após o processamento das regras pela máquina de inferência, é
realizado a saída, definida no processo de deffuzificação.
2.7.3.3 Máquina de Inferência
Processa os valores de entrada (fuzzificação), junto com as regras, de modo a inferir as
ações de controle Fuzzy, aplicando o operador de implicação Fuzzy e as regras de inferência
da Lógica Fuzzy.
Segundo Barros e Bassanezi (2006) é nessa etapa que cada proposição é traduzida
“matematicamente” por meio das técnicas da Lógica Fuzzy. Essa etapa fornecerá a saída
(controle) Fuzzy a ser adotado pelo controlador. A partir da entrada de cada conjunto Fuzzy.
22
Nesse processo pode-se citar os modelos de inferência Mandani e Kang-Takagi-Sugeno ou
KTS.
2.7.3.4 Deffuzzificador
Segundo Barros e Bassanezi (2006) o processo de defuzzificação é a representação de
valores do conjunto Fuzzy para valores reais (crisp). Neste processo ao utilizarmos um
modelo linguístico, a saída Fuzzy é gerada pela composição das regras do algoritmo de
inferência (MARTINS, 2007) usando métodos específicos.
Segundo Martins (2007) este processo consiste em converter valores do conjunto
Fuzzy para valores reais através de métodos específicos. Existem vários métodos para o
processo de defuzzificação cada um possuindo suas vantagens e desvantagens, os mais
utilizados são Máximo, Média dos Máximos e Centróide:
Máximo: extrai o valor máximo do conjunto de saída. Este não possui um bom
funcionamento quanto a saídas com intervalo;
Média dos máximos: extrai a média entre os valores máximos do conjunto de
saída. Nesse método a falha ocorre ao atingir o limite superior do valor máximo do
conjunto de saída e também quando a média é exatamente um valor que possui
grau de pertinência zero; e
Centróide: extrai o centro de gravidade do conjunto. Este requer um maior poder
computacional para obter o valor preciso, por isso nem sempre é o mais indicado.
Segundo Cruz (2009) a base de conhecimento Fuzzy necessita ser completa e
consistente, garantindo que sempre haverá uma regra que satisfaça qualquer entrada e que seja
única evitando ambiguidades.
Para a modelagem será utilizada a ferramenta shell FuzzyCLIPS, esta shell é uma
extensão da ferramenta CLIPS usada para o desenvolvimento de Sistemas Especialistas
baseada em Lógica Fuzzy desenvolvido pela Integrated Reasoning Group do Institute for
Information Technology da National Research Council of Canada bastante difundido e com
aceitação no meio acadêmico.
23
2.8 Controladores
Um sistema de controle é basicamente um sistema de entradas e saídas. O sistema a
ser controlado é, em geral, chamado de processo ou planta.
Segundo Matias (2008), existem basicamente dois tipos de natureza de controle: os
auto-operados e os dependente de alguma fonte de energia externa. Nos modelos auto-
operados pode citar o controle mais simples criado com uso nos dias atuais garantindo uma
ótima eficácia, são as bóias de caixa d’água de nossas residências usada para o controle de
fluxo da água no reservatório evitando transbordar. Já os sistemas de fonte de energia externa
podem ser controlados de forma pneumática, hidráulica e elétrica ou eletrônica. Essas formas
de controle são utilizados no controle de grandeza de tipo vazão, temperatura, pressão,
velocidade, nível, posição, etc.
Segundo Souza Filho (2009), esses controladores tem por objetivo reduzir o erro à
zero ou próximo a isto, bastando gerar um sinal de controle. O controle é realizando
comparando o valor desejado, ou comando de entrada com o valor do processo ou saída
efetiva da planta. Basicamente existem quatro tipos de controle usados de forma individual ou
de forma híbrida, resultando num total de seis tipos de controle garantindo maior precisão na
planta a qual deseja controlar. Esses controles podem ser de liga-desliga, controle
proporcional, controle integral e controle derivativo:
Controle liga-desliga: conhecido também como controle on-off ou de “duas posições”
permite apenas dois níveis de controle, o totalmente ligado ou totalmente desligado
(MATIAS, 2008);
Controle proporcional: este tipo de controlador é utilizado em casos que requerem um
nível de controle mais suave daqueles fornecido pelo tipo liga-desliga realizado de
forma linear resultando em um movimento proporcional de acordo com a posição do
elemento controlador (MATIAS, 2008); e
Controle integral e derivativo: esses controladores são usados de forma não linear
aplicando alguma função matemática para uma maior precisão do elemento
controlador.
24
2.9 Trabalhos Similares
Nesta seção serão apresentados trabalhos similares que se mostraram relevantes ao
projeto, visando facilitar o entendimento analisando a suas dificuldades e extrair possíveis
soluções para os problemas encontrados ao longo do desenvolvimento deste projeto.
2.9.1 Montagem de um robô autônomo usando Lógica Fuzzy
Reis (2010), mostra a montagem e programação de um robô que age de diferentes
maneiras de acordo com o ambiente o qual está inserido. No projeto foi utilizada uma placa
Axon, uma ponte H, dois motores, sensores de distância por infravermelho e sensores de luz.
Na etapa de montagem do robô, o movimento se dá por seus dois motores (atuadores)
de corrente continua que no caso é controlado por uma ponte H o qual controla sua velocidade
e sentido horário e anti-horário, sendo o sentido tratado com o modulador de largura de pulso
(PWM), para a “percepção” do local são utilizados os sensores de distância por infravermelho
e de luz, já todo o processamento adquirido da leitura dos sensores serão feitos usando a placa
Axon.
Os sensores “sentem” o ambiente através de suas portas analógicas, os quais serão
enviados a um computador que irá submeter à máquina de inferência Fuzzy que retornará um
valor de velocidade a serem aplicados nos motores, em seguida entra em cena o
microcontrolador Axon interpretando as informações enviando assim um sinal PWM para o
circuito controlador dos motores (L298) que será por fim retransmitido aos motores. Na
Figura 4 é apresentado o diagrama de blocos da interligação do sistema.
25
Figura 4. Diagrama de blocos do sistema.
Fonte: (REIS; SARMENTO; ZARAMELLA, 2010).
A comunicação estabelecida entre o computador e placa Axon foi realizada através de
um cabo USB através de um conversor UART/USB, portanto essa conexão é vista como uma
porta COM no computador.
Na conversão A/D da tensão nos pinos ADC da placa Axon, a biblioteca Webbot
usada para suporte a robôs de alguns modelos de microcontroladores da família Atmega
retorna 1 byte de informação para cada sensor, portanto no microcontrolador são obtidos
quatro bytes, sendo dois referente aos sensores LDR e dois aos sensores infravermelho. Esses
bytes são enviados pelo cabo USB ao computador o qual processará usando a máquina de
inferência Fuzzy retornando um byte para a placa Axon. Esse byte possui a informação
referente a velocidade das rodas. O byte tem a seguinte construção do bit mais significativo: 1
bit para o sentido da roda esquerda + 1 bit para o sentido da roda direita + 3 bits para a
velocidade da roda esquerda de 0 a 7 + 3 bits de velocidade para a roda direita. Como
exemplos temos o byte 10110010 o qual o robô fará uma curva rápida para a direita
demonstrado por partes sua formação abaixo de acordo com Tabela 02.
Tabela 2. Exemplo de controle
Sinal de controle Operação
1 Roda esquerda para frente
0 Roda direita para trás
110 Nível 6 de velocidade para roda esquerda
26
010 Nível 2 de velocidade para roda direita
Fonte: (REIS; SARMENTO; ZARAMELLA, 2010).
Para um conjunto de variações adequado de velocidade os acadêmicos utilizaram os 8
valores retornados pelo Fuzzy, o controle de velocidade dos motores é obtido através da
biblioteca Webbot a qual define por exemplo valores zero para os motores não sendo ativados
e quando um dos motores é 7 é utilizando 85% da velocidade máxima do motor, este
percentual segundo os autores são para facilitar os testes.
Para os comportamentos Fuzzy que definem o estado do robô os acadêmicos
propuseram os estados: calmo, com medo e o curioso. Na situação onde o comportamento
ativado é o calmo o robô fica parado, o estado de medo o robô foge de uma fonte luminosa e
de objetos próximos, já para o estado de curioso é o inverso ao estado de medo, onde segue
um objeto próximo ou uma fonte luminosa. Com o emprego da Lógica Fuzzy os
comportamentos podem se sobrepor, como exemplo pode ter um robô mais curioso que
calmo, neste caso ele seguirá a luz ou um objeto próximo mas não com tanta intensidade,
como se fosse somente o estado de curioso.
2.9.2 Autonomous Robot Obstacle Avoidance using a Fuzzy Logic Control
Scheme
Neste projeto, William Martin da Middlebury College propôs um robô autônomo que
evita obstáculos usando um esquema de Lógica Fuzzy e o Arduino Duemilanove para o
controle.
O acadêmico utilizou um veículo tank de brinquedo retirando todos os componentes
internos mantendo somente os dois motores de corrente contínua para atuar em sua esteira
realizando o movimento (MARTIN, 2009).
No projeto foram utilizados três sensores de distância por infravermelho com um
limite de detecção de 10 a 80 cm para as medições. Para obter três diferentes medidas em
ângulos de 45 graus sendo um sensor à direita, um no meio e outro a esquerda garantindo
assim uma maior precisão para o controle do robô (MARTIN, 2009).
Para controlar a velocidade de cada motor, o PWM (Pulse Width Modulation) foi
utilizado junto a dois circuitos integrados (L2722). A alta resistência de entrada desses
circuitos integrados permitem que os motores sejam alimentados com energia reduzida vindos
do PWM (MARTIN, 2009).
27
Para a movimentação do robô foi utilizado um esquema de controle utilizando a
Lógica Fuzzy com o intuito de evitar os obstáculos. A lógica utilizada foi desenvolvida para
interpretar as medidas de distância (MARTIN, 2009).
Foi definido três conjuntos de funções de pertinência. Eles foram criados para
expressar a distancia, velocidade de translação e velocidade de rotação feita por um total de
duas funções de entrada e oito funções de pertinência para a saída. Por se tratar de controle
num microcontrolador que possui processamento e memória limitada, foram utilizadas as
funções triangular e trapezoidal por serem rápidas de calcular e de fácil modificação. Devido
a este motivo, necessitou-se a alteração no modo de calcular. Para obter uma maior eficiência
no processamento da maioria dos conjuntos de dados reduzindo o tempo de análise, de um
segundo para aproximadamente 40 milissegundos. A função de pertinência distancia permite
que as distâncias interpretadas pelo sensor infravermelho sejam rapidamente fuzzificadas,
enquanto as oito velocidades da função de pertinência de valores Fuzzy convertidos de volta
para valor crisp (MARTIN, 2009).
Uma vez que os dados de entradas foram fuzzificados, as oito regras definidas para a
Lógica Fuzzy foram executadas em ordem atribuindo valores para a velocidade de translação
e rotação. Este resultou em múltiplos valores para cada componente de saída Fuzzy. Foi então
necessário levar o máximo desses valores como o valor Fuzzy para cada componente.
Finalmente, esses valores de saídas Fuzzy foram defuzzificados usando a técnica do Produto-
Máximo resultando em atualizações que foram ajustadas no motor (MARTIN, 2009).
Abaixo segue as figuras que apresentam as funções de pertinência referente à distância
(Figura 6), velocidade de translação (Figura 7) e velocidade de rotação (Figura 8) e por fim a
Tabela 3 contendo a base de regras Fuzzy utilizadas, respectivamente.
28
Figura 5. Função de Pertinência para Distância.
Fonte: adaptado de XU; TSO; FUNG (1998).
Figura 6. Função de Pertinência para Velocidade Translação.
Fonte: adaptado de XU; TSO; FUNG (1998).
29
Figura 7. Função de Pertinência para Velocidade Rotação.
Fonte: adaptado de XU; TSO; FUNG (1998).
Tabela 3. Base de Regras
Fonte: adaptado de XU; TSO; FUNG (1998)
Regra Esquerda Centro Direita Velocidade Rotação
1 perto perto perto lento muito direita
2 perto perto longe media pouco direita
3 perto longe perto lento frente
4 perto longe longe rapida pouco direita
5 longe perto perto media pouco esquerda
6 longe perto longe lento muito direita
7 longe longe perto rapida pouco esquerda
8 longe longe longe rapida frente
Segundo XU; TSO; FUNG (1998 apud Martin, 2009), o esquema de controle Fuzzy
utilizado permitiu ao robô responder de forma rápida aos obstáculos que poderiam ser
detectados no ambiente, possibilitando seguir paredes e dobrar esquinas de forma satisfatória
evitando os obstáculos. Martin (2009) ainda cita que o robô por vezes teve problemas na
detecção de obstáculos relacionada com a geometria dos mesmos. Por exemplo, quando o
feixe infravermelho batesse numa incidência oblíqua não ocasionando a reflexão no receptor
infravermelho o obstáculo era desconsiderado. Além disso, a quantidade de regras utilizadas
podem ter limitado a dinâmica das respostas do robô. XU; TSO; FUNG (1998 apud Martin,
2009) em seus estudos, identificou que alguns autores sugerem até quarenta regras a ser
utilizada, enquanto outros citam algo em torno de dez a vinte regras. O objetivo do trabalho
não era explorar a complexidade dos movimentos (cinética) ou simulações computacionais do
30
robô. Apesar dos problemas enfrentados quanto á falha da leitura dos sensores na medição da
distância, os testes ocorreram de forma satisfatória com as oito regras definidas fazendo com
que a robustez da Lógica Fuzzy fosse capaz de evitar os obstáculos. Martin (2009) conclui que
há várias melhorias a serem realizadas em trabalhos futuros com o intuito de melhorar o
desempenho do robô. Ele propõe um sistema de sensores infravermelhos ou ultra-sônicos em
um servo para escanear o ambiente em 180º garantindo mais confiabilidade na leitura dos
sensores. No entanto esta aplicação poderia comprometer alguma das facilidades da Lógica
Fuzzy.
Outra melhoria apontada se refere à limitação mínima de 10 cm dos sensores
infravermelhos utilizados não detectando objetos de forma segura, a mesma limitação ocorre
em relação ao limite máximo de 80 cm da área detectável comprometendo a identificação de
obstáculos distantes. Este problema poderia ser contornado com o uso de sensores ultra-
sônicos que possuem alcance significativamente maior a um custo pouco superior aos
infravermelhos. Por último o autor relata um aumento na utilização de funções de pertinência
que poderiam ajudar a base de regras a criar respostas mais afinadas.
2.9.3 Desenvolvimento de um robô autônomo que desvia de obstáculo –
RADO – I
No projeto apresentado por Fábio Alves Oliveira Silva do Centro Universitário
Sant’anna em cumprimento dos requisitos para a conclusão da matéria Projetos de Sistemas
Digitais e Microprocessadores projetou, construiu e implementou o robô autônomo que desvia
de obstáculos chamado de RADO-I, equipado com autonomia energética e de controle.
O robô se move através de motor de passo, controlado pelo módulo controlador dos
motores, baseando-se no microcontrolador AT89S8253 da fabricante Atmel. O módulo
principal recebe os sinais do sensor externo e os processa de acordo com a estratégia de
controle adotada, com base nas informações captadas pelo sensor serão tomadas as decisões,
na sequencia serão enviadas pela interface para o módulo controlador dos motores, não
havendo intervenção externa. A alimentação é feita por baterias embarcadas no robô.
O robô possui seu formato em forma retangular sobre três rodas, sendo duas motrizes
e a terceira de apoio. Para que servisse de exemplo o acadêmico decidiu que o robô iria vagar
no ambiente detectando e evitando obstáculos e depressões.
No projeto foram definidos o sensor de sonar que possui um preço aceitável e uma alta
taxa de detecção conseguindo perceber alteração no ambiente entre 0 e 6,45 metros de
31
distância. Os motores elétricos selecionados foram: um servo-motor normal, e outros dois
servo-motores com rotação contínua e através de um comando de pulso (PWM) estes podem
variar a velocidade e o sentido de rotação.
Figura 8. Simulação da tomada de decisão ao detectar objeto.
Fonte: (OLIVEIRA SILVA, 2008).
Segundo Silva Oliveira (2008), a estratégia de controle utilizada analisa as seguintes
situações, onde o robô não encontrando obstáculos sempre se locomoverá para frente. Na
detecção de um objeto o Motor de Passo posiciona o sensor de ultra-som a esquerda e fará a
medição da distância, o motor se movimentará novamente reposicionando o sensor a direita, o
sensor medirá nesta direção. Na menor distância encontrada ou ausência de obstáculos em
qualquer direção o robô tomará a decisão de desviar para o lado contrário da menor distância
medida ou ausência da mesma. Na possibilidade de ausência de distância ou impossibilidade
de cálculos o desvio é feito a direita por padrão (Conforme Figura 9).
32
Figura 9. Fluxograma do programa.
Fonte: (OLIVEIRA SILVA, 2008).
Embora este trabalho não utilize alguma técnica de Inteligência Artificial para o
controle do veículo robô, o autor criou um controle simples, porém funcional.
Os trabalhos similares aqui apresentados possuem grande valor para o projeto
proposto. Nesses trabalhos são possíveis de extrair soluções encontradas para problemas que
podem aparecer no desenvolver do projeto além de poder identificar as várias soluções
empregadas pelos autores.
33
3 DESENVOLVIMENTO
Nesta seção é demonstrada a modelagem para o veículo robô. O projeto apresenta os
requisitos funcionais além de abordar o funcionamento geral do veículo robô, como ocorre a
detecção de obstáculos, como funcionam seus atuadores, etapa de montagem e adaptação,
montagem eletrônica na protoboard e também é apresentada a modelagem do controlador
Fuzzy. Na Figura 10 é apresentado uma visão geral do veículo robô.
Figura 10. Visão geral do veículo robô.
Basicamente os sensores recebem os dados lidos do ambiente e passam para a placa
Arduino que baseado na Lógica Fuzzy atuará de forma a prover uma saída adequada para
velocidade e direção controlando assim o motor de corrente contínua e o servomotor.
3.1 Requisitos Funcionais
Os requisitos funcionais revelam como o veículo autônomo deverá funcionar.
O veículo deverá movimentar-se num ambiente plano.
O veículo deverá percorrer o ambiente por um período de 30 segundos.
O veículo deverá “perceber” o mundo e atuar sobre ele evitando potenciais
obstáculos respeitando seus limites.
34
O veículo deverá parar quando o limite de tempo for atingido sinalizando com
3 bipes sonoros a ação.
O veículo deverá parar sinalizando com 5 bipes sonoros quando um obstáculo
impedir de realizar uma curva.
3.2 Funcionamento do Veículo Autônomo
O veículo autônomo é uma plataforma de um carrinho de controle remoto com quatro
rodas que será preservada. Nessa estrutura, seus motores são preservados. Uma adaptação na
direção do veículo foi necessária para possibilitar usar um servomotor padrão para controle,
assim como permitir embarcar a placa Arduino junto com dois sensores infravermelhos de
longo alcance, posicionados de forma a detectar e evitar as possíveis colisões à frente com
obstáculos ao longo do percurso baseado na técnica de Inteligência Artificial, a Lógica Fuzzy.
O veículo ao ser ligado começará a se mover no ambiente plano detectando e evitando
os obstáculos em um tempo determinado de 30 segundos. Esse tempo de funcionamento foi
escolhido para limitar seu período de execução, julgado como adequado para demonstração
do veículo autônomo no ambiente. Quando o limite de tempo for atingido ou o veículo não
conseguir realizar a manobra adequada de direção devido à ausência do controle da ré o
mesmo irá soar três bipes para sinalizar sua ação de parada ou cinco bipes na impossibilidade
de concretizar uma direção não coberta nessa versão.
Quando o veículo estiver em modo ligado sua tendência é se movimentar pelo
ambiente em linha reta desviando somente no caso em que encontre algum obstáculo a sua
frente.
3.3 Percepção do ambiente
Para delimitar o seu raio de ação, inicialmente os sensores verificarão se não existe
algum obstáculo próximo. Esta proximidade depende da caraterística do sensor. Neste caso os
sensores de distância infravermelhos utilizados foram modelo Sharp GP2Y0A02YK0F de
longo alcance permitindo uma detecção entre 20 e 150 cm. Neste trabalho foram usados dois
sensores para detecção dos obstáculos. A posição adotada para os sensores foi em forma de
“X” fazendo com que em aproximadamente 15 centímetros de distância os raios
infravermelhos se encontrem na tentativa de amenizar o ponto cego ao meio para a detecção
de potenciais obstáculos. Esse esquema está exemplificado na Figura 11.
35
Figura 11. Raios infravermelhos partindo dos sensores posicionados no veículo.
Foram realizados vários testes a fim de identificar uma posição ideal dos sensores. Foi
detectado que, se os sensores estivessem em paralelo, os feixes infravermelho não
identificariam obstáculos ao centro. Na Figura 12 é apresentado uma conexão do sensor
infravermelho ao Arduino.
Figura 12. Sensor infravermelho conectado ao Arduino.
Fonte: adaptado de BRASIL ROBOTICS (2011).
Este tipo de sensor possui três fios de conexão, onde o fio vermelho é ligado a
alimentação de tensão da placa, no exemplo utiliza-se 5 volts (5v), o fio preto é conectado ao
pino identificado como o terra (Gnd), já para identificar a tensão gerada pela leitura do sensor
utiliza-se o fio amarelo ligado ao pino de entrada analógica 0 (zero).
3.3.1 Funcionamento do Sensor Infravermelho
Este tipo de sensor tem como característica possuir um circuito de controle para
contornar os ruídos relacionados ao ambiente. A medição é feita pela triangulação óptica para
36
determinar a distância. A triangulação apresenta um resultado melhor se comparado ao fato de
simplesmente medir a intensidade de luz infravermelha refletida. Para medição da distância o
sensor trabalha com variação de tensão conforme demonstrado na Figura 13.
Figura 13. Relação tensão e distância para objeto refletido.
Fonte: adaptado de SPARKFUN (2011).
Como é possível ver na Figura 13 a relação voltagem versus objeto refletido ou
detectado expresso em centímetros, nota-se que quanto maior o pico de tensão menor é a
distância medida, já para distâncias maiores sua voltagem é reduzida proporcionalmente. Na
imagem também é possível comparar a taxa de refletância (relação entre o fluxo de radiação
incidente na superfície com o fluxo de radiação refletida) entre os objetos medidos entre o
limite mínimo e máximo suportado, percebe-se à medida que a distância aumenta sua taxa de
refletância sofre variações.
37
3.3.2 Cálculo da Distância
A placa Arduino possui seis pinos de entrada analógicos disponíveis para uso,
identificados de 0 a 5. Os sensores infravermelhos são dispositivos analógicos os quais
produzem um sinal que será convertido para digital pelo Arduino fornecendo uma faixa de
valores no intervalo de 0 a 1023, resultando em 1024 variações. Para medir a distância será
necessário verificar a mudança na tensão a qual impacta diretamente em sua distância.
Segundo Larry (2009), os valores de distância convertidos apresentados na Figura 13
não traz nenhuma informação que possa ajudar no cálculo, contudo é necessário converter
este valor de volta para o real valor analógico. Para tal toma-se a voltagem da fonte de
alimentação do Arduino (5 volts) e divide-se pelas 1024 variações, obtendo-se o valor de
0,0048828125 (Equação 1).
1024
5volts
Equação 1
A próxima etapa é elaborar uma equação do gráfico mostrado na Figura 13 para obter
a chamada distância teórica a partir da leitura de tensão, percebe-se também uma exponencial
entre 20 e 150 cm. Para a mudança exponencial tem-se que transformar o valor para receber a
distância conforme a Figura 13, conforme demonstrado na Equação 2.
EF *65 Equação 2
Segundo Larry (2009), este é o índice que multiplicará os resultados de tensão para
obter a distância. Isso seria simples se este fosse um gráfico linear, em que a mudança na
tensão seria proporcional à distância total. Mas é exponencial (Figura 13) e para a conversão
tem-se que transformar o valor em um expoente. A fórmula para a leitura da distância de
tensão é mostrado na Equação 3.
38
xEG *65 Equação 3
Na Figura 13 é mostrado uma curva ascendente que representa os valores não
identificados pelo sensor. Entre 20 e 150 cm a curva é descendente e mostra os valores
identificados pelo sensor (LARRY, 2009).
A Equação 4 representa o resultado (H) da tensão em função da distância percebida
pelo sensor.
ErvalorSensoH * Equação 4
Para identificar as leituras do sensor infravermelho o ambiente de programação
Arduino permite acessar métodos que facilitem esse processo, contando com uma biblioteca
completa com diversos métodos para tratar a leitura de pinos analógicos.
3.4 Atuador Servomotor
Como citado neste trabalho o projeto utilizará um servomotor normal como atuador
para controle da direção do veículo. Estes dispositivos possuem 180º de liberdade permitindo
controles precisos dentro do intervalo, comumente encontrados em aeromodelos e
automodelos, além de projetos de robótica. Estes tipos de atuadores possuem três fios para o
correto funcionamento, sendo dois para alimentação e um para controle. Geralmente o fio
vermelho é usado para alimentação da tensão, o fio preto ou marrom é o terra e o controle
podendo ser identificados com o fio azul ou branco. O sinal de controle é responsável por
determinar o ângulo de giro do eixo do atuador. A Figura 14 apresenta uma ligação do
servomotor na placa Arduino.
39
Figura 14. Servomotor ligado ao Arduino.
Fonte: (AZEGA, 2011).
A Figura 14 apresenta uma ligação do servomotor ao Arduino, onde o fio vermelho da
alimentação (Vcc) é ligado a placa Arduino no pino referente à tensão de alimentação 5 volts
(5v). O fio terra é ligado ao pino Gnd e o fio de controle (Pulse) é ligado ao pino 9 do
Arduino que permite controlar a modulação da largura de pulso (PWM). Para usar o
servomotor na placa é necessário incluir a biblioteca Servo no sketch (programa Arduino).
Esta biblioteca contém métodos para manipulação desses dispositivos permitindo o controle
de um grande número desses atuadores.
Esse atuador será controlado pelo controlador Fuzzy o qual com as entradas detectadas
pelos sensores infravermelhos irá inferir o processo Fuzzy gerando um valor crisp de saída
para que posicione o servomotor em um ângulo adequado evitando assim os obstáculos no
caminho.
3.4.1 Funcionamento Servomotor
Segundo a Escola Superior de Tecnologia e Gestão de Portugal (ESTG, 2011), os
servomotores são motores especiais que possuem um sistema de controle da posição. A
maioria dos fabricantes permitem movimentos de 0º a 90º, ou 0º a 180º. Para a alimentação
desses tipos de atuadores necessita-se de uma tensão de 4,5 a 6,5 volts e sua corrente varia de
acordo com cada modelo.
40
O controle da posição do servomotor é feito com uma sequência de pulsos variando
sua amplitude geralmente entre 1 e 2 ms, a uma frequência aproximada de 50 Hertz. Na
Figura 15 é mostrado o movimento do eixo do servo em relação ao pulso recebido.
Figura 15. Movimento servomotor em função do sinal recebido.
Fonte: (ESTG, 2011).
Conforme demonstrado na Figura 15, quando o pulso recebido for 1,5 ms a
engrenagem de posicionamento do eixo do servo será movimentado ao centro do intervalo de
rotação nos 90º. Para pulsos de 1 ms, o eixo do servo será movimentado em sentido horário
até alcançar o limite do intervalo de rotação correspondente a 0º. Em pulsos de 2 ms, o eixo
do servo será posicionado em sentido anti-horário atingindo o limite do intervalo de rotação
correspondente a 180º. Pulsos recebidos no intervalo de 1 e 1,5 ms controlará a posição em
sentido horário no intervalo correspondente a 0º e 90º, a mesmo processo ocorre para pulsos
recebidos no intervalo de 1,5 a 2 ms com a diferença de sentido anti-horário no intervalo de
41
90º e 180º. A biblioteca Servo da placa Arduino permite controlar o eixo de rotação do
servomotor usando o método correspondente ao ângulo ou informando o tempo em
microssegundos.
3.5 Atuador CC e o controlador
Outro atuador importante para o trabalho proposto é o uso de motores de corrente
contínua ou popularmente chamado de DC motor, em inglês. Esses motores são amplamente
usados em praticamente qualquer brinquedo eletrônico que permita algum tipo de movimento.
Usados em conjunto com um controlador de motores (shield que possui o CI de Ponte-H para
controle) que permite usar dois motores para controle de velocidade podendo também ser
utilizado para controle da rotação do motor. Na Figura 16 é apresentada uma ligação direta
simples de um único motor a placa Arduino.
Figura 16. Controle de um motor de corrente contínua no Arduino.
Fonte: (THE NAND GATE, 2011).
Na Figura 16 é mostrado o uso de um motor de corrente continua ligado de forma
simples diretamente ao Arduino com o auxilio de uma protoboard (matriz de contatos para
facilitar a prototipação de projetos) que possui um componente facilmente encontrado em
projetos eletrônicos principalmente como amplificador e interruptor de sinais elétricos, o
transistor.
42
Segundo McRoberts (2011) o componente eletrônico transistor é usado para ligar e
desligar uma voltagem e uma corrente mais alta. O máximo de tensão que a placa Arduino
suporta são 5V. Por este motivo foi usado o componente transistor que pulsa o sinal várias
vezes por segundo de forma a ligar e desligar a corrente regulando a mesma.
3.5.1 Controlador de Motores
Na seção anterior foi demonstrado um único motor de corrente contínua ligada à placa
Arduino. Nesta seção será mostrado como controlar dois motores usando um shield para o
devido controle. A Figura 17 apresenta um tipo de shield para controlar a velocidade de dois
motores de corrente contínua. Estas placas que ampliam as funcionalidades do Arduino
possibilitam também controlar o sentido da rotação.
Figura 17. Controle de dois motores (shield) no Arduino.
Fonte: adaptado de CAFE COM JAVA (2011).
Na Figura 17 são visto dois motores de corrente contínua diretamente ligados ao
controlador de motores que possui componente eletrônico para permitir controlar a velocidade
e a shield ainda permite controlar o sentido de rotação dos motores. Basicamente essas shields
possuem um circuito integrado (CI) de Ponte-H para o controle da velocidade dos motores e a
possibilidade de permitir o controle do sentido de rotação. Um circuito integrado de Ponte-H
de modelo L293D, por exemplo, permite controlar totalmente dois motores de corrente
contínua e ainda possui componente eletrônico para proteção do CI diferente de modelos
43
anteriores que não possuem tal proteção. O componente tem o nome de Ponte-H devido à
forma atribuída a sua semelhança quando o circuito é montado.
O Arduino possui métodos para trabalhar com os pinos analógicos, com isso o
controle de dois motores é possível quando usado qualquer um dos pinos PWM de entrada
analógica para controlar a velocidade de rotação dos motores.
Assim como ocorre o controle de direção dos servomotores pela Lógica Fuzzy, os
motores de corrente continua também serão controlados. Esses motores terão sua velocidade
controlada a partir da leitura dos sensores infravermelho de longo alcance processada pelo
Fuzzy retornando um valor crisp para ser usado no controle de velocidade do veículo robô.
3.6 Atuador Servomotor
Nesta seção será apresentado o carrinho de controle remoto usado, bem como mostrar
o passo-a-passo de sua adaptação na tentativa de torná-lo o mais adequado para que esse
trabalho fosse realizado.
Figura 18. Visão frontal original do carrinho.
Na Figura 18 é apresentada a visão frontal original do carrinho antes de sofrer as
devidas alterações e adaptações necessárias ao projeto.
3.6.1 Montagem e Adaptação do Carrinho
Após colar a peça com problemas foi necessário abrir o carrinho para analisar sua
estrutura interna e identificar as adaptações necessárias a serem realizadas para inserir o
servomotor para controlar sua direção e o local mais apropriado para incluir os dois sensores
infravermelho de longo alcance.
44
A parte interna da dianteira do carrinho teve uma adaptação para resolver o problema
da fixação do servomotor. Foi necessário colocar um pedaço de madeira no corpo do carrinho
usando dois parafusos para fixação segurando assim um dos lados do suporte do
servomecanismo.
Após parafusar a madeira foi necessário nivelar a altura das laterais usando pequenos
pedaços de isopor para que, quando a protoboard for anexada com o circuito montado, o
Arduino não fique em desnível. A Figura 19 apresenta além do servo fixado na madeira o
isopor colado nas laterais.
Figura 19. Servo fixado na madeira parafusada e o isopor colado nas laterais.
Na Figura 19 é possível perceber a madeira com os dois parafusos para fixação e o
servomotor com um de seus lados também parafusados na madeira para ter sustentação.
Outra etapa necessária ao projeto foi à adaptação da barra de direção do carrinho para
encaixar o servomotor, um processo criterioso, pois as peças que estão ali presentes são
frágeis.
Nessa etapa foi necessário perfurar com uma broca a peça branca dentada responsável
por segurar a barra de direção. A escolha de usar um pino para fazer o movimento servo/barra
de direção foi pensando numa possível substituição da roseta que o servomotor vai
movimentar. Para isto, basta retirar o pino e substituir a roseta. Na Figura 20 é possível
visualizar a peça dentada (central) e o com o pino partindo do servo (no centro-alto).
45
Figura 20. Detalhe da peça que segura a barra de direção fixada com um pino.
Outra etapa também necessária ao processo foi a retirada de uma folga que existia na
barra de direção, onde nos testes percebeu-se que o veículo tornava-se bambo ao andar pelo
ambiente, dificultando muitas vezes a execução de seu trabalho já que virava bruscamente em
outras direções.
Nessa etapa foi efetuada a adaptação com uma peça de madeira e fixado com um
parafuso a outra extremidade do servomotor.
Figura 21. Servomotor com a sua extremidade parafusada na madeira.
Na Figura 21 é possível visualizar o parafuso no servomotor fixado a madeira para dar
sustentação no momento que o dispositivo começar a funcionar.
46
E na última etapa que refere-se à montagem, foi necessário fixar os dois sensores
infravermelhos de longo alcance na mesma madeira que o servomotor foi fixado. Nesta etapa
foi usado dois horns1de servomotor para servir de base para os sensores permitindo regulagem
individual. Os sensores foram colados com cola quente e os dois horns foram parafusados
para permitir tal regulagem. Na Figura 22 é possível visualizar como os sensores e os horns
estão fixados.
Figura 22. Visão dos horns (peça na cor vermelha) parafusados e com os sensores colados em
cima.
Para concluir a etapa de montagem, foi cortado um pedaço de isopor para servir como
base de modo que sua altura ultrapassasse a altura do servo para não usá-lo como apoio
forçando a ponto de danificá-lo. O isopor então foi fixado ao carrinho usando dois elásticos
ficando um em cada extremidade. Na Figura 23 é possível ver a base montada no carrinho
para sustentar a protoboard.
1 Horn: Um pequeno braço de nylon ou de plástico ou uma roda que une ao eixo de saída
de um servo.
47
Figura 23. Base de isopor montada para apoiar a protoboard.
Na Figura 23 é visto o veículo montado com a base para apoiar a protoboard preso aos
dois elásticos para prender o suficiente a ponto de não deixar folga.
Por fim é necessário prender a protoboard com o circuito montado junto ao Arduino a
base de isopor demonstrado na etapa anterior. Na Figura 24 pode-se ver a protoboard
montada e fixada ao veículo.
Figura 24. Visão do veículo adaptado.
Na Figura 24 é possível ver o veículo adaptado e montado junto com os sensores
infravermelhos, o servomotor e a protoboard com o circuito montado e o Arduino fixado na
extremidade com elástico.
48
3.7 Montagem Eletrônica
Nesta seção mostra-se o esquemático do circuito usado para controlar o Motor CC, o
Servomotor e os dois Sensores Infravermelho de Longo Alcance. Na Figura 25 é possível
visualizar o esquemático utilizado.
Figura 25. Esquemático do circuito.
No circuito montado foi necessária uma alimentação externa. Este motivo deve-se ao
fato da placa Arduino não suportar todos os dispositivos conectados ao mesmo tempo. Motor
CC, Servomotor e os Sensores infravermelho interligados ao mesmo tempo consomem uma
potência extra que será suprida por uma fonte externa.
A Alimentação foi realizada com uma fonte de entrada bivolt e uma saída de 12 volts
para alimentar o circuito (4). Como o Arduino trabalha com 5 volts internamente foi
necessário o componente eletrônico chamado regulador de tensão. Para isso foi usado o
modelo LM7805 onde entra 12 volts e sai 5 volts para alimentação dos dispositivos.
No esquemático da Figura 25 é possível perceber o uso de dois reguladores de tensão
(1), um ao lado do outro, dedicando-se um somente ao motor e o outro para o resto dos
dispositivos. Esta decisão foi tomada devido ao alto consumo do Motor CC e pelo
49
superaquecimento dos reguladores de tensão, onde também foi necessário o uso de
dissipadores de calor junto com a pasta térmica para não superaquecer.
Para o correto funcionamento do Motor CC e resolver o problema da pouca
amperagem fornecida pelo Arduino foi usado um componente eletrônico chamado transistor
(2), que nesse circuito foi usado o modelo TIP 120. O componente eletrônico transistor ligado
ao motor neste circuito funciona da seguinte maneira: ao ser acionado o transistor recebe pela
base a informação e permite que entre coletor e emissor circule uma corrente muito maior.
Esta corrente será suficiente para alimentar e controlar a corrente do motor.
Já os capacitores (3) usados no projeto, estão atuando de forma a proteger o circuito
contra oscilações, filtrando a energia e eliminando ruídos existentes da fonte externa o qual é
alimentado o circuito.
3.8 Partes Principais do Sketch do Veículo Autônomo
Nesta seção serão apresentados trechos de código do Veículo Autônomo carregado no
microcontrolador do Arduino.
As variáveis distanceLeft e distanceRight são obtidas a partir da leitura
respectivamente dos sensores da esquerda e direita. As distâncias aproximadas são obtidas
através de um cálculo matemático já citado nesse projeto.
As variáveis de distância SHORT_DISTANCE, MEDIA_DISTANCE e
LONG_DISTANCE representam, respectivamente 50, 100 e 150 centímetros e as variáveis de
velocidade SPEED_LOW, SPEED_MIDDLE, SPEED_HIGH representam, respectivamente
125, 135 e 145 rpm, numa escala que tem limites de 1 a 255 rpm.
Por problemas estruturais do Veículo Autônomo o mesmo só permitirá três níveis de
direção: esquerda, centro (reta) e direita, onde são representadas, respectivamente pelas
variáveis LEFT, CENTER e RIGHT que possuem valores 25, 65 e 130 graus.
A Figura 26 apresenta a Regra 2 baseada na Lógica Fuzzy, onde é identificado uma
distância menor para o sensor da esquerda (MEDIA_DISTANCE) e uma distância
considerada média para o sensor da direita (valor entre MEDIA_DISTANCE e
LONG_DISTANCE) resultando em uma curva a direita com uma velocidade baixa
(SPEED_LOW).
50
Figura 26. Regra 2 baseada na Lógica Fuzzy.
A Figura 27 apresenta a Regra 5 baseada na Lógica Fuzzy, onde é identificado uma
distância aqui considerada média (entre MEDIA_DISTANCE e LONG_DISTANCE) para
ambos os sensores. Nestas condições o Veículo Autônomo centralizará a posição do
servomotor para que ande reto e execute uma velocidade média aqui definida pela constante
SPEED_MIDDLE.
Figura 27. Regra 5 baseada na Lógica Fuzzy.
Na Figura 28 apresenta a Regra 7 baseada na Lógica Fuzzy, onde é identificado uma
distância longa para o sensor da esquerda (LONG_DISTANCE) e uma distância considerada
menor ou igual a média para o sensor da direita (MEDIA_DISTANCE). Nesta situação o
Veículo Autônomo moverá a posição do horn do servomotor para a esquerda (LEFT) e
executará uma velocidade considerada alta a qual é definida pela constante SPEED_HIGH.
Figura 28. Regra 7 baseada na Lógica Fuzzy.
51
3.9 Controlador Fuzzy
Nesta seção é apresentada uma modelagem para o controlador Fuzzy para o problema
do controle de velocidade e direção do veículo robô.
3.9.1 Variáveis Linguísticas
Segundo Barros e Bassanezi (2006) uma variável linguística é uma representação que
defini um conjunto de palavras de um dado domínio, enquanto os possíveis valores
pertencentes a este domínio são conhecidos como sendo os adjetivos. Na Tabela 04 é
apresentada uma possível modelagem para as variáveis de entrada do controlador Fuzzy para
o veículo robô.
Tabela 4. Variáveis Linguísticas de Entrada
Variáveis de Entrada Conjuntos
SensorEsquerda pouca distancia, media distancia, muita distancia
SensorDireita pouca distancia, media distancia, muita distancia
Os sensores de infravermelho da direita (SensorDireita) e da esquerda
(SensorEsquerda) serão responsáveis por obter a distância de um potencial obstáculo a sua
frente, essa informação é importante para que o controlador Fuzzy defina sua velocidade e
direção.
Na etapa de adaptação do Veículo Autônomo ocorreram diversos problemas no
momento de fixar o servomotor e levantar os ângulos suportados para a esquerda e direita e ao
centro. Um dos problemas enfrentados refere-se à limitação de graus permitidos para os lados
do veículo, onde na peça que esta fixada o servomotor possui paredes laterais que impedem o
horn mover os 180º permitidos pelo atuador. Outro problema enfrentado foi decorrente dos
testes para identificar os graus suportados pelos servomotor, onde forçou o lado esquerdo do
veículo resultando na quebra do pino que segura à roda na barra de direção. Na Figura 29 é
mostrado como estão definidas as variáveis linguísticas para os sensores da direita e esquerda.
52
Figura 29. Valores para as variáveis linguísticas referentes aos sensores de distância.
A Figura 29 apresenta os valores para as variáveis linguísticas referentes aos sensores:
Pouca, Media e Muita referente à direção a ser tomada pelo Veículo Autônomo. Os valores
usados para expressar as variáveis no intervalo de 0 a 150 centímetros baseado nos limites do
sensor infravermelho usado.
Para o controle da velocidade e da direção do veículo robô, a Tabela 05 apresenta as
variáveis de saída para o controlador Fuzzy. A velocidade poderá assumir baixa, média ou alta
e a direção poderá assumir muito esquerda, pouco esquerda, não vire, pouco direita ou muito
direita.
Tabela 5. Variáveis Linguísticas de Saída
Variáveis de Saída Conjuntos
Velocidade baixa, media, alta
Direcao muito esquerda, pouco esquerda, não vire, pouco direita, muito direita
Após o controlador Fuzzy inferir nas regras realizando uma potencial saída para os
conjuntos “Velocidade” e “Direcao” de forma a atuar nos mecanismos do motor de corrente
contínua e no servomotor, resultando em uma saída adequada de controle.
Como o controlador Fuzzy não foi embarcado na placa Arduino de acordo com os
problemas já relatados, foi realizado somente simulação no FuzzyCLIPS e passado os
parâmetros calculados para o sketch carregado no Arduino. Na Figura 30 é mostrado como
está baseado os valores para a variável linguística de saída referente à velocidade.
53
Figura 30. Valores para a variável linguística de saída referente à velocidade.
A Figura 30 apresenta o conjunto para a variável linguística velocidade: Baixa, Media
e Alta executada pelo Motor CC do Veículo Autônomo. Os valores usados para expressar as
variáveis no intervalo de 135 a 145 numa escala de 0 a 255 foi baseada em testes adequando a
velocidade em local plano como o piso. Na Figura 31 é mostrado como está baseado os
valores para a variável linguística de saída referente à direção.
Figura 31. Valores para a variável linguística de saída referente à direção.
A Figura 31 apresenta os valores para o conjunto da variável linguística direção:
Esquerda, Centro e Direita a ser executada pelo servomotor do Veículo Autônomo. Os valores
usados para expressar o conjunto são 25, 65 e 130 respectivamente, estes limites foram
identificados em testes de acordo com a limitação imposta pela estrutura do carrinho.
3.9.2 Regras Fuzzy
Segundo Barros e Bassanezi (2006) a base de regras Fuzzy consiste em proposições
formadas por uma coleção de regras SE-ENTÃO, onde cada condição da regra é chamada de
antecedente e cada ação é comumente conhecida como consequente. Os antecedentes
54
verificam as regras de entrada do conjunto Fuzzy, já os consequentes fornecem os possíveis
valores de saída aceitos nas variáveis linguísticas definido em um determinado conjunto
Fuzzy. Na Tabela 06 é apresentada a modelagem das regras para o projeto.
Tabela 6. Projeto Base de Regras
Entradas Saídas
SensorEsquerda SensorDireita Velocidade Ângulo de Direção
pouca distancia pouca distancia baixa direita
pouca distancia media distancia baixa direita
pouca distancia muita distancia baixa direita
media distancia pouca distancia baixa esquerda
media distancia media distancia media não vire
media distancia muita distancia media não vire
muita distancia pouca distancia baixa esquerda
muita distancia media distancia media não vire
muita distancia muita distancia alta não vire
A base de regras apresentada na Tabela 06 consiste na modelagem de nove regras
definidas para serem inferidas pela máquina de inferência e apresentar a possível melhor saída
para os atuadores.
3.9.3 Defuzzificação
No processo de defuzzificação serão “traduzidos” os valores do conjunto Fuzzy,
através de métodos, do processo de inferência realizado pela máquina de inferência para
valores de saída (crisp) que serão os valores de controle referente às variáveis de saída
Velocidade e Direção que consequentemente atuarão no motor de corrente continua e no
servomotor. Existem vários métodos possíveis, os mais comuns são o Centro de Gravidade
(COG) e a Média dos Máximos (MOM). Nesta etapa será estudado o método da Média dos
Máximos já que este apresenta a vantagem de ser rápido por realizar poucos cálculos com
pontos flutuantes, mas apresenta a desvantagem de variações menos suave comparado ao
método de Centro de Gravidade, por exemplo.
3.10 Ferramenta FuzzyCLIPS
A simulação Fuzzy foi realizada com a ferramenta shell FuzzyCLIPS, a qual é uma
extensão da ferramenta de sistemas especialista CLIPS. FuzzyCLIPS é baseada em Lógica
55
Fuzzy, desenvolvida pela Integrated Reasoning Group do Institute for Information
Technology da National Research Council of Canada. Uma grande melhoria incorporada na
ferramenta FuzzyCLIPS foi o tratamento de conjuntos Fuzzy para raciocínio com o
mecanismo de inferência integrado ao CLIPS. Com a melhoria implementada torna-se
possível representar e manipular fatos e regras Fuzzy, podendo trabalhar tanto com raciocínios
exatos quanto raciocínios Fuzzy ou até mesmo uma mistura desses raciocínios.
3.10.1 Simulações
A simulação na shell FuzzyCLIPS é usado basicamente três telas para análise do
processamento Fuzzy. Essas telas são: a principal, a dos fatos e a de agenda.
Nesta subseção é apresentada três casos de simulação realizada no ambiente
FuzzyCLIPS. A Figura 32 apresenta a tela principal do FuzzyCLIPS após carregar o arquivo
contendo a especificação Fuzzy do Veículo Autônomo e clicar em Reset no item de menu
Execution, é então mostrada a definição de variáveis globais, variáveis linguísticas, regras da
base de conhecimento e regra para defuzzificação e os fatos para a base de regras.
Figura 32. Tela principal do FuzzyCLIPS após carregar o arquivo.
56
É também apresentada ao lado da tela principal, a de Fatos. Esta tela apresenta os fatos
explícitos presente na base de conhecimento, assim como são mostrados os fatos implícitos
que surgem à medida que as regras são disparadas. Na Figura 33 é apresentada a tela de fatos.
Figura 33. Tela de fatos.
Outra tela apresentada junto a principal é a de Agenda. Armazena todas as regras que
“casam” com os fatos e então podem ser disparadas Na Figura 34 é apresentada a tela de
Agenda.
Figura 34. Tela de Agenda.
57
3.10.2 Caso 1
Inicialmente o fato a ser simulado é inserido manualmente no arquivo de especificação
criado com as definições para o Veículo Autônomo no editor do FuzzyCLIPS. Nesta primeira
simulação o Veículo Autônomo detecta um obstáculo a 150 cm para o sensor da direita
(Sensor IR 2) e 150 cm para o sensor da esquerda (Sensor IR 1). A Figura 33 demonstra o
Veículo Autônomo detectando o obstáculo aqui considerado distante.
Figura 35. Detecção de obstáculos considerados distantes.
Após executar o FuzzyCLIPS passo-a-passo, é obtido os fatos resultantes no processo
Fuzzy antes de executar a regra criada para efetuar a defuzzificação conforme demonstra a
Figura 36.
Figura 36. Fatos antes da defuzzificação.
Após a defuzzificação o sistema exibe na tela principal o resultado para as saídas:
Velocidade e Direção, ambas mostradas tanto no método da centróide (COG) quanto pelo
58
método da média dos máximos (MOM). A Figura 37 apresenta a tela principal com os
resultados da saída defuzzificadas para a velocidade e direção.
Figura 37. Caso 1 - Tela com resultados da saída.
Conforme resultado mostrado na Figura 37 o Veículo Autônomo terá a saída referente
a sua velocidade com valor 145 rpm e a saída referente a direção será 65 graus. Estes valores
gerados se resumem a uma velocidade alta em reta.
3.10.3 Caso 2
Nesta segunda simulação o Veículo Autônomo detecta um obstáculo a 50 cm para o
sensor da direita (Sensor IR 2) e 50 cm para o sensor da esquerda (Sensor IR 1). A Figura 38
demonstra o Veículo Autônomo detectando o obstáculo aqui considerado próximo.
59
Figura 38. Detecção de obstáculo próximo.
Após executar o FuzzyCLIPS passo-a-passo, é obtido os fatos resultantes no processo
Fuzzy antes de executar a regra criada para efetuar a defuzzificação conforme demonstra a
Figura 39.
Figura 39. Fatos antes da defuzzificação.
Após a defuzzificação o sistema exibe na tela principal o resultado para as saídas:
Velocidade e Direção, ambas mostradas tanto no método da centróide (COG) quanto pelo
método da média dos máximos (MOM). A Figura 40 apresenta a tela principal com as saídas
defuzzificadas para a velocidade e direção.
60
Figura 40. Caso 2 - Tela com resultados da saída.
Conforme resultado mostrado na Figura 40 o Veículo Autônomo terá a saída referente
à sua velocidade com valor 140 rpm e a saída referente a direção será de 70.83 graus. Estes
valores gerados se resumem a uma velocidade considerada baixa e sua direção será à direita.
3.10.4 Caso 3
Nesta terceira simulação o Veículo Autônomo detecta um obstáculo a 80 cm para o
sensor da direita (Sensor IR 2) e 35 cm para o sensor da esquerda (Sensor IR 1). A Figura 41
demonstra o Veículo Autônomo detectando o Obstáculo 1 a direita necessitando virar a
esquerda por possuir maior distância.
61
Figura 41. Detecção de obstáculo próxima à direita.
Após executar o FuzzyCLIPS passo-a-passo, é obtido os fatos resultantes no processo
Fuzzy antes de executar a regra criada para efetuar a defuzzificação conforme demonstra a
Figura 42.
Figura 42. Fatos antes da defuzzificação.
Após a defuzzificação o sistema exibe na tela principal o resultado para as saídas:
Velocidade e Direção, ambas mostradas tanto no método da centróide (COG) quanto pelo
método da média dos máximos (MOM). A Figura 43 apresenta a tela principal com as saídas
defuzzificadas para a velocidade e direção.
62
Figura 43. Caso 3 - Tela com resultados da saída.
Conforme resultado mostrado na Figura 43 o Veículo Autônomo terá a saída referente
à sua velocidade com valor 135 rpm e a saída referente a direção será 25 graus. Estes valores
gerados se resumem a uma velocidade considerada baixa e sua direção será à esquerda.
Os dois métodos de defuzzificação exibidos nos resultados das simulações foram
mostrados somente para fins de comparação, o método usado no Veículo Autônomo foi o
método da média dos máximos.
Os resultados gerados pela defuzzificação nas simulações do FuzzyCLIPS foram
tratados quando possuíam decimais, arredondando ou truncando os valores quando
necessário, onde somente valores inteiros serão utilizados no sistema de controle do Arduino.
Esses valores foram inseridos manualmente em constantes definidas no sketch do Veículo
Autônomo no Arduino.
63
4 CONCLUSÕES
Desde o início do projeto acreditava-se num grande desafio a ser enfrentado e vencido,
já que este projeto possui uma multidisciplinaridade envolvendo além da filosofia do Faça
Você Mesmo (DIY) as áreas do conhecimento, como mecânica, eletrônica e computação.
O primeiro problema e o que tomou mais tempo para resolver, sem dúvida, foi o
circuito necessário para que os dispositivos funcionassem corretamente, necessitando de
alimentação externa já que o Arduino não suporta tensões e correntes muito altas. É o caso do
motor de corrente contínua que precisou também de um transistor para suportar as altas
correntes necessárias.
Para que todo o circuito funcionasse de acordo foi necessário usar dois reguladores de
tensão com dissipadores de calor e pasta térmica, sendo um exclusivo para o motor. Isto deve-
se ao fato de exigir uma corrente muito alta e outro para o restante dos dispositivos como o
servomotor e os sensores infravermelho.
O segundo maior problema enfrentado foi à adaptação do carrinho. Este, assim como a
montagem do circuito tomou muito tempo também para ser resolvido já que a manipulação
das peças necessitava de paciência devido à sua fragilidade. A necessidade de confeccionar
peças de madeira na medida correta para adaptações do servomotor, adaptações na barra de
direção do carrinho e para encaixe do servomotor foram trabalhos extras que demandaram
tempo. A adaptação de um suporte na parte frontal, onde foram fixados os sensores e o outro
lado do servomotor, bem como a retirada de partes do carrinho para movimento correto da
barra de direção também foram tarefas que ajudaram o movimento de direção das rodas.
Neste projeto além de superar os problemas encontrados, a parte eletrônica também foi
um contratempo. Muitos componentes eletrônicos não eram conhecidos: regulador de tensão,
transistor, capacitor e diodo, além dos parâmetros dos sensores infravermelho. Motores de
corrente contínua e servomotor apresentam suas particularidades, mas graças à facilidade que
a plataforma Arduino apresenta esses problemas foram resolvidos.
Os objetivos do trabalho foram cumpridos em sua parcialidade. A adaptação do carro
modelo, embarcar o circuito eletrônico criado no veículo bem como ajustar a integração dos
componentes foram os processos que mais consumiram tempo, tomando aproximadamente
80% do desenvolvimento do projeto o qual impactou diretamente no desenvolvimento do
controlador Fuzzy. Com o tempo gasto na adaptação da estrutura do carro modelo bem como
o tempo investido na aprendizagem de eletrônica inviabilizou a construção do controlador
64
Fuzzy, ficando este simulado no ambiente FuzzyCLIPS onde seu resultado é inserido
manualmente no sketch do Arduino. Foi sugerido como trabalho futuro desenvolver o
controlador Fuzzy.
4.1 Trabalhos Futuros
A sugestão para trabalhos futuros é melhorar a aparência do circuito. Elaborar uma
placa de circuito impresso com os componentes necessários ao funcionamento e adaptando
plugs para um encaixe mais adequado.
Realizar um estudo para avaliar uma maneira de permitir o servomotor girar a mesma
quantidade de graus para ambos os lados permitindo um controle de direção mais adequado
na hora de implementar o software de controle do Veículo Autônomo.
Desenvolver um controlador Fuzzy otimizado para embarcar no Arduino atendendo as
necessidades do projeto.
Incluir um terceiro sensor infravermelho para melhorar a percepção de objetos
detectados e implementá-lo no meio dos sensores laterais.
Incluir a funcionalidade de ré no Veículo Autônomo, permitindo acionar essa
funcionalidade quando detecta-se objetos muito próximos onde a direção não tem ângulos
suficientes para realizar uma curva adequada.
Criar uma biblioteca com métodos para realizar o controle total do Veículo Autônomo
permitindo assim compartilhar com a comunidade.
65
REFERÊNCIAS
AZEGA. Arduino Servomotor. Disponível em: <http://www.azega.com/arduino-servo-
motor-part-1>. Acesso em: 30 out. 2011.
ARDUINO. Site Oficial. Disponível em: <http://www.arduino.cc/>. Acesso em: 24 ago.
2011.
BARROS, L. C. e BASSANEZI, R. C. 2006. Tópicos de Lógica Fuzzy e Biomatemática,
volume 5 Coleção IMECC - Textos Didáticos. IMECC-UNICAMP, Campinas/SP.
BENTES, Leandro Maurício Araújo. Arduino: hardware e software open-source.
Disponível em: < http://www.hardware.com.br/artigos/arduino/>. Acesso em: 14 ago. 2011.
BERTO, Marciel Francisco. Aplicação da Lógica Paraconsistente Anotada Evidencial Et
no controle de Sensores de temperatura na atuação de robôs móveis. 2007. Disponível
em:
<http://www.unip.br/ensino/pos_graduacao/strictosensu/eng_producao/download/eng_marciel
franciscoberto.swf>. Acesso em: 02 out. 2011.
BRASIL ROBOTICS. Tutorial: Sensor Infravermelho Sharp com Arduino. Disponível
em: <http://brasilrobotics.blogspot.com/2011/07/tutorial-sensor-infra-vermelho-sharp.html>.
Acesso em: 14 set. 2011.
BRESSIANI, Davi; PERINI, Ismael; N. SILVA, Jackson; GANZER, Jonata. Sensor de
Medição de Distância. 2006. Disponível em:
<http://hermes.ucs.br/ccet/demc/vjbrusam/inst/dist61.pdf>. Acesso em 08 set. 2011.
CAFÉ COM JAVA. Carrinho Controle Remoto com Java e Arduino. Disponível em:
<http://www.cafecomjava.com.br/2011/01/22/65/>. Acesso em: 06 nov. 2011.
COELHO, Marcelo S. Atuadores. Disponível em:
<http://marcelocoelho.net/ARQUIVOS/SAI171_IAI/AULA%204-
ATUADORES%20%20REV2-JAN-2010.pdf>. Acesso em: 12 out. 2011.
CRUZ, Shermila Guerra Santa. Sistema de Navegação para Veículo Autônomo usando
Lógica Difusa. 2009. Disponível em:
<http://www.teses.usp.br/teses/disponiveis/18/18152/tde-09092009-
082215/publico/Shermila.pdf>. Acesso em: 28 set. 2011.
DARPA, Darpa Urban Challenge. 2007. Disponível em:
<http://www.darpagrandchallenge.com>. Acesso em: 15 ago. 2011.
ENOMOTO, João Luiz Ferreira. Controle de Inclinação usando Lógica Fuzzy. 2010.
Disponível em: <http://www.eletrica.ufpr.br/ufpr2/tccs/175.pdf>. Acesso em: 26 set. 2011.
ESTG. Controlo de Servomotores com o microcontrolador BX-24. 2003. Disponível em:
<http://www.estg.ipg.pt/robobombeiro2003>. Acesso em: 29 out. 2011.
66
GIOPPO, Lucas Longen; HIGASKINO, Marcelo Massao Kataoka; FANTIN DA COSTA,
Ricardo; MEIRA, William Hitoshi Tsunoda. Robô Seguidor de Linha. 2009. Disponível em:
<http://www.slideshare.net/rafaelpouzada/monografia-arduino>. Acesso em: 16 out. 2011.
HEINEN, Farlei José. Sistema de Controle Híbrido para Robôs Móveis Autônomos. 2002.
Disponível em: <http://osorio.wait4.org/oldsite/alunos/mestrado/mestrado-farlei-heinen.pdf>.
Acesso em: 30 set. 2011.
HILARE. “HILARE” Autonomous Mobile Robot – French. Disponível em:
<http://cyberneticzoo.com/?p=4971>. Acesso em: 02 out. 2011.
HALFPAP, Dulce Maria; CORRÊA DE SOUZA, Gilberto; ALVES, João Bosco da Mota.
Robôs como Artefatos. 2007. Disponível em:
<http://www.sumarios.org/sites/default/files/pdfs/52824_6189.PDF>. Acesso em: 01 out.
2011.
JÁCOBO, Júlio Emílio Alvarez. Desenvolvimento de um Robô Autônomo Móvel Versátil
utilizando Arquitetura Subsumption. 2001. Dissertação de Mestrado (Engenharia
Mecânica). Disponível em:
<http://www.fem.unicamp.br/~lva/pdf/Pablo/TeseJustoEmilioAlvarez2001.pdf>. Acesso em:
01 out. 2011
KOHAGURA, Tiago. Lógica Fuzzy e suas Aplicações. 2007. Trabalho de Conclusão de
Curso (Graduação em Ciência da Computação) – Departamento de Computação,
Universidade Estadual de Londrina, Londrina, 2007. Disponível em
<http://www2.dc.uel.br/nourau/document/?view=601>. Acesso em: 12 ago. 2011.
LARRY, Lucky. Arduino – Using a Sharp IR Sensor for Distance Calculation. Disponível
em: <http://luckylarry.co.uk/arduino-projects/arduino-using-a-sharp-ir-sensor-for-distance-
calculation>. Acesso em: 01 nov. 2011.
MARTIN, William. Autonomous robot obstacle avoidance using a fuzzy logic control
scheme. 2009. Disponível em:
<http://vision.middlebury.edu/~wcmartin/files/fuzzy_control_robot.pdf>. Acesso em: 15 out.
2011.
MARTINS, Wander Ferreira. Controle Fuzzy em tempo real, aplicado ao sistema
plataforma –ESFERA. 2007. Disponível em: <
http://www.pgee.ime.eb.br/pdf/wander_martins.pdf>. Acesso em: 13 out. 2011.
MATIAS, Juliano. Teoria de Controle PID. 2008. Disponível em:
<http://www.mecatronicaatual.com.br/secoes/leitura/273>. Acesso em: 25 set. 2011.
MAUSHAMMER, John. Sparkfun Autonomous Vehicle Competition. 2009. Disponível em:
< http://blog.makezine.com/archive/2009/04/sparkfun-autonomous-vehicle-competi.html >.
Acesso em: 16 ago. 2011.
MCROBERTS, Michael. Arduino Básico / Michael McRoberts ; [tradução Rafael Zanolli]. --
São Paulo : Novatec Editora, 2011.
67
NETO, Gregório – LUCENA, Thiago – BERGAMIN, Carlos André. Sensor de
Temperatura LM 335. 20--. Disponível em:
<http://hermes.ucs.br/ccet/demc/vjbrusam/inst/lm335.pdf>. Acesso em: 13 ago. 2011.
PALPITE DIGITAL. Porque utilizar microcontroladores. 2007. Disponível em:
<http://www.palpitedigital.com.br/wp/2007/05/12/porque-utilizar-micrcontroladores/>.
Acesso em: 06 out. 2011.
RICARDO DA SILVA, José. Atuadores Pneumáticos. 2008. Disponível em:
<http://www.mecatronicaatual.com.br/secoes/leitura/324>. Acesso em: 09 out. 2011.
ROBÓTICA LIVRE. Introdução à programação de microcontroladores. 2011. Disponível
em:
<http://www.roboticalivre.com/index.php?option=com_flexicontent&view=items&cid=58&i
d=70>. Acesso em: 02 out. 2011.
RODRIGO, Leandro. Plataforma Arduino, Hardware e Visão Geral. 2011. Disponível em:
<http://www.dihitt.com.br/barra/arduino--visao-geral>. Acesso em: 24 ago. 2011.
ROTTAVA DA SILVA, Luciano. Análise e Programação de Robôs Móveis Autônomos da
Plataforma Eyebot. 2003. Disponível em: <
http://www.das.ufsc.br/~rottava/download/dissertacao.pdf>. Acesso em: 01 out. 2011.
SILVA OLIVEIRA, Fábio Alves. Desenvolvimento de um robô autônomo que desvia de
obstáculo – RADO. 2008. Disponível em:
<http://www.fabiocompany.com.br/tecnologia/wp-content/uploads/2011/02/PROJETO.pdf>.
Acesso: 03 out. 2011.
REIS, Cibele Alves da Silva; SARMENTO Henrique Reinaldo; ZARAMELLA Vinicius.
Montagem de um Robô Autônomo utilizando Lógica Fuzzy. 2010. Disponível em:
<http://www.pessoal.utfpr.edu.br/msergio/Monog-10-2-Robo-Fuzzy.pdf>. Acesso em: 22 set.
2011.
SPARKFUN. Especificação do sensor de distância infravermelho. Disponível em:
<http://www.sparkfun.com/datasheets/Sensors/Infrared/gp2y0a02yk_e.pdf>. Acesso em: 12
set. 2011.
SPARKFUN I. SparkFun’s Autonomous Vehicle Competition. 2011. Disponível em:
<http://www.sparkfun.com/products/10435>. Acesso em: 15 ago. 2011.
SOUZA FILHO, Marlos Roberto de. Rede Neural Artificial para o Deslocamento de um
Robô Autonônomo. 2009. Disponível em:
<http://siaibib01.univali.br/pdf/Marlos%20Roberto%20de%20Souza%20Filho.pdf>. Acesso
em: 07 set. 2011.
TARIG, Ali A. E. S. Controle de um braço robótico utilizando uma abordagem de agente
inteligente. 2001. 98 f. Dissertação (Mestrado em Ciências da Computação) – Programa de
Pós-Graduação em Informática, Universidade Federal da Paraíba, João Pessoa.
THE NAND GATE. Acionando um motor CC com Arduino. Disponível em:
<http://thenandgate.blogspot.com/2011/04/acionando-um-motor-cc-com-arduino.html>.
Acesso em: 01 nov. 2011.
68
UNIMATE. Primeiro Robô Industrial. Disponível em:
<http://www.robothalloffame.org/unimate.html>. Acesso em: 02 out. 2011.
XU, W. L; TSO, S. K; FUNG, Y. H. Fuzzy reactive control of a mobile robot incorporating
a real/virtual target switching strategy. presented at Robotics and Autonomous Systems,
1998, pp.171-186.
WERNECK, Pedro. Introdução ao Arduino. 2009. Disponível em:
<http://www.sabereletronica.com.br/secoes/leitura/1307>. Acesso em: 14 out. 2011.
69
GLOSSÁRIO
Arduino É uma plataforma de hardware e software livre para prototipagem
rápida que permite conectar vários tipos de sensores e atuadores para
realizar seu controle.
Atuador Elemento que produz movimento, seja sua fonte pneumática,
hidráulica ou elétrica.
PWM Técnica que permite simular variações de tensões entre 0 e 5 volts.
Ponte-H É um circuito eletrônico que permite controlar um motor de corrente
contínua através de um microcontrolador.
Microcontrolador É um circuito integrado que possui internamente um microprocessador
com características de um computador, porém com limitação em seu
hardware.
Shield São placas que se acoplam em cima da placa Arduino para ampliar
suas funcionalidades.
Sketch Nome usado para identificar um programa escrito em Arduino.
70
APÊNDICE A. SKETCH DO VEÍCULO AUTÔNOMO
#include <Servo.h>
boolean oneTime = true; // CONTROLE DE PARADA
unsigned long RUNTIME = 30000; // TEMPO TOTAL DE EXECUÇÃO DO VEÍCULO
// CONFIGURAÇÃO PINOS
int pinSensorIRLeft = A1; // SENSOR POSICIONADO A DIREITA
int pinSensorIRRight = A2; // SENSOR POSICIONADO A ESQUERDA
int pinMotor = 5; // PINO PWM MOTOR
int pinServo = 9; // PINO DIGITAL PWM SERVOMOTOR
int piezoPin = 7; // PINO DIGITAL BUZZER
// PARÂMETROS DIREÇÃO
int CENTER = 65; // IDENTIFICA O CENTRO DO SERVOMOTOR
int LEFT = 25; // TOTALMENTE A ESQUERDA
int RIGHT = 130; // TOTALMENTE A DIREITA
// PARÂMETROS DISTÂNCIA
int ATENCION_DISTANCE = 35; // DISTÂNCIA MUITO PRÓXIMA DO OBSTÁCULO
int SHORT_DISTANCE = 50; // DISTÂNCIA CURTA
int MEDIA_DISTANCE = 100; // DISTÂNCIA MÉDIA
int LONG_DISTANCE = 150; // DISTÂNCIA LONGA
// VELOCIDADE MOTOR
int SPEED_STOP = 0; // IDENTIFICA A PARADA DO MOTOR
int SPEED_LOW = 135; // VELOCIDADE BAIXA DA SIMULAÇÃO FUZZY
int SPEED_MIDDLE = 140; // VELOCIDADE MÉDIA DA SIMULAÇÃO FUZZY
int SPEED_HIGH = 145; // VELOCIDADE ALTA DA SIMULAÇÃO FUZZY
// INSTANCIA OBJETO direcao
Servo direcao;
// DISPARA O BIP
void startTone(int bip) {
pinMode(piezoPin, OUTPUT);
for (int i = 0; i < bip; i++) {
tone(piezoPin, 3100, 700);
71
delay(1000);
}
}
// TESTA A DIREÇÃO MOVENDO O HORN DO SERVO
void calibrate() {
direcao.attach(pinServo);
direcao.write(LEFT);
delay(1000);
direcao.write(RIGHT);
delay(1000);
direcao.write(CENTER);
delay(1000);
}
// INICIA COM 3 BIPS E TESTA O SERVO
void setup() {
startTone(3);
calibrate();
}
// CALCULA A DISTÂNCIA APROXIMADA
float getIRDistance(int pin) {
int count;
float volts = 0;
float totalDistance = 0;
float media = 0;
// FAZ UMA MÉDIA DAS 8 LEITURAS DO SENSOR IR
for (count = 1; count <= 8; count++) {
volts = analogRead(pin) * 0.0048828125;
totalDistance+= 65*pow(volts, -1.10);
}
media = totalDistance / count;
return media;
}
72
void loop() {
if (millis() <= RUNTIME) {
// DISTÂNCIA APROXIMADA DO SENSOR IR ESQUERDO
float distanceLeft = getIRDistance(pinSensorIRLeft);
// DISTÂNCIA APROXIMADA DO SENSOR IR DIREITO
float distanceRight = getIRDistance(pinSensorIRRight);
// CONDIÇÃO DE PARADA AO SE APROXIMAR MUITO DO OBSTÁCULO
if (distanceLeft <= ATENCION_DISTANCE && distanceRight <= ATENCION_DISTANCE) {
startTone(5);
direcao.write(RIGHT);
delay(15);
analogWrite(pinMotor, SPEED_STOP);
}
else
// REGRA 1
if ((distanceLeft >= SHORT_DISTANCE & distanceLeft <= MEDIA_DISTANCE) && (distanceRight >=
SHORT_DISTANCE & distanceRight <= MEDIA_DISTANCE)) {
direcao.write(RIGHT);
delay(15);
analogWrite(pinMotor, SPEED_LOW);
}
else
// REGRA 2
if (distanceLeft <= MEDIA_DISTANCE && (distanceRight > MEDIA_DISTANCE & distanceRight <
LONG_DISTANCE)) {
direcao.write(RIGHT);
delay(15);
analogWrite(pinMotor, SPEED_LOW);
}
else
// REGRA 3
if (distanceLeft <= MEDIA_DISTANCE && distanceRight > LONG_DISTANCE) {
73
direcao.write(RIGHT);
delay(15);
analogWrite(pinMotor, SPEED_LOW);
}
else
// REGRA 4
if ((distanceLeft > MEDIA_DISTANCE & distanceLeft < LONG_DISTANCE) & distanceRight <=
MEDIA_DISTANCE) {
direcao.write(LEFT);
delay(15);
analogWrite(pinMotor, SPEED_LOW);
}
else
// REGRA 5
if ((distanceLeft > MEDIA_DISTANCE & distanceLeft < LONG_DISTANCE) & (distanceRight >
MEDIA_DISTANCE & distanceRight < LONG_DISTANCE)) {
direcao.write(CENTER);
delay(15);
analogWrite(pinMotor, SPEED_MIDDLE);
}
else
// REGRA 6
if ((distanceLeft > MEDIA_DISTANCE & distanceLeft < LONG_DISTANCE) & (distanceRight >
LONG_DISTANCE)) {
direcao.write(CENTER);
delay(15);
analogWrite(pinMotor, SPEED_MIDDLE);
}
else
// REGRA 7
if ((distanceLeft > LONG_DISTANCE) & (distanceRight <= MEDIA_DISTANCE)) {
direcao.write(LEFT);
74
delay(15);
analogWrite(pinMotor, SPEED_HIGH);
}
else
// REGRA 8
if ((distanceLeft > LONG_DISTANCE) & (distanceRight > MEDIA_DISTANCE & distanceRight <
LONG_DISTANCE)) {
direcao.write(CENTER);
delay(15);
analogWrite(pinMotor, SPEED_MIDDLE);
}
else
// REGRA 9
if ((distanceLeft > LONG_DISTANCE) & (distanceRight > LONG_DISTANCE)) {
direcao.write(CENTER);
delay(15);
analogWrite(pinMotor, SPEED_HIGH);
}
}
else
// PÁRA MOTOR APÓS ATINGIR O TEMPO PRÉ-DEFINIDO
if (oneTime) {
startTone(3);
oneTime = false;
// CENTRALIZA O SERVOMOTOR
direcao.write(CENTER);
delay(15);
// PARAR O MOTOR
analogWrite(pinMotor, SPEED_STOP);
}
}
![UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIAS ...siaibib01.univali.br/pdf/Sidnei Baron[1].pdf · UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E](https://img.document.onl/doc/110x75/5c6087e109d3f21b6a8b9d28/universidade-do-vale-do-itajai-centro-de-ciencias-baron1pdf-universidade.jpg)
