Algoritmo para Desenvolvimento de Rotas Autônomas Aplicadas A Robótica

Faculdade de Ciência e Tecnologia de Montes Claros
Warley Cândido Peixoto Júnior
ALGORITMO PARA DESENVOLVIMENTO DE

ROTAS AUTÔNOMAS APLICADO À ROBÓTICA
MÓVEL
Montes Claros - MG
2018
ALGORITMO PARA DESENVOLVIMENTO DE ROTAS

AUTÔNOMAS APLICADO À ROBÓTICA MÓVEL
Monografia apresentada ao Curso de Engenha-

ria de Controle e Automação, da Faculdade de
Ciência e Tecnologia de Montes Claros como
parte dos requisitos para obtenção de título de
Engenheiro de Controle e Automação.
Orientador: PROF. YURI ADAN GONÇAL-

VES CORDOVIL
Montes Claros - MG
2018
FUNDAÇÃO EDUCACIONAL DE MONTES CLAROS
Faculdade de Ciência e Tecnologia de Montes Claros
A LGORITMO PARA DESENVOLVIMENTO DE ROTAS

AUTÔNOMAS APLICADO À ROBÓTICA MÓVEL
Esta monografia foi julgada adequada como

parte dos requisitos para obtenção do diploma de
Engenheiro de Controle e Automação. Apro-
vada pela banca examinadora da Faculdade de
Ciência e Tecnologia de Montes Claros.
Prof. Msc. Wesley Oliveira Maia

Coord. do Curso de Engenharia de Controle e
Automação
Banca Examinadora
Prof. Yuri Adan Gonçalves Cordovil

(Professor Orientador)
Yuri Adan Gonçalves Cordovil
Orientador
Prof. Mirla Rocha de Oliveira Ferreira, FACIT
(Professor Convidado)
Mirla Rocha de Oliveira Ferreira
Avaliador 1
Prof. Msc. Wesley Oliveira Maia, FACIT
(Professor Convidado)
Msc. Wesley Oliveira Maia
Avaliador 2
Montes Claros - MG, 13 de Novembro de 2018.

Dedico esta monografia primeiramente a Deus
que tem me sustentado a cada dia, e à todas as
pessoas que me ajudaram a alcançar o objetivo
de tornar-me engenheiro.
AGRADECIMENTOS
Agradeço primeiramente a Deus pela oportunidade de chegar até aqui, pelo sustento e por
conceder-me a sabedoria e o entendimento necessários para trilhar essa longa jornada.
Aos meus pais Warley Peixoto e Joelma Gomes e ao meu irmão Gustavo Gomes pelo amor
incondicional e por não medirem esforços para que este sonho se tornasse possível.
À minha namorada Iêssa Lino pela motivação e incentivo em meio às situações mais
adversas vividas durante o curso.
Ao meu orientador Yuri Adan pela disponibilidade e orientação, elementos essenciais para
a concretização do presente projeto.
Aos familiares, amigos, professores e àqueles que contribuíram de forma direta ou indireta,
meus sinceros agradecimentos.
“E não vos conformeis com este mundo, mas transformai-vos pela renovação da vossa mente,
para que experimenteis qual seja a boa, agradável e perfeita vontade de Deus”
(Bíblia Sagrada, Romanos 12:2)
RESUMO
O presente projeto tem por objetivo criar um algoritmo utilizando o controlador fuzzy capaz de
gerar rotas autônomas. Para alcançá-lo, foi utilizado um software de simulação V-REP juntamente
com o Matlab para a modelagem do controlador fuzzy. O método de pesquisa utilizado tem
caráter descritivo e explicativo, contendo metodologia experimental e análises quantitativas. No
desenvolvimento deste projeto foram utilizados dois softwares: um para a simulação e outro
para a modelagem do controlador. Posteriormente, foi implementado o protótipo responsável
pela validação do algoritmo criado e simulado. Para a criação desse, lançou-se mão de Arduino,
Raspberry e sensores ultrassônicos. Todos os itens citados foram montados em estrutura com
dois motores DC e uma roda universal. Os objetivos propostos foram alcançados, demonstrando
assim a eficiência do algoritmo e a autonomia nas tomadas de decisões, aplicando assim as
técnicas de controle utilizando a ferramenta fuzzy.
Palavras-chave: Rotas autônomas, Fuzzy, Algoritmo, Matlab, Robô.

ABSTRACT
The present project aims to create an algorithm using the fuzzy controlator capable of generating
autonomous routes. To achieve this, a V-REP simulation software was used along with Matlab to
model the fuzzy controller. The research method used is descriptive and explanatory, containing
experimental methodology and quantitative analyzes. In the development of this project two
software were used: one for the simulation and another for the modeling of the controller.
Subsequently, the prototype responsible for validation of the created and simulated algorithm
was implemented. For the creation of this, Arduino, Raspberry and ultrasonic sensors were used.
All the mentioned items were mounted in structure with two DC motors and a universal wheel.
The proposed objectives were achieved, demonstrating the efficiency of the algorithm and the
autonomy in decision making, applying the control techniques using the fuzzy tool.
Keywords: Autonomous Routes, Fuzzy, Algorithm, Matlab, Robot.

LISTA DE ILUSTRAÇÕES
FIGURA 1 – Diagrama simplificado de um neurônio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

FIGURA 2 – Exemplos de funções de pertinência . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
FIGURA 3 – Representação fuzzy do sistema de entrada e saída . . . . . . . . . . . . . . . . . . . . . . . . . 19
FIGURA 4 – Resultado da defuzzificação pelo método (C-o-A) . . . . . . . . . . . . . . . . . . . . . . . . . 19
FIGURA 5 – Resultado da defuzzificação pelo método (C-o-M). . . . . . . . . . . . . . . . . . . . . . . . . 20
FIGURA 6 – Resultado da defuzzificação pelo método (M-o-M) . . . . . . . . . . . . . . . . . . . . . . . . 21
FIGURA 7 – Descrição simplificada de um sistema de controle . . . . . . . . . . . . . . . . . . . . . . . . . 23
FIGURA 8 – Sistema de malha aberta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
FIGURA 9 – Sistema de malha fechada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
FIGURA 10 – Web API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
FIGURA 11 – Diagrama de blocos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
FIGURA 12 – Ambiente de simulação do Software V-REP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
FIGURA 13 – Ferramenta para inserção de lógica fuzzy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
FIGURA 14 – Chassi 2WD Robô . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
FIGURA 15 – Raspberry Pi 3 Model B+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
FIGURA 16 – Arduino UNO R3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
FIGURA 17 – IDE (Ambiente de Desenvolvimento Integrado) . . . . . . . . . . . . . . . . . . . . . . . . . . 34
FIGURA 18 – Driver Motor Ponte H L298N . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
FIGURA 19 – Sensor Ultrassônico HC-SR04 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
FIGURA 20 – Sequência de sinais do sensor HC-SR04 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
FIGURA 21 – Fluxograma de processo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
FIGURA 22 – Cenário 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
FIGURA 23 – Cenário 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
FIGURA 24 – Cenário 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
FIGURA 25 – Robô móvel Pioneer p3dx . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
FIGURA 26 – Onda tipo cone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
FIGURA 27 – Configuração dos sensores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
FIGURA 28 – Controlador Fuzzy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
FIGURA 29 – Funções de pertinência de entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
FIGURA 30 – Funções de pertinência de saída. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
FIGURA 31 – Funções de pertinência gaussmf e gauss2mf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
FIGURA 32 – Cenário 1 com a função gaussmf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
FIGURA 34 – Gráfico da função gaussmf do cenário 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
FIGURA 35 – Cenário 2 com a função gauss2mf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
FIGURA 36 – Gráfico da função gauss2mf do cenário 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
FIGURA 38 – Gráfico da função gaussmf do cenário 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
FIGURA 39 – Cenário 3 com a função gauss2mf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
FIGURA 40 – Gráfico da função gauss2mf do cenário 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
FIGURA 41 – Protótipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
FIGURA 42 – Esquemático de ligação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
FIGURA 43 – Pista 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
FIGURA 44 – Pista 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
FIGURA 45 – Fluxograma do comportamento entre as placas Arduino e Raspberry . . . 54
FIGURA 46 – Gráfico da função gauss2mf da pista 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
FIGURA 47 – Gráfico da função gauss2mf da pista 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
FIGURA 48 – Gráfico de comparação entre a simulação e o protótipo . . . . . . . . . . . . . . . . . . 56
LISTA DE ABREVIATURAS E SIGLAS
ACO Ant Colony Optimization
API Application Programming Interface
CI Circuito Integrado
CLP Controlador Lógico Programável
C-o-A Centro-da-Área
C-o-M Centro-dos-Máximo
CPU Central Processing Unit
GB Giga Byte
IDE Integrated Development Environment
mA Miliampere
M-o-M Média-do-Máximo
PWM Pulse Width Modulation
RAM Random Access Memory
RNA Rede Neural Artificial
USB Universal Serial Bus

SUMÁRIO
INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
CAPÍTULO 1 REVISÃO DA LITERATURA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.1 Redes neurais artificiais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.1.1 Neurônios biológicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.2 Algoritmos genéticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.3 Fuzzy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.3.1 Configuração básica de um controlador fuzzy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.1.1 Funções de pertinência fuzzy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.1.2 Funções de interface de fuzzificação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.1.3 Base de conhecimento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.1.4 Lógica de tomada de decisões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.1.5 Funções da interface de defuzzificação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.3.1.6 Defuzzificação Centro-da-Área (C-o-A) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.3.1.7 Defuzzificação Centro-do-Máximo (C-o-M). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.3.1.8 Defuzzificação Média-do-Máximo (M-o-M) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.4 Neuro-fuzzy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.5 Otimização com colônia de formigas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.6 Sistemas de controle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.6.1 Malha aberta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.6.2 Malha fechada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.7 Circuitos elétricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.8 Microcontroladores e microprocessadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.9 Software V-REP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.9.1 Remote API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.10 Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.11 Elementos sensores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
CAPÍTULO 2 MATERIAIS E MÉTODOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.1 Simulação do ambiente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.2 Modelagem do sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.3 Protótipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.4 Sistema embarcado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.4.1 Raspberry Pi 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.4.2 Arduino UNO R3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.5 Ponte H L298N . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.6 Elementos sensores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
CAPÍTULO 3 RESULTADOS, ANÁLISE E DISCUSSÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.1 Desenvolvimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.1.1 Dimensionamento do robô . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.1.2 Dimensionamento dos sensores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.1.3 Simulações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.1.4 Resultados das simulações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.1.4.1 Cenário 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.1.4.2 Cenário 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.1.4.3 Cenário 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.2 Protótipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.2.1 Resultados do Protótipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.2.1.1 Pista 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.2.1.2 Pista 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
CONSIDERAÇÕES FINAIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
APÊNDICE A – ALGORITMO CONEXÃO V-REP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
APÊNDICE B – FUZZY LOGIC DESIGNER - GAUSSMF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
APÊNDICE C – FUZZY LOGIC DESIGNER - GAUSS2MF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
13
INTRODUÇÃO
A motivação em pesquisa começou com a necessidade de projetar robôs que pudessem

realizar tarefas com algum grau de flexibilidade e resposta em relação ao mundo externo. De
acordo com Luger (2013), o planejamento pressupõe um robô que seja capaz de realizar certas
ações atômicas. Ele procura encontrar uma sequência dessas ações que realize uma tarefa de alto
nível, como por exemplo, mover-se através de uma sala com vários obstáculos.
Luger (2013) afirma que o planejamento é um problema difícil por uma série de razões,
podendo destacar o tamanho do espaço de sequências possíveis de movimento. Mesmo robôs
extremamente simples são capazes de gerar um vasto número de sequências de movimentos
prováveis, por exemplo: um robô pode mover-se para frente ou para trás, para esquerda ou para a
direita. Admite-se ainda que esse mesmo robô encontra-se em uma sala repleta de obstáculos.
Desenvolver um algoritmo inteligente capaz de criar uma rota diante todos esses fatores requer
técnicas refinadas para a busca de soluções possíveis.
Um dos métodos que os seres humanos utilizam para o planejamento é a decomposição
hierárquica do problema. Quando planeja-se uma viagem para Paris, por exemplo, geralmente
o problema é tratado de forma separada como: organizar o voo, chegar ao aeroporto, fazer
as conexões aéreas, mesmo que tais partes sejam integrantes de um problema muito maior.
Distintamente dos seres humanos que planejam com grande facilidade, o desenvolvimento de
programas de computador que façam o mesmo é um grande desafio.
Um robô que executasse cegamente uma sequência de ações sem responder às alterações do
ambiente ou que não fosse capaz de corrigir erros, não seria considerado inteligente. Sendo assim,
um robô deve começar movendo-se pelo ambiente com base no que pôde detectar, corrigindo
o seu caminho conforme outros obstáculos são identificados, de maneira que seja possível
responder às condições variáveis do ambiente (LUGER, 2013).
Tendo em vista a complexidade de planejamento do movimento de um autômato, faz-se
necessária a criação de um algoritmo capaz de solucionar o problema relacionado às rotas
alternativas, permitindo a liberdade desse mesmo autômato na realização de seus movimentos e
nas tomadas de decisões implementadas para que assim, seja possível atingir o seu objetivo final
sem que haja bloqueio por algum obstáculo. Para alcançar a criação de um algoritmo capaz de
gerar rotas autônomas alternativas, utilizaram-se objetivos específicos tais como: modelagem do
controlador, simulação e teste em software e construção de protótipo para tornar as simulações
válidas.
14
CAPÍTULO 1 REVISÃO DA LITERATURA
1.1 Redes neurais artificiais
Redes Neurais Artificiais (RNAs) são sistemas paralelos distribuídos, compostos por
unidade de processamento simples (nodos) que calculam determinadas funções matemáticas
(normalmente não-lineares). Tais unidades são dispostas em uma ou mais camadas, sendo
interligadas por um grande número de conexões, geralmente unidirecionais. Na maioria dos
modelos, estas conexões estão associadas a pesos que armazenam o conhecimento representado
no modelo e servem para ponderar a entrada recebida por cada neurônio da rede. O funcionamento
destas redes é inspirado em uma estrutura física concebida pela natureza: o cérebro humano
(BRAGA; CARVALHO; LUDERMIR, 2000).
Braga, Carvalho e Ludermir (2000) afirmam ainda que as RNAs devem passar por uma
fase de aprendizagem com um conjunto de exemplos apresentados para a rede. A partir desses
exemplos, a rede extrai automaticamente as características básicas para representar a informação
fornecida. A capacidade de “aprender” diante de exemplos e de “generalizar” a informação é o
atrativo principal da solução dos problemas através de RNAs. A generalização, está relacionada
à capacidade da rede em aprender através dos exemplos e, subsequentemente, dar respostas
coerentes aos dados não conhecidos.
1.1.1 Neurônios biológicos
Conforme Duran (2011), uma célula nervosa ou simplesmente neurônio é especializada

em receber impulsos elétricos do próprio organismo ou do ambiente externo. Ela integra as
informações contidas no impulso elétrico e as retransmite para outros neurônios. Para o neurônio
desempenhar suas funções, seu corpo celular, o axônio, os dendritos e as sinapses devem possuir
determinadas características quanto ao modo de gerar, conservar e transmitir impulsos elétricos.
FIGURA 1 – Diagrama simplificado de um neurônio

Fonte: Luger (2013, p. 24)
15
A capacidade de adaptação dos neurônios garante que o robô tome decisões distintas e
autônomas de modo que o objetivo final seja alcançado ou que ele consiga definir qual rota tomar
diante do obstáculo encontrado ao longo do trajeto.
1.2 Algoritmos genéticos
Um algoritmo é qualquer procedimento computacional bem definido que toma algum valor
ou conjunto de valores como entrada e produz algum valor ou conjunto de valores como saída.
Concluindo, um algoritmo é uma sequência de etapas computacionais que transformam a entrada
na saída (CORMEN et al., 2012).
Os algoritmos genéticos são um ramo de algoritmos evolucionários e como tal, podem ser
definidos como uma técnica de busca baseada numa metáfora do processo biológico de evolução
natural.
Nos algoritmos genéticos, populações de indivíduos são criadas e submetidas aos opera-
dores genéticos: seleção, recombinação (crossover) e mutação. Estes operadores utilizam uma
caracterização de qualidade de cada indivíduo como uma solução do problema em questão
chamada de avaliação, gerando um processo de evolução natural destes indivíduos que, eventual-
mente, deverá gerar um indivíduo que caracterizará uma boa solução para o problema (LINDEN,
2006).
1.3 Fuzzy
A lógica fuzzy (também conhecida como lógica nebulosa e em alguns casos por teoria de
possibilidades) é uma forma ousada de manuseio de informações imprecisas. “A lógica fuzzy
provê um método de traduzir expressões verbais, vagas, imprecisas e qualitativas, comuns na
comunicação humana em valores numéricos.” (SIMÕES; SHAW, 1999). Essa tradução abre
portas para a conversão da linguagem humana em uma forma compreensível para o computador.
Os sistemas fuzzy são relativamente fáceis de entender e aplicar na prática, não é necessário
de um conhecimento matemático tão complexo como parece no primeiro contato com a lógica.
Todavia, o projetista do controlador fuzzy necessita de uma vasta compreensão de como as
imprecisões e incertezas ocorrem em processos e plantas industriais e como elas afetam as apli-
cações usuais da teoria de controle moderno, criando possibilidades à verificação da relevância e
confiabilidade dos resultados alcançados através da aplicação da teoria da lógica fuzzy (SIMÕES;
SHAW, 1999).
A lógica fuzzy pode também ser agregada aos sistemas de redes neurais citados na sessão
1.1, os chamados sistemas neuro-fuzzy, que aumentam a capacidade de aprendizado através da
16
interface com os dados numéricos (SIMÕES; SHAW, 1999).
1.3.1 Configuração básica de um controlador fuzzy
Um controlador fuzzy é composto de algumas etapas funcionais, essas etapas são:

a) Interface de fuzzificação;
b) Base de conhecimento;
c) Lógica de tomada de decisões;
d) Interface de defuzzificação.
Para que o controlador funcione, essas estruturas representam a transformação que ocorre
no mundo real, para números reais, ou melhor, para o domínio fuzzy. Na transformação para
o domínio fuzzy é necessário um conjunto de inferência fuzzy que é usado para as tomadas de
decisões, ocorrendo ao final de tudo, a transformação inversa do domínio fuzzy para o domínio
real.
1.3.1.1 Funções de pertinência fuzzy
Simões e Shaw (1999) afirmam que as funções de pertinência representam aspectos

essenciais de procedimentos teóricos e práticos do sistema fuzzy. Uma função de pertinência é
uma função numérica gráfica ou tabulada que adiciona valores de pertinência fuzzy para valores
discretos de uma variável em seu universo de discurso. É importante lembrar que o universo de
discurso de uma variável representa todo o intervalo numérico de todos os valores possíveis que
uma variável pode atribuir-se.
FIGURA 2 – Exemplos de funções de pertinência

Fonte: Desenvolvido pelo autor no software Matlab (2015)
17
A figura 2 mostra dois exemplos de pertinência, onde o eixo vertical representa o intervalo
[0,1] e o eixo horizontal o universo do discurso. É possível perceber que onde a função de
pertinência se anula há coincidência com o eixo horizontal (SIMÕES; SHAW, 1999). As funções
de pertinência apresentadas na imagem são: triangular, e trapezoidal, respectivamente, plotadas
sob o mesmo universo do discurso de uma variável física.
Simões e Shaw (1999) ressalta ainda que a quantidade de funções em um universo de
discurso e seu formato são escolhidos com base na experiência, na dinâmica do processo a
ser controlado. Quanto maior o número de conjuntos, maior a precisão. Porém, a demanda
computacional aumenta de acordo com a inserção de novos conjuntos. Outros formatos além
dos apresentados na imagem podem ser inseridos no conjunto, temos funções do tipo: cos²(x),
gaussiana, sigmoide e spline cúbico (S-shape) (SIMÕES; SHAW, 1999).
1.3.1.2 Funções de interface de fuzzificação
De acordo com Simões e Shaw (1999), os valores discretos (não-fuzzy) das variáveis de
entrada geralmente são originários de sensores das grandezas físicas ou de dispositivos de entrada
computadorizada. A interface de fuzzificação usa funções de pertinência contidas na base de
conhecimento, convertendo os sinais de entrada em um intervalo [0,1].
Por exemplo, Parede, Gomes e Horta (2011) afirmam que o padrão de comunicação 4-20
miliampere (mA) é largamente utilizado como forma de transmitir uma informação do processo
para um elemento de controle ou registro. Ao inserir um controlador fuzzy, ele converte esse
padrão de comunicação de 4-20 mA para um intervalo de [0,1]. Ao final, ocorre a transformação
onde os números convertidos nas etapas anteriores retornam ao padrão utilizado na entrada.
1.3.1.3 Base de conhecimento
Conforme Simões e Shaw (1999), a base de conhecimento simboliza o padrão do sistema

a ser controlado. A base de dados fornece as definições numéricas necessárias às funções de
pertinência que serão usadas no conjunto de regras fuzzy.
1.3.1.4 Lógica de tomada de decisões
“A lógica de tomada de decisões, incorporada na estutura de inferência da base de regras,

usa implicações fuzzy para simular tomadas de decisões humanas.” (SIMÕES; SHAW, 1999).
Ela cria ações de controle a partir de um conjunto de condições de entrada anteriores.
18
1.3.1.5 Funções da interface de defuzzificação
A defuzzificação consiste na volta da conversão feita anteriormente para ser trabalhada no

ambiente fuzzy. Esta função é necessária apenas quando a saída do controlador necessitar ser
interpretada como uma ação de controle discreta (SIMÕES; SHAW, 1999) como por exemplo,
retornar os valores que foram inseridos no controlador fuzzy para os valores de entrada. No
exemplo anterior, o valor de entrada utilizado foi o padrão de comunicação 4-20 mA.
“O sucesso mundialmente reconhecido de sistemas de modelagem e controle baseados em
lógica fuzzy em aplicações industriais, tem comprovado sua utilização como mais uma ferramenta
(ou tecnologia) para as disciplinas de engenharia de controle industrial, manufatura e em sistemas
de tomada de decisão.” (SIMÕES; SHAW, 1999)
Para selecionar o método apropriado de defuzzificação, pode-se analisar a perspectiva
baseada no centroide ou nos valores máximos que ocorrem da função de pertinência resultante.
Os seguintes métodos são utilizados: Centro-da-Área (C-o-A), Centro-dos-Máximo (C-o-M) e
Média-do-Máximo (M-o-M) (SIMÕES; SHAW, 1999).
1.3.1.6 Defuzzificação Centro-da-Área (C-o-A)
O método Centro-da-área é frequentemente chamado de método Centro-de-Gravidade,

pois ele calcula o centro da área composta que representa o termo de saída fuzzy. Esse termo
de saída é constituído pela união de todas as contribuições de regras. Uma desvantagem desse
método é a dificuldade de calcular o universo do discurso se o mesmo não for discreto (SIMÕES;
SHAW, 1999). O cálculo do centro-da-área se da pela seguinte equação 1:
∑︀𝑁
𝑢𝑖 𝜇𝑂𝑈 𝑇 (𝑢𝑖 )
𝑢* = ∑︀𝑖=1
𝑁
(1)
𝑖=1 𝜇𝑂𝑈 𝑇 (𝑢𝑖 )
Onde 𝜇𝑂𝑈 𝑇 (𝑢𝑖 ) é o termo de saída fuzzy composto pela união de todas as contribuições de regras.
Por exemplo, um sistema fuzzy controla a vazão de um processo através da posição de uma
válvula proporcional.
19
(a) Sistema de entrada (b) Sistema de saída

FIGURA 3 – Representação fuzzy do sistema de entrada e saída
Fonte: Simulado pelo autor no software Matlab (2015)
A entrada do sistema fuzzy varia de 0 a 200 litros por segundo. A saída é a posição de uma
válvula normalmente fechada (0 a 100%). Os conjuntos fuzzy de entrada e saída são representados
pela imagem. Se for aplicado o método de defuzzificação centro-da-área serão obtidos resultados
mais precisos, porém a dificuldade do cálculo é elevada.
(a) Vazão em 10% (b) Vazão em 80% (c) Vazão em 160%

FIGURA 4 – Resultado da defuzzificação pelo método (C-o-A)
Na figura acima foi utilizado o método de inferência de Mamdani e o método de defuz-

zificação centro-da-área. Ao observar a figura 4 em relação a figura 5 e 6 percebemos que o
método de defuzzificação (C-o-A) possui uma resposta muito mais precisa na saída em relação
as outras. Simões e Shaw (1999) afirmam que se o método apresenta um pequeno problema,
um deles ocorre quando a função de pertinência não possui sobreposição. Já o outro é que, se
mais de uma regra tiver a mesma saída fuzzy, ocorrerá uma sobreposição de áreas que não serão
consideradas. Esse método também utiliza um grande esforço computacional para o cálculo
sendo uma desvantagem em relação aos outros.
20
1.3.1.7 Defuzzificação Centro-do-Máximo (C-o-M)
Esse método consiste em observar o conjunto fuzzy de saída e determinar os valores de

x de saída para os quais 𝜇(x) é máximo, ou seja, pega os valores de máximo de cada conjunto
que contribui para formar o conjunto C de saída. Em seguida, é calculada a média destes valores
de máximo ponderados pelo grau de pertinência dos respectivos conjuntos (SIMÕES; SHAW,
1999).

FIGURA 5 – Resultado da defuzzificação pelo método (C-o-M)
O cálculo do centro-do-máximo se da pela equação:
𝑀1 𝜇1 + 𝑀2 𝜇2
𝑆= (2)
𝜇1 + 𝜇2
Pode-se perceber que a equação do método (C-o-A) é extremamente semelhante à do
método (C-o-M), exceto pelo fato de que enquanto a equação do método (C-o-A) utiliza as áreas
de cada função de pertinência, a equação do método (C-o-M) usa apenas seus máximos. Os
resultados dos dois métodos são levemente diferentes. Pode-se observar essa ligeira diferença
nas figuras 5 e 6, onde foram usados os métodos (C-o-A) e (C-o-M) respectivamente (SIMÕES;
SHAW, 1999).
1.3.1.8 Defuzzificação Média-do-Máximo (M-o-M)
A defuzzificação pela utilização do método média-do-máximo constitui um dos métodos

mais simples, visto que sua saída é o valor correspondente ao conjunto que possui o maior grau
de pertinência. O cálculo do centro-do-máximo pela equação abaixo:
𝑀1 + 𝑀2
𝑆= (3)
2
21

FIGURA 6 – Resultado da defuzzificação pelo método (M-o-M)
Ao observar os resultados dos três valores de vazão da figura 6, verifica-se que tal método
apresenta grande diferença nos valores de saída em relação aos métodos citados anteriormente.
Entretanto, há uma grande vantagem computacional por apresentar uma equação simples de ser
calculada.
1.4 Neuro-fuzzy
Conforme explanado anteriormente, as redes neurais oferecem características surpreenden-

tes tais como aprendizagem, adaptação, tolerância à falhas e generalização. Uma das vantagens
em se utilizar redes neurais é a capacidade de reconhecimento dos padrões, reconhecimento
de caracteres e formas, controle de processos, estimação de funções não lineares e previsões
financeiras. Na ausência de modelos matemáticos de processos, as redes neurais podem utilizar
históricos de dados iniciais para construir modelos primitivos. Uma vez treinadas, essas redes
são capazes de predizer as reações do processo às novas condições.
TABELA 1
Comparação entre sistemas fuzzy e neurais
Sistemas fuzzy Redes neurais
Aquisição de conhecimento Especialistas humanas Dados numéricos
Método de treinamento Interação/indução Algoritmos/ajuste de pesos
Tipos de incertezas Qualitativa/quantitativa Quantitativa
Raciocínio Busca heurística Computação paralela
Interface linguística Explícita Não evidente
Tolerância a falhas Não evidente Muito alta
Robustez Muito alta Muito alta
Fonte: Shaw e Simões (1999, p.115)
A tabela 1 exibe uma comparação entre os sistemas fuzzy e redes neurais, indicando que
a combinação das características de lógica fuzzy e redes neurais trazem soluções de controle
inteligentes e possíveis soluções para as rotas autônomas (SIMÕES; SHAW, 1999).
22
1.5 Otimização com colônia de formigas
Otimização com Colônia de Formigas, mais conhecida na literatura por sua forma na
língua inglesa “Ant Colony Optimization” (ACO), corresponde a uma classe de algoritmos que
geram soluções para um problema de otimização através de um mecanismo construído a partir
do componente da solução a ser adicionado em cada passo. A ideia central dessa meta-heurística
consiste em simular o processo de acúmulo e evaporação do ferormônio excretado pelas formigas
reais (SILVA, 2003).
1.6 Sistemas de controle
Um sistema de controle consiste em subsistemas e processos (ou plantas) construídos com

objetivo de se obter uma saída desejada com um desempenho desejado, dada uma entrada especi-
ficada (NISE, 2013). Com os sistemas de controle, foi possível mover equipamentos pesados com
uma precisão que, anteriormente à criação destes, seria impossível. A partir da implementação
dos sistemas de controle em indústrias, foram obtidos alguns avanços tecnológicos e científicos,
culminando em benefícios como:
a) Padronização de produtos;
b) Qualidade;
c) Redução de custos;
d) Redução dos riscos;
e) Flexibilidade.
De acordo com Nise (2013) os sistemas de controle foram construídos por quatro razões
principais:
a) Amplificação de potência;
b) Controle remoto;
c) Conveniência da forma da entrada;
d) Compensação de pertubações.
A figura a seguir mostra um sistema de controle em sua forma mais simples, na qual a
entrada representa uma saída desejada.
23
FIGURA 7 – Descrição simplificada de um sistema de controle

Fonte: Nise (2012, p. 2)
Apesar de o sistema demonstrado possuir apenas uma entrada e uma saída em sua forma
mais simples, demonstrar-se-ão ao longo do desenvolvimento do projeto, sistemas com realimen-
tações e incrementos de outros blocos que promovem melhorias dos mesmos.
1.6.1 Malha aberta
Na figura 7 foi representado um sistema de controle com a forma mais simples. Nesta seção
e na seção seguinte serão apresentados dois tipos de configurações dos sistemas de controle. É
possível considerar essas configurações como sendo a arquitetura interna do sistema total.
Para total entendimento de um sistema em malha aberta, iremos considerar o diagrama de
blocos de um sistema em malha aberta genérico. Ele é começado com um subsistema chamado
transdutor de entrada, o qual converte a forma de entrada em uma a ser utilizada pelo controlador.
Transdutores são dispositivos que convertem grandezas físicas em grandezas elétricas (DORF;
SVOBODA, 2008). O controlador, então, aciona um processo ou planta. Perturbações são
mostradas adicionados a saída do controlador que ao final são acrescentados na soma algébrica.
A entrada pode ser chamada, algumas vezes, de referência, enquanto a saída, variável controlada.
Para exemplificar esse sistema de controle, a planta pode ser uma caldeira, no qual a variável de
saída é a temperatura.
FIGURA 8 – Sistema de malha aberta

Os sistemas de malha aberta não possuem correção para perturbações e são comandados
apenas pela entrada. Nise (2013) exemplifica os sistemas de malha aberta utilizando uma
torradeira, onde só é possível verificar a variável controlada (saída) a partir da visualização da
24
cor da torrada. O dispositivo não mede a cor da torrada, nem efetua correções quanto ao tipo de
pão ou o formato do mesmo.
1.6.2 Malha fechada
As desvantagens dos sistemas em malha aberta como a sensibilidade às perturbações e as

dificuldades de corrigir seus efeitos, foram superadas nos sistemas em malha fechada. Na figura
9 é possível verificar a arquitetura genérica de um sistema em malha fechada.
FIGURA 9 – Sistema de malha fechada

Ao comparar o sistema em malha aberta com o sistema em malha fechada, verifica-se que
foi adicionado um transdutor de saída ou sensor no diagrama de blocos. A primeira junção de
soma adiciona o sinal de entrada ao sinal de saída, que chega através da malha de realimentação,
ao caminho de retorno da saída para a junção soma. O sinal de saída é subtraído ao sinal de
entrada, sendo o resultado chamado de sinal de atuação ou erro (NISE, 2013). O valor do sinal
de atuação é igual à diferença real entre a entrada e a saída.
Os sistemas em malha fechada conseguem reagir melhor às perturbações quando compa-
rados aos sistemas em malha aberta, pois com a realimentação é possível comparar o sinal de
entrada com o efeito da perturbação e, caso exista alguma diferença entre as duas respostas, o
atuador faz a correção na planta a fim de eliminar tais diferenças.
1.7 Circuitos elétricos
“Um circuito elétrico é um conjunto de componentes elétricos ligados entre si de modo a

formar um percurso fechado através do qual possa circular uma corrente” (DORF; SVOBODA,
2008, p. 1). “Um circuito elétrico é um modelo matemático que se comporta aproximadamente
como um sistema elétrico real” (NILSSON; RIEDEL, 2008, p. 3).
25
A partir dessas duas definições depreende-se que, para alcançar um circuito elétrico com
componentes eletrônicos, é necessário simular em um modelo matemático de maneira a observar
o comportamento aproximado daquele circuito.
1.8 Microcontroladores e microprocessadores
Conforme Dias Júnior (1990), um microcomputador é um sistema formado por um ou

mais circuitos integrados que utilizam a lógica digital e os semicondutores para executar grandes
quantidades de funções computacionais em pequena proporção.
Um microprocessador, também conhecido como Unidade Central de Processamento (CPU),
analogamente ao ser humano, corresponderia ao cérebro. Fisicamente, é um dispositivo semi-
condutor (circuito integrado, CI) constituído por milhões de transistores que implementam
uma variedade de circuitos (registradores, máquinas, circuitos lógicos). Ele é responsável pela
execução do programa que foi inserido em sua memória (GIMENEZ, 2002).
Gimenez (2002) afirma ainda que o microcontrolador completa todas as partes básicas de
um microcomputador, microprocessador (CPU), memórias, porta de entrada e portas de saída. É
possível dizer que ele é um microcomputador completo em um único CI.
Os microcontroladores são utilizados em aplicações especificas onde não é necessária
grande quantidade de armazenamento de dados, por exemplo: automação residencial, automação
predial, automação industrial e automação embarcada. Na automação residencial, podem ser
exemplificados os fornos microondas, máquinas de lavar louças, telefones, alarmes residenciais
e gerenciamento de iluminação.
A automação industrial é uma área que vem ganhando grande espaço nos últimos anos.
O uso de dispositivos e aplicações de soluções inteligentes para a resolução de problemas que
melhoram o trabalho perigoso e monótono do ser humano, trazem melhoria na qualidade dos
processos produtivos, otimização dos espaços, redução no tempo de produção e diminuição de
custos (PAREDE; GOMES; HORTA, 2011).
Alguns exemplos de automação industrial:
a) Robótica;
b) Controladores lógicos programáveis (CLPs);
c) Controladores de acesso restrito;
d) Relógios de ponto;
26
1.9 Software V-REP
O simulador V-REP é um ambiente de simulação integrado, baseado em uma arquitetura de

controle distribuído, onde cada objeto pode receber códigos, plugins, ROS, BlueZero e clientes
API’s remotos. Isso faz com que o V-REP seja flexível e ideal para aplicações diversas. O
V-REP tem suporte para ser programado em C/C++, Python, Java, Lua, MatLab, Octave ou Urbi
(ROBOTICS, 2018).
A seguir podemos observar algumas aplicações do V-REP:
a) Simulação de sistemas de automação de fábrica;
b) Monitoramento remoto;
c) Controle de Hardware;
d) Rápida prototipagem e verificação no ambiente virtual;
e) Monitoramento de segurança;
f) Desenvolvimento e integração rápida do algoritmo.
1.9.1 Remote API
A Remote API faz parte da estrutura do V-REP “Application Programming Interface(API)”

em português “Interface de Programação de Aplicações”, consistem em um conjunto de rotinas
e padrões de programação para acesso de um aplicativo, software ou plataforma baseado na Web
(MASSE, 2012).
FIGURA 10 – Web API

Fonte: Massé (2012, p. 6)
Como podemos observar na figura 10 a API é face de um serviço Web, que escuta e
responde às solicitações do cliente diretamente (MASSE, 2012).
27
1.10 Arduino
Margolis (2012) diz que o Arduino é uma família de microcontroladores de pequeno porte,
que possui um ambiente de criação de software, facilitando a criação de programas que podem
interagir com o mundo físico. Tais componentes podem ser sensores que recebem estímulos
do ambiente físico e os convertem em sinais de entrada enviados ao microcontrolador que,
em seguida, leem essas informações e as interpretam. Baseado nas informações recebidas, o
microcontrolador toma decisões e atua no processo de acordo com a modelagem do sistema.
FIGURA 11 – Diagrama de blocos

Fonte: Wheat (2015, p.2)
O Arduino baseado no microcontrolador ATmega possui entradas e saídas digitais, entradas

analógicas e PWM, uma unidade de alimentação de tensão e uma unidade de conexão através de
barramento de dados (USB). A figura 11 mostra um diagrama de blocos simplificados possuindo
os componentes básicos do Arduino (WHEAT, 2011).
1.11 Elementos sensores
Os sensores são a interface perceptiva entre robôs e seus ambientes (NORVIG; RUSSELL,
2013). Diversos tipos de sensores estão disponíveis para coleta de um processo de produção
e utilização no controle por realimentação (feedback). Segundo Groover (2011), um sensor é
um transdutor ou dispositivo que converte um estímulo físico ou uma variável de interesse, por
exemplo, temperatura, pressão ou deslocamento, em uma forma mais conveniente, em geral um
sinal elétrico como a voltagem que tem como objetivo medir o estímulo.
Na robótica os sensores são utilizados em grande escala, pois um robô sem sensor é
simplesmente uma máquina, ou seja, é necessário que este possua sensores que percebam o
28
mundo ao seu redor, podendo reagir a determinados estímulos externos. Os sensores têm por
objetivo auxiliar o robô na execução de tarefas ajudando-o a determinar os parâmetros do
ambiente que o cerca (ROSÁRIO, 2005).
29
CAPÍTULO 2 MATERIAIS E MÉTODOS
Este capítulo tem como objetivo a apresentação dos materiais e métodos que foram
necessários para a construção do algoritmo, bem como os tipos de pesquisa essenciais para a
realização dos acontecimentos.
2.1 Simulação do ambiente
Para o projeto do protótipo foram utilizados programas computacionais também denomina-

dos softwares, para simular o ambiente e facilitar os cálculos realizados. O software empregado
para a simulação computacional foi o V-REP, que cria um ambiente para a inserção dos robôs
a serem testados. Foram acrescentados também os sensores e os obstáculos a serem desviados
pelo robô.
FIGURA 12 – Ambiente de simulação do Software V-REP

Fonte: Acervo do autor
Na figura 12 é possível visualizar o ambiente de simulação principal para testes com os

sensores, posicionamento dos sensores, inserção de obstáculos, criação de diferentes pistas e
outros recursos empregados para melhoria da pesquisa e entendimento.
30
2.2 Modelagem do sistema
Como houve a simulação de um ambiente com obstáculos onde o robô deveria tomar
decisões autônomas para alcançar o objetivo, foram necessárias técnicas de controle e modelagem
do sistema para obter-se o resultado desejado. Para auxílio das simulações e modelagem utilizou-
se softwares como o MatLab, desenvolvido pela empresa MathWorks® com matriz situada na
cidade de Natick, Massachusetts nos Estados Unidos. Esse software possui ferramentas como
a de simulação fuzzy, onde foram inseridos os valores de pertinências, as regras e o método
utilizado para calcular os valores de saída.
FIGURA 13 – Ferramenta para inserção de lógica fuzzy

A figura 13 mostra a ferramenta de inserção de lógica fuzzy. Nela inseriram-se as regras e

as funções de pertinência para a modelagem do sistema.
2.3 Protótipo
Para a construção do protótipo foram utilizados Chassi 2WD Robô, onde encontram-se os
sensores juntamente com os sistemas embarcados: Raspberry Pi 3 e arduino uno R3. A imagem
a seguir demonstra o chassi do robô empregado nos testes de rotas alternativas.
31
FIGURA 14 – Chassi 2WD Robô

Fonte: Filipe Flop (2015)
O Chassi é composto de acrílico revestido por uma película adesiva para proteção contra
arranhados. Ambos os motores DC possuem caixa de redução (1:48) e são conectados indepen-
dentemente em cada roda, sobrando assim uma roda boba (universal) para dar sustentação. Possui
ainda dois discos de encoder acoplado nas rodas para medir a rotação, oferecendo possibilidades
à realização de testes de velocidade.
2.4 Sistema embarcado
O sistema embarcado é de grande importância, visto que constitui parte do circuito ele-
trônico que, através de microcircuitos, estabelece a lógica de controle, ou seja, nele aplica-se
diretamente o algoritmo que representa o controlador. O sistema embarcado usado foi a Raspberry
Pi 3 objetivando rodar o algoritmo alimentado com os dados coletados pelos sensores, tomando
assim as decisões necessárias e enviando-os diretamente ao arduino uno R3 responsável pela
leitura e controle da velocidade dos motores, assim como o envio de tais dados por intermédio
da comunicação USB serial.
2.4.1 Raspberry Pi 3
A figura 15 exibe a Raspberry Pi 3 Model B+, uma placa constituída por um processador
com clock de 1.2GHz capaz de executar diversas distribuições Linux como o Raspbian que foram
empregadas nesse projeto. Além disso, a placa possui 1GB de memória RAM, adaptador para
cartão microSD e saída para áudio e vídeo.
32
FIGURA 15 – Raspberry Pi 3 Model B+

Fonte: RaspberryPi (2018)
De acordo com a RaspberryPi (2018) seguem as especificações:
TABELA 2
Especificações da Raspberry Pi 3
Especificação Dados
Chip Broadcom BCM2837B0, Cortex-A53 (ARMv8) 64-bit
Modelo Raspberry Pi 3 Model B+
Tensão de operação 5V, 2.5A
GPIO 40
Portas USB 4 USB 2.0
Memoria RAM 1GB LPDDR2 SDRAM
Clock 1.2 GHz
Conector Ethernet 100 Base Ethernet
Saída HDMI 1
Saída de Áudio 1
Saída de Display (DSI) 1
Saída de Câmera (CSI) 1
Dimensões 85 x 56 x 17mm
Fonte: (RASPBERRYPI, 2018)
2.4.2 Arduino UNO R3
A figura 16 mostra o arduino uno R3, uma placa composta por um microcontrolador Atmel,
circuitos de entrada/saída, que pode ser facilmente conectada à um computador e programada
via IDE (Integrated Development Environment, ou Ambiente de Desenvolvimento Integrado)
33
utilizando uma linguagem baseada em C/C++, sem a necessidade de equipamentos extras além
de um cabo USB.
FIGURA 16 – Arduino UNO R3

Fonte: Arduino (2018)
De acordo com Arduino (2018) seguem as especificações do microcontrolador Arduino

UNO R3:
TABELA 3
Especificações do arduino uno R3
Chip ATmega328P
Modelo UNO R3
Tensão de operação 5V
Tensão de entrada 7-12V
Tensão máxima e mínima de entrada 6-20v
Entradas digitais 14
Saídas PWM 6
Entradas Analógicas 6
Memoria Flash 32kb
SRAM 2 KB (ATmega328P)
EEPROM 1 KB (ATmega328P)
Clock 16 MHz
Dimensões 68.6mmx53.4mm
Peso 25g
Fonte: Arduino (2018)
34
FIGURA 17 – IDE (Ambiente de Desenvolvimento Integrado)

Fonte: O autor
O software open-source é o ambiente que facilita a escrita do código e envio à placa.

Ele é executado no Windows, Mac OS X e Linux. O ambiente é escrito em java e baseado em
processamento de outros softwares de código aberto. A IDE pode ser usada com qualquer placa
arduino. O software também possui o Web Editor, que pode ser programado na nuvem. Nela é
possível obter sempre as versões mais recentes da IDE, incluindo todas as bibliotecas e suporte
para as placas arduino. A IDE do arduino possui vários exemplos básicos importantes para a
criação da programação. Na figura 17 foi inserido um código do efeito blink utilizando um dos
exemplos que a IDE fornece.
2.5 Ponte H L298N
Este Driver Motor Ponte H é baseado no chip L298N, construído para controlar cargas
indutivas como: relés, solenoides, motores DC e motores de passo. Com este Driver é possível
controlar independentemente a velocidade e rotação de dois motores DC ou um motor de passo
(FILIPEFLOP, 2018).
35
FIGURA 18 – Driver Motor Ponte H L298N

Fonte: FilipeFlop (2018)
De acordo com FilipeFlop (2018) os atributos desse módulo são:
TABELA 4
Especificações da Ponte H L298N
Tensão de operação 4 35V
Chip ST L298N
Corrente de operação máxima 2A por canal ou 4A máxima
Tensão lógica 5v
Corrente lógica 0 36mA
Limites de Temperatura -20 a +135°C
Potência Máxima 25W
Dimensões 43mm x 43mm x 27mm
Para o desenvolvimento protótip,o o driver motor ponte H será de grande importância,

pois é com ele que serão controlados os dois motores DC. O driver motor possui 4 entradas no
barramento, IN1, IN2, IN3 e IN4 responsáveis pela rotação do motor. Existem 2 pinos, um do
lado da entrada IN1 e o outro ao lado da entrada IN4, que são responsáveis pelo controle PWM
dos motores da esquerda e da direita, respectivamente.
2.6 Elementos sensores
Os sensores foram de grande importância para o projeto, haja vista que são os olhos do
robô. De acordo com Rosário (2005), os sensores têm o objetivo de auxiliar o robô na execução
de tarefas ajudando-o a determinar os parâmetros do ambiente que o cerca.
36
FIGURA 19 – Sensor Ultrassônico HC-SR04

Fonte: ElecFreaks
Na figura 19 foi apresentado o sensor ultrassônico HC-SR04, que é um componente muito

comum em projetos com arduino, e permite que sejam realizadas leituras de distâncias entre 2 cm
e 4 metros, com precisão de 3 mm. Pode ser utilizado tanto para medir a distância entre o sensor
e um objeto quanto para acionar portas do microcontrolador, desviar um robô de obstáculos e
acionar alarmes.
O funcionamento do HC-SR04 é baseado no envio de sinais ultrassônicos pelo sensor,
que aguarda o retorno (echo) do sinal que, com base no tempo entre envio e retorno, calcula a
distância entre o sensor e o objeto detectado.
FIGURA 20 – Sequência de sinais do sensor HC-SR04

Primeiramente, é enviado um pulso de 10µs, indicando o início da transmissão de dados.

Depois disso, são enviados 8 pulsos de 40 Hz e o sensor, então, aguarda o retorno (em nível
alto/high) para determinar a distância entre o sensor e o objeto utilizando a equação:
𝑇 *𝑉
𝐷= (4)
2
Onde D é a distância, T = tempo echo em nível alto e V = velocidade do som (340m/s).
37
TABELA 5
Especificações do Sensor ultrassônico HC-SR04
Tensão de operação 5V
Corrente de operação 15mA
Frequência de trabalho 40Hz
Distância mínima 2cm
Distância máxima 4m
Ângulo de trabalho 15º
Dimensões 45mmx20mmx15mm
Fonte: ElecFreaks
A tabela 5 mostra as especificações do sensor ultrassônico HC-SR04, tabela de grande

importância para as ligações futuras com os outros componentes, responsável por mostrar as
especificações do sensor.
38
CAPÍTULO 3 RESULTADOS, ANÁLISE E DISCUSSÃO
Neste capítulo serão apresentados os resultados obtidos a partir do desenvolvimento do

objetivo proposto, bem como a discussão a respeito do algoritmo desenvolvido. A implementação
e os testes do projeto foram realizados utilizando o MatLab juntamente com o software de
simulação de ambiente para robôs, testado em um protótipo que utiliza sistemas embarcados na
sua construção e elementos sensores.
3.1 Desenvolvimento
O presente projeto foi iniciado a partir da ideia de criar um algoritmo capaz de tomar
decisões autônomas gerando rotas alternativas de modo que o objetivo de chegar ao final do
percurso fosse alcançado. O fluxograma de processo mostrado abaixo ilustra o comportamento
do robô para tomadas de decisões em relação ao percurso.
FIGURA 21 – Fluxograma de processo

Fonte: O Autor
Após a análise da ideia explícita ao longo do capítulo, iniciou-se o desenvolvimento dos

ambientes de simulação utilizados para os testes. Com o auxílio do software V-REP foi possível
realizar simulações reais de prováveis obstáculos que poderiam ao longo do trajeto do robô.
Foram criados três cenários para a comprovação da eficácia do algoritmo.
39
FIGURA 22 – Cenário 1
Fonte: O Autor
A figura 22 demonstra o primeiro cenário após a criação. Como recursos do software,

foram adicionados o gráfico de posição, para verificar o trajeto registrado pelo robô, e uma outra
perspectiva de câmera, para auxiliar na visualização da trajetória.
Fonte: O Autor
40
No cenário 2, observado na figura anterior, foram acrescentados alguns obstáculos de

diferentes tamanhos para início dos primeiros testes de detecção dos sensores e tomada de
decisão do algoritmo.
Fonte: O Autor
Na figura 24, além de possuir os obstáculos do cenário 2, foram acrescentadas pessoas

para a simulação de obstáculos em movimento, aumentando a confiabilidade do algoritmo sendo
que o mesmo tem autonomia para definir sua trajetória ao longo do cenário.
3.1.1 Dimensionamento do robô
O software V-REP possui um grande acervo de robôs para serem utilizados em testes no
simulador, dentre eles, manipuladores robóticos, drones, veículos, humanoides, hexapod.
41
FIGURA 25 – Robô móvel Pioneer p3dx

Fonte: Simulado no software V-REP pelo Autor
Para os testes de simulação nos cenários, utilizou-se um robô móvel conhecido como
pioneer p3dx. Esse robô se assemelha ao robô utilizado no protótipo, possuindo dois motores DC,
que podem ser controlados independentes e uma roda universal, dezesseis sensores ultrassônicos
sendo que oito desses sensores estão localizados na parte de trás do robô e os demais, na frente.
3.1.2 Dimensionamento dos sensores
Os sensores utilizados foram do tipo ultrassônico com configurações equivalentes ao sensor

HC-SR04. A distância de detecção apresentava um ângulo de 30º a uma distância de quatro
metros. A seguir pode-se observar a área de propagação das ondas do som utilizadas para a
detecção de objetos. Na figura abaixo é possível visualizar como é o comportamento da onda
tipo cone e o que pode ser alterado de acordo com a aplicação.
FIGURA 26 – Onda tipo cone

Fonte: V-REP User Manual
42
De acordo com Robotics (2018) o sensor de proximidade do tipo cone permite melhor e
mais precisa modelagem da maioria dos sensores de proximidade. Os sensores de proximidade
operam de maneira geometricamente exata visto que realizam o cálculo da distância entre o seu
ponto de detecção e o objeto detectável. É possível observar na figura 27 que as configurações
do sensor foram baseadas na figura 26 que mostra perfeitamente as opções que foram utilizadas
e o que impactaria na área cônica.
FIGURA 27 – Configuração dos sensores

Fonte: O Autor
Por padrão, permaneceram as configurações de Inside gap, Radius, Face count, Subdivisi-
ons e Subdivisions far, mantendo as semelhanças em relação ao sensor ultrassônico do modelo
HC-SR04.
3.1.3 Simulações
Após a criação dos cenários, o posicionamento dos sensores e à escolha do robô, deu-se
inicio as simulações. Para que fossem possíveis as simulações era necessário realizar a comu-
nicação entre o software V-REP e o software Matlab. Tal comunicação é feita pela utilização
das API’s fornecidas pelos desenvolvedores do V-REP, remoteApiProto.m, remApi.m e remote-
Api.dll. A conexão foi estabelecida pelo localhost do Windows utilizando a porta 19999. A seguir,
apresenta-se o código padrão disponibilizado pelos desenvolvedores do V-REP para estabelecer
a comunicação entre o Matlab e o software simulador.
1 %Cria uma API remota usando o arquivo(remoteApiProto.m)

2 vrep = remApi(’remoteApi’);
3 %Verifique se todas as conexoes anteriores foram fechadas
43
4 vrep.simxFinish(-1);
5 %Inicia a conexao com o endereco de IP e a porta(estes sao valores
padroes)
6 clientID = vrep.simxStart(’127.0.0.1’,19999,true,true,5000,5);
7 %Confirmando a conexao
8 if (clientID>-1)
9 disp(’Connected to remote API server’);
Para implementar o controlador fuzzy, inicialmente foram criadas as funções de pertinência

que descrevem as características do sistema. Apos a criação, estabeleceram-se as regras de
inferência que determinam como o sistema deveria reagir em situações específicas. As regras
foram criadas baseadas no conhecimento obtido pelo estudo do modelo do robô. Esses parâmetros
foram implementados na toolbox Fuzzy Logic Designer do Matlab. Foram utilizadas três entradas
e duas saídas. As entradas são os sensores ultrassônicos divididos em três grupos: os sensores da
esquerda, os sensores do centro e os sensores da direita. As saídas são os motores DC controlados
pelo PWM aplicado em cada motor para a movimentação do robô.
FIGURA 28 – Controlador Fuzzy

Fonte: O Autor
Na figura acima tem-se a estrutura do controlador fuzzy utilizado para os testes no simulador,
seguida de inserção no protótipo para validação da funcionalidade. Os blocos “distância-frente”,
“distância-esquerda” e “distância-direita”, estão implementados com as funções de pertinência
input(entrada) responsáveis pelo processamento dos sensores que alimentarão as regras com os
valores e, logo após, o controle e o envio da resposta do controle para os blocos de saída. Os
blocos “velocidade-esquerda” e “velocidade-direita” são aqueles responsáveis pelas pertinências
do tipo output(saída). Neles foram utilizadas constantes com valores pré definidos segundo as
regras.
44
FIGURA 29 – Funções de pertinência de entrada

Fonte: O Autor
Para os blocos de entrada utilizaram-se as funções de pertinência representadas pela figura

acima. Dividido novamente em três funções do tipo gaussiana, o range foi de quatro metros
considerando o parâmetro de distância inserido para detecção dos sensores ultrassônicos.
FIGURA 30 – Funções de pertinência de saída

Fonte: O Autor
Os blocos de saída utilizaram funções de pertinência do tipo constante, podendo ser

visualizadas na figura 30. Foi definida como constante a função de pertinência da saída com base
na experiência e levou-se em consideração a dinâmica do processo a ser controlado, por exemplo:
supõe-se que o robô tivesse a frente livre para deslocar. Os sensores frontais não detectariam
obstáculos e a entrada de valores nas regras aumentaria gradativamente, forçando os motores a
45
aumentarem sua velocidade. A partir disso, foram definidas faixas de valores onde o controlador
fuzzy pudesse trabalhar de acordo com as entradas.
3.1.4 Resultados das simulações
Serão apresentados os resultados obtidos com os testes realizados com o controlador

fuzzy juntamente com os softwares MatLab e V-REP. O objetivo dos testes fazendo uso do
simulador é validar o controlador para utilizá-lo no protótipo físico. Os testes foram divididos
em duas rodadas de simulações. Para a primeira rodada, foi utilizada a função de pertinência do
tipo gaussmf que pode ser visualizada na figura 31. Já para a segunda rodada de testes, foram
utilizadas as funções de pertinência do tipo gauss2mf.
(a) Curva gaussmf (b) Curva gauss2mf

FIGURA 31 – Funções de pertinência gaussmf e gauss2mf
Fonte – Simulado no software Matlab pelo autor
A fórmula utilizada pelo Matlab para se obter a curva do gaussmf e do gauss2mf é dada
abaixo:
(
− 𝑥−𝑒2 )
𝑓 (𝑥; 𝜎, 𝑐) = 𝑒 2𝜎 2 (5)
A função gauss2mf é uma combinação de dois desses dois parâmetros. A primeira função,
especificada por sig1 e c1, determina a forma da curva mais à esquerda. A segunda função
especificada por sig2 e c2 determina a forma da curva mais à direita. Sempre que c1 < c2, a
função gauss2mf atinge um valor máximo de um. Caso contrário, o valor máximo é menor que
um (MATHWORKS, 2018).
46
3.1.4.1 Cenário 1
O primeiro teste foi realizado no cenário mais simples, utilizado apenas para calibração
das posições do sensores ultrassônicos, testes de conexão entre o simulador e o MatLab e ajustes
no controlador fuzzy.
FIGURA 32 – Cenário 1 com a função gaussmf

Fonte: Simulado pelo Autor no software V-REP
É possível observar na figura 32 a validação do primeiro cenário utilizado para o teste. O

cenário é composto por quatro paredes sem a utilização de obstáculo. Foi inserido um gráfico de
posição para observar o trajeto realizado pelo robô durante a simulação.
3.1.4.2 Cenário 2
No segundo cenário, foram implementados os primeiros obstáculos como desafio. Abaixo

a figura que representa o trajeto feito pelo robô.
47

É possível verificar no gráfico de velocidade que, nos primeiros 10 segundos de simulação,

os motores permanecem com a velocidade “rapido” como definida na modelagem do controlador
fuzzy. O sensor, ao perceber o primeiro obstáculo localizado à direita, reduz a velocidade do
motor esquerdo para “reverso” e mantém a velocidade do motor direito em “normal” para efetuar
o desvio da primeira obstrução.
FIGURA 34 – Gráfico da função gaussmf do cenário 2

Fonte: Gráfico gerado no software Matlab pelo autor
48
Na figura acima, pode-se observar o comportamento dos motores ao longo da trajetória do

cenário 2 utilizando a função de pertinência gaussmf.
FIGURA 35 – Cenário 2 com a função gauss2mf

A figura acima mostra o teste realizado no cenário 2 utilizando as funções de pertinência

do tipo gauss2mf sendo perceptível que o robô amenizou nas curvas onde os obstáculos foram
detectados. Na figura abaixo, tem-se o resultado do comportamento dos motores com a função
de pertinência gauss2mf.
49
FIGURA 36 – Gráfico da função gauss2mf do cenário 2

Na figura 36 é possível perceber que a variação ao longo do trajeto foi mais suave do que a
resposta do gráfico da figura 34, onde a variação dos motores foi bem alta.
3.1.4.3 Cenário 3
No cenário 3 foi implementada a simulação de pessoas em movimento, para a validação

da resposta do controlador quanto ao surgimento inesperado de obstáculos. Foram utilizadas
duas pessoas com rotas distintas. A primeira pessoa, localizada no canto inferior esquerdo, faz
o deslocamento subindo o cenário. Já a outra pessoa localizada no canto superior direito faz
o movimento contrário, deslocando para a parte debaixo. A primeira pessoa tem a função de
chegar pela parte traseira do robô para que se faça o teste de percepção além da observância de
tomada de decisão, enquanto a segunda pessoa chega pela frente do robô para validar a tomada
de decisão quanto ao obstáculo que surgiu rapidamente.
50

Fonte: Simulado pelo autor no software V-REP
A cor magenta representa a trajetória do robô enquanto a cor verde representa a trajetória
da pessoa que saiu da posição superior direita. Não obstante, a cor azul representa o trajeto feito
pela pessoa posicionada no canto inferior esquerdo. É possível perceber, no inicio da trajetória
do robô, o desvio feito por este visando sair do deslocamento da pessoa posicionada no canto
inferior esquerdo. Ao final do trajeto, o robô efetuou um desvio do deslocamento de outra pessoa
que apresenta o percurso demonstrado em verde, curvando levemente para a esquerda.
FIGURA 38 – Gráfico da função gaussmf do cenário 3

51
A figura 38 representa o gráfico pertinência de saída x tempo em segundos gerado na

simulação do cenário 3, utilizando a função de pertinência gaussmf.
FIGURA 39 – Cenário 3 com a função gauss2mf

Fonte: Simulado pelo autor no software V-REP
A mesma situação que ocorreu no cenário 2 com a função de pertinência gauss2mf, pode
ser encontrada no cenário 3. A função gauss2mf reduziu as curvas bruscas geradas pela função
gaussmf.
FIGURA 40 – Gráfico da função gauss2mf do cenário 3

52
Por fim, é possível analisar a figura anterior e perceber o comportamento dos motores ao
longo da trajetória. Nos três pontos onde ocorreu desvio dos obstáculos, a função de pertinência
do tipo gauss2mf se manteve com as variações dos motores mais amenas em relação ao desvio
no teste feito com a função de pertinência do tipo gaussmf.
3.2 Protótipo
Após todos os testes e simulações nos cenários com o auxílio do software V-REP e Matlab,
foi construído o protótipo para aplicação do controlador fuzzy. Na figura 41 é possível visualizar
o protótipo construído. Para a construção, utilizaram-se quatro sensores ultrassônicos: três à
frente e um atrás conforme a modelagem do sistema fuzzy e simulações no software V-REP. De
acordo com os resultados coletados pelas simulações, foi escolhido como função de pertinência
o gauss2mf por apresentar melhores resultados.
FIGURA 41 – Protótipo
Fonte: Construido pelo autor
Na figura a seguir é possível visualizar o desenho esquemático de ligação dos sensores e

da ponte H ao Arduino.
53
FIGURA 42 – Esquemático de ligação

Fonte: Construído pelo autor no software Fritzing
O Arduino é o responsável por receber os dados dos sensores e enviar, por meio da USB
serial, à Raspberry. Esta irá processar os dados e retorná-los ao Arduino, que fará o acionamento
dos motores conforme o comando da Raspberry.
Em seguida confeccionou-se a pista para testes com o robô. A primeira pista pode ser
visualizada na figura abaixo. Esta é semelhante ao cenário 1 construído na figura 32 da simulação.
Este cenário foi necessário para os ajustes dos sensores.
FIGURA 43 – Pista 1
Fonte: Construído pelo autor
54
A segunda pista é demonstrada na figura abaixo, assemelhando-se ao cenário 2 da 43,

servindo como base de comparação dos resultados.
FIGURA 44 – Pista 2
Fonte: Construído pelo autor
A comunicação entre a Raspberry e o Arduino foi dada pela USB serial. A placa res-
ponsável para o processamento do controlador fuzzy foi a Raspberry juntamente à biblioteca
scikit-fuzzy. Na biblioteca scikit-fuzzy aplicou-se a mesma configuração do controlador fuzzy
utilizado no Matlab.
FIGURA 45 – Fluxograma do comportamento entre as placas Arduino e Raspberry

Fonte: O Autor
No fluxograma acima é possível observar a relação entre o comportamento da Raspberry e

do Arduino durante a movimentação do robô.
55
3.2.1 Resultados do Protótipo
Serão apresentados os dados obtidos pelo testes realizados com o protótipo. Para obter a
comparação com os testes de simulação utilizou-se a função de pertinência do tipo gauss2mf. Os
gráficos serão gerados a partir da coleta de dados do console presente no python.
3.2.1.1 Pista 1
Seguem abaixo os primeiros dados coletados pelo protótipo utilizando a pista 1.
FIGURA 46 – Gráfico da função gauss2mf da pista 1

O gráfico acima mostra o resultado satisfatório na pista sem obstáculos. O robô manteve-se
centralizado conforme simulado no software. No início do percurso, houve uma variação nos
motores. Nesse momento, o robô estava centralizando na pista, pois, no inicio, eles estavam
deslocados.
3.2.1.2 Pista 2
Na pista 2 foram acrescentados os mesmos obstáculos presentes no cenário 2 para a

comparação entre a simulação e o protótipo.
56
FIGURA 47 – Gráfico da função gauss2mf da pista 2

Acima, há o resultado da variação dos motores do protótipo ao longo do percurso. Se

comparado à figura 36 é possível perceber alguns pontos semelhantes. Entre o intervalo de tempo
40 e 60 segundos, percebemos o desvio do obstáculo à esquerda do robô. Na figura 36 esse
desvio ocorreu entre os tempos 55 segundos e 80 segundos. Vale ressaltar que a pista possui
uma distância menor entre os obstáculos. A figura 48 irá mostrar os dois gráficos, um ao lado do
outro, para melhor visualização dos pontos semelhantes.
(a) Gráfico do cenário 2 (b) Gráfico coletado do protótipo

FIGURA 48 – Gráfico de comparação entre a simulação e o protótipo
Fonte – Simulado no software Matlab pelo autor
É possível observar com facilidade os três pontos onde o robô simulado e o protótipo
encontraram o obstáculo e efetuaram o desvio. A figura (a) retrata o gráfico gerado a partir da
simulação entre os tempos 20 e 40 segundos onde surge o primeiro obstáculo, entre 55 e 80
segundos o segundo e, finalmente, entre 110 e 130 segundos o último obstáculo, não sendo
diferente na figura (b). Ambas diferem no tamanho da pista utilizada para o teste com o protótipo,
57
reduzindo assim o tempo do encontro com cada um dos obstáculos. Porém, o gráfico segue uma
variação bem próxima àquele simulado no software V-REP, mostrando assim a qualidade em se
utilizar o controlador fuzzy juntamente à função de pertinência gauss2mf.
58
CONSIDERAÇÕES FINAIS
A partir das análises e discussões apresentadas ao longo do presente trabalho, foi possível
perceber que o controlador fuzzy constitui-se uma alternativa excelente e extremamente viável
para dotar o robô móvel e da simulação de autonomia, não havendo a necessidade de lançar
mão de mapa para auxílio em sua orientação e, utilizando-se de poucas regras linguísticas,
foi possível a realização de diferentes configurações de percurso apresentando constantemente
ótimos resultados, haja vista a superação dos obstáculos de maneira eficiente e eficaz mesmo
diante dos obstáculos móveis.
Percebe-se ainda que os resultados demonstrados pela simulação estiveram bem próximos
aos resultados extraídos do protótipo, garantindo a confiabilidade do sistema proposto. Além
disso, o protótipo mostrou-se bastante confiável visto que, mesmo havendo perda da comunicação
com o computador, manteve-se desempenhando sua função devido à localização do algoritmo
em seu interior. A utilização do simulador previamente à aplicação do protótipo permitiu um
menor número de aparições de falhas na montagem do sistema final, visto que todos os testes
foram realizados possibilitando o estabelecimento de previsões.
A utilização de saídas funções de pertinência do tipo constante garantiu melhor mobilidade
do protótipo ao longo das pistas culminando em maior segurança nos testes, porém houve uma
limitação da velocidade máxima. Sendo assim, àqueles sistemas que necessitem de velocidades
maiores torna-se necessária a modificação das constantes segundo a experiência do processo em
questão.
Conclui-se, portanto, que o algoritmo mostra-se apto à criação de rotas autônomas, tendo
em vista sua efetividade e oferta de respostas precisas nas tomadas de decisões. Para a realização
de projetos futuros, há a possibilidade de implementação de outros controladores de modo que,
posteriormente, seja estabelecido o critério comparativo ao presente controlador.
59
REFERÊNCIAS
ARDUINO. ARDUINO UNO REV3. 2018. Disponível em: https://store.arduino.cc/usa/arduino-

uno-rev3. Acesso em: 15 set.2018.
BRAGA, A. de P.; CARVALHO, A. P. de Leon F. de; LUDERMIR, T. B. Redes Neurais

Artificiais. 1. ed. Rio de Janeiro: LTC, 2000. ISBN 8521612184.
CORMEN, T. H. et al. Introdução aos algoritmos. 3. ed. São Paulo: Elsevier, 2012.
DORF, R. C.; SVOBODA, J. A. Introdução aos circuitos elétricos. Rio de Janeiro: LTC,
2008.
DURAN, J. E. R. Biofísica: conceitos e aplicações. 2. ed. São Paulo: Pearson Prentice Hall,
2011. ISBN 978-85-7605-928-8.
FILIPEFLOP. Driver Motor Ponte H L298n. 2018. Disponível em:

https://www.filipeflop.com/produto/driver-motor-ponte-h-l298n/tab-description. Acesso em: 12
set.2018.
GIMENEZ, S. P. Microcontroladores 8051. São Paulo: Pearson Education do Brasil, 2002.
GROOVER, M. Automação industrial e sistemas de manufatura. 3. ed. São Paulo: Pearson

Prentice Hall, 2011. ISBN 9788576058717.
LINDEN, R. Algoritmos genéticos. 2. ed. Rio de Janeiro: BRASPORT Livros e Multimídia

Ltda, 2006.
LUGER, G. F. Inteligência Artificial. 6. ed. São Paulo: Pearson Education do Brasil, 2013.
ISBN 9788581435503.
MARGOLIS, M. Arduino cookbook. 2. ed. Sebastopol: O’Reilly Media, 2012.
MASSE, M. REST API Design Rulebook. United States of America: O’Reilly Media, 2012.
MATHWORKS. gauss2mf: Função de associação de combinação gaussiana. 2018.

Disponível em: https://www.mathworks.com/help/fuzzy/gauss2mf.html. Acesso em: 28
out.2018.
NILSSON, J. W.; RIEDEL, S. A. Circuitos Elétricos. 8. ed. São Paulo: Pearson Prentice Hall,
2008.
NISE, N. S. Engenharia de Sistemas de Controle. 3. ed. Rio de Janeiro: LTC, 2013. ISBN
9788521621355.
NORVIG, P.; RUSSELL, S. Inteligência artificial. 3. ed. Rio de Janeiro: Elsevier, 2013.
PAREDE, I. M.; GOMES, L. E. L.; HORTA, E. Habilitação técnica em eletrônica:

Automação Industrial. 9. ed. São Paulo: Fundação Padre Anchieta, 2011.
RASPBERRYPI. Raspberry PI 3 Model B+. 2018. Disponível em:

https://www.raspberrypi.org/products/raspberry-pi-3-model-b-plus/. Acesso em: 06
set.2018.
60
ROBOTICS, C. Virtual Robot Experimentation Platform User Manual. 2018. Disponível

em: http://www.coppeliarobotics.com/helpFiles. Acesso em: 29 set.2018.
ROSáRIO, J. M. Princípios de Mecatrônica. São Paulo: Prentice Hall, 2005.
SILVA, R. M. de A. Otimização baseada em colônia de formigas aplicada ao problema de

cobertura de conjuntos. [S.l.]: Universidade Federal de Pernambuco, 2003.
SIMõES, M. G.; SHAW, I. S. Controle e Modelagem Fuzzy. 2. ed. São Paulo: Edgard Blucher,
1999. ISBN 8521204167.
WHEAT, D. Arduino internals. New York: Apress, 2011.

61
APÊNDICE A – ALGORITMO CONEXÃO V-REP
1 %Create a remote API using the prot file (remoteApiProto.m)

2 vrep = remApi(’remoteApi’);
3
4 %Ensure that all previous connections are closed

5 vrep.simxFinish(-1);
6
7 %Start connection with IP address and port (these are default values)
8 clientID = vrep.simxStart(’127.0.0.1’,19999,true,true,5000,5);
9
10 %Confirmando a conexao
11 if (clientID>-1)
12 disp(’Connected to remote API server’);
13 %Criacao da handle para o acesso aos sensores ultrassonicos
14 uSensorHandles = zeros(16,1);
15
16 %Cada ultrassonico detecta 3 valores

17 %detecta X, Y, Z nos eixos.
18 uSensorVals = zeros(16,3);
19
20 %Capturando o valor de cada ultrassonico

21 for i=1:16
22 %simxGetObjectHandle retorna o erro do codigo e os valores
dos sensores,
23 [errCode, sensorHandle] = vrep.simxGetObjectHandle(clientID,
strcat(’Pioneer_p3dx_ultrasonicSensor’,num2str(i)), vrep.
simx_opmode_blocking);
24 uSensorHandles(i) = sensorHandle;
25 %Antes de receber os valores do sensores precia iniciar os
sensores
26 [errorCode,detectionState,detectedPoint,detectedObjectHandle,
detectedSurfaceNormalVector] = vrep.
simxReadProximitySensor(clientID, sensorHandle, vrep.
simx_opmode_oneshot_wait);
27
28 %Criacao da handle para conexao com os motores

29 [errCode0, motorEsquerda] = vrep.simxGetObjectHandle(clientID, ’
Pioneer_p3dx_leftMotor’, vrep.simx_opmode_oneshot_wait);
62
30 [errCode1, motorDireita] = vrep.simxGetObjectHandle(clientID, ’

Pioneer_p3dx_rightMotor’, vrep.simx_opmode_oneshot_wait);
31
32 %carrega o controlador fuzzy

33 TreinamentoFuzzy = readfis(’moyo_sugeno_flcR2.fis’);
34 tic
35 %1000 interacoes
36 for epoch = 1:1000
37 %Primeiro ele le os sensores
38 for i=1:16
39 %Especificando a leitura do sensor
40 sensorHandle = uSensorHandles(i);
41 % C o m e o da leitura
42 [errorCode,detectionState,detectedPoint,
detectedObjectHandle,detectedSurfaceNormalVector] =
vrep.simxReadProximitySensor(clientID, sensorHandle,
vrep.simx_opmode_oneshot_wait);
43
44 if detectedPoint(3) < 0.01

45 uSensorVals(i, 3) = 1;
46 else
47 %Caso contrario, retorne a leitura real do sensor (>
0.01m, <1m)
48 uSensorVals(i, 3) = detectedPoint(3);
49 end
50 end
51
52 fuzzy_DistanciaFrente = mean([uSensorVals(4,3),uSensorVals
(5,3)]);
53
54 fuzzy_DistanciaEsquerda = uSensorVals(2,3);
55 fuzzy_DistanciaDireita = uSensorVals(7,3);
56
57 % Envia as entradas para o controlador fuzzy e

retornara dois valores: o
58 % de velocidade para os motores esquerdo (velocidade (1)) e
direito (velocidade (2))
59 velocidade = evalfis([fuzzy_DistanciaFrente,
fuzzy_DistanciaEsquerda, fuzzy_DistanciaDireita],
TreinamentoFuzzy)
60
61 vrep.simxPauseCommunication(clientID,1);
63
62 %Define a velocidade dos motores

63 %A velocidade e atualizada em cada epoca
64 velocidadeEsquerda = vrep.simxSetJointTargetVelocity(clientID
, motorEsquerda, velocidade(1), vrep.simx_opmode_streaming
);
65 velocidadeDireita = vrep.simxSetJointTargetVelocity(clientID,
motorDireita, velocidade(2), vrep.simx_opmode_streaming);
66 % Deixe o robo continuar executando comandos

67 vrep.simxPauseCommunication(clientID,0);
68
69 end
70 %Se as interacoes acabarem seta o valor da velocidade para 0
71 velocidadeEsquerda = vrep.simxSetJointTargetVelocity(clientID,
motorEsquerda, 0, vrep.simx_opmode_streaming);
72 velocidadeDireita = vrep.simxSetJointTargetVelocity(clientID,
motorDireita,0, vrep.simx_opmode_streaming);
73
74 %Make sure that the robot recieves the command to stop

75 vrep.simxGetPingTime(clientID);
76
77 % Now close the connection to V-REP:

78 vrep.simxFinish(clientID);
79 %If connection to the robot failed
80 else
81 disp(’Failed connecting to remote API server’);
82 end
83 vrep.delete(); % call the destructor
84 disp(’Program ended’);
64
APÊNDICE B – FUZZY LOGIC DESIGNER - GAUSSMF
1 [System]
2 Name=’flc_gauss_r4’
3 Type=’sugeno’
4 Version=2.0
5 NumInputs=3
6 NumOutputs=2
7 NumRules=16
8 AndMethod=’prod’
9 OrMethod=’probor’
10 ImpMethod=’prod’
11 AggMethod=’sum’
12 DefuzzMethod=’mom’
13 [Input1]
14 Name=’DISTANCIA-FRENTE’
15 Range=[0 1]
16 NumMFs=3
17 MF1=’Perto’:’gaussmf’,[0.1475 0.1397]
18 MF2=’Longe’:’gaussmf’,[0.149 0.8526]
19 MF3=’Medio’:’gaussmf’,[0.12 0.5046]
20 [Input2]
21 Name=’DISTANCIA-ESQUERDA’
22 Range=[0 1]
23 NumMFs=3
24 MF1=’Perto’:’gaussmf’,[0.1475 0.1397]
25 MF2=’Longe’:’gaussmf’,[0.149 0.8526]
26 MF3=’Medio’:’gaussmf’,[0.12 0.5046]
27 [Input3]
28 Name=’DISTANCIA-DIREITA’
29 Range=[0 1]
30 NumMFs=3
31 MF1=’Perto’:’gaussmf’,[0.1475 0.1397]
32 MF2=’Longe’:’gaussmf’,[0.149 0.8526]
33 MF3=’Medio’:’gaussmf’,[0.12 0.5046]
34 [Output1]
35 Name=’VELOCIDADE-ESQUERDA’
36 Range=[0 1]
37 NumMFs=4
38 MF1=’REVERSO’:’constant’,[-0.5]
65
39 MF2=’NORMAL’:’constant’,[0.4]
40 MF3=’RAPIDO’:’constant’,[1]
41 MF4=’DEVAGAR’:’constant’,[0.2]
42 [Output2]
43 Name=’VELOCIDADE-DIREITA’
44 Range=[0 1]
45 NumMFs=4
50 [Rules]
51 1 1 1, 1 2 (1) : 1
52 1 1 2, 3 4 (1) : 1
53 3 3 2, 2 4 (1) : 1
54 3 1 2, 3 4 (1) : 1
55 3 3 3, 4 4 (1) : 1
56 3 1 3, 3 4 (1) : 1
57 2 2 2, 3 3 (1) : 1
58 1 3 2, 4 3 (1) : 1
59 1 1 0, 4 3 (1) : 1
60 0 1 0, 3 4 (1) : 1
61 3 3 1, 2 1 (1) : 1
62 3 2 1, 4 3 (1) : 1
63 1 3 1, 3 4 (1) : 1
64 1 0 1, 4 2 (1) : 1
65 0 0 1, 1 2 (1) : 1
66 1 0 0, 1 2 (1) : 1;
66
APÊNDICE C – FUZZY LOGIC DESIGNER - GAUSS2MF
1 [System]
2 Name=’flc_gauss2mf_r4’
3 Type=’sugeno’
4 Version=2.0
5 NumInputs=3
6 NumOutputs=2
7 NumRules=16
8 AndMethod=’prod’
9 OrMethod=’probor’
10 ImpMethod=’prod’
11 AggMethod=’sum’
12 DefuzzMethod=’mom’
13 [Input1]
14 Name=’DISTANCIA-FRENTE’
15 Range=[0 1]
16 NumMFs=3
17 MF1=’Perto’:’gauss2mf’,[0.1475 0.1397]
18 MF2=’Longe’:’gauss2mf’,[0.149 0.8526]
19 MF3=’Medio’:’gauss2mf’,[0.12 0.5046]
20 [Input2]
21 Name=’DISTANCIA-ESQUERDA’
22 Range=[0 1]
23 NumMFs=3
24 MF1=’Perto’:’gauss2mf’,[0.1475 0.1397]
25 MF2=’Longe’:’gauss2mf’,[0.149 0.8526]
26 MF3=’Medio’:’gauss2mf’,[0.12 0.5046]
27 [Input3]
28 Name=’DISTANCIA-DIREITA’
29 Range=[0 1]
30 NumMFs=3
31 MF1=’Perto’:’gauss2mf’,[0.1475 0.1397]
32 MF2=’Longe’:’gauss2mf’,[0.149 0.8526]
33 MF3=’Medio’:’gauss2mf’,[0.12 0.5046]
34 [Output1]
35 Name=’VELOCIDADE-ESQUERDA’
36 Range=[0 1]
37 NumMFs=4
67
42 [Output2]
43 Name=’VELOCIDADE-DIREITA’
44 Range=[0 1]
45 NumMFs=4
50 [Rules]
51 1 1 1, 1 2 (1) : 1
52 1 1 2, 3 4 (1) : 1
53 3 3 2, 2 4 (1) : 1
54 3 1 2, 3 4 (1) : 1
55 3 3 3, 4 4 (1) : 1
56 3 1 3, 3 4 (1) : 1
57 2 2 2, 3 3 (1) : 1
58 1 3 2, 4 3 (1) : 1
59 1 1 0, 4 3 (1) : 1
60 0 1 0, 3 4 (1) : 1
61 3 3 1, 2 1 (1) : 1
62 3 2 1, 4 3 (1) : 1
63 1 3 1, 3 4 (1) : 1
64 1 0 1, 4 2 (1) : 1
65 0 0 1, 1 2 (1) : 1
66 1 0 0, 1 2 (1) : 1;

Algoritmo para Desenvolvimento de Rotas Autônomas Aplicadas A Robótica

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Algoritmo para Desenvolvimento de Rotas Autônomas Aplicadas A Robótica

Enviado por

Direitos autorais:

Formatos disponíveis

Faculdade de Ciência e Tecnologia de Montes Claros

Warley Cândido Peixoto Júnior

ALGORITMO PARA DESENVOLVIMENTO DE

ALGORITMO PARA DESENVOLVIMENTO DE ROTAS

Monografia apresentada ao Curso de Engenha-

Orientador: PROF. YURI ADAN GONÇAL-

Warley Cândido Peixoto Júnior

A LGORITMO PARA DESENVOLVIMENTO DE ROTAS

Esta monografia foi julgada adequada como

Prof. Msc. Wesley Oliveira Maia

Prof. Yuri Adan Gonçalves Cordovil

Montes Claros - MG, 13 de Novembro de 2018.

Palavras-chave: Rotas autônomas, Fuzzy, Algoritmo, Matlab, Robô.

Keywords: Autonomous Routes, Fuzzy, Algorithm, Matlab, Robot.

FIGURA 1 – Diagrama simplificado de um neurônio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

ACO Ant Colony Optimization

API Application Programming Interface

CLP Controlador Lógico Programável

CPU Central Processing Unit

IDE Integrated Development Environment

PWM Pulse Width Modulation

RAM Random Access Memory

RNA Rede Neural Artificial

USB Universal Serial Bus

A motivação em pesquisa começou com a necessidade de projetar robôs que pudessem

CAPÍTULO 1 REVISÃO DA LITERATURA

1.1 Redes neurais artificiais

1.1.1 Neurônios biológicos

Conforme Duran (2011), uma célula nervosa ou simplesmente neurônio é especializada

FIGURA 1 – Diagrama simplificado de um neurônio

1.2 Algoritmos genéticos

interface com os dados numéricos (SIMÕES; SHAW, 1999).

1.3.1 Configuração básica de um controlador fuzzy

Um controlador fuzzy é composto de algumas etapas funcionais, essas etapas são:

1.3.1.1 Funções de pertinência fuzzy

Simões e Shaw (1999) afirmam que as funções de pertinência representam aspectos

FIGURA 2 – Exemplos de funções de pertinência

1.3.1.2 Funções de interface de fuzzificação

1.3.1.3 Base de conhecimento

Conforme Simões e Shaw (1999), a base de conhecimento simboliza o padrão do sistema

1.3.1.4 Lógica de tomada de decisões

“A lógica de tomada de decisões, incorporada na estutura de inferência da base de regras,

1.3.1.5 Funções da interface de defuzzificação

A defuzzificação consiste na volta da conversão feita anteriormente para ser trabalhada no

1.3.1.6 Defuzzificação Centro-da-Área (C-o-A)

O método Centro-da-área é frequentemente chamado de método Centro-de-Gravidade,

(a) Sistema de entrada (b) Sistema de saída

(a) Vazão em 10% (b) Vazão em 80% (c) Vazão em 160%

Na figura acima foi utilizado o método de inferência de Mamdani e o método de defuz-

1.3.1.7 Defuzzificação Centro-do-Máximo (C-o-M)

Esse método consiste em observar o conjunto fuzzy de saída e determinar os valores de

(a) Vazão em 10% (b) Vazão em 80% (c) Vazão em 160%

O cálculo do centro-do-máximo se da pela equação:

1.3.1.8 Defuzzificação Média-do-Máximo (M-o-M)

A defuzzificação pela utilização do método média-do-máximo constitui um dos métodos

(a) Vazão em 10% (b) Vazão em 80% (c) Vazão em 160%

Conforme explanado anteriormente, as redes neurais oferecem características surpreenden-

1.5 Otimização com colônia de formigas

1.6 Sistemas de controle

Um sistema de controle consiste em subsistemas e processos (ou plantas) construídos com

FIGURA 7 – Descrição simplificada de um sistema de controle

1.6.1 Malha aberta

FIGURA 8 – Sistema de malha aberta