sayuri arake
TRANSCRIPT
UNIVERSIDADE FEDERAL DE MATO GROSSO
COORDENAÇÃO DE ENSINO DE GRADUAÇÃO EM CIÊNCIA
DA COMPUTAÇÃO
APLICAÇÃO DA LÓGICA FUZZY NO CONTROLE DE UM
SISTEMA DINÂMICO ACOPLADO
SAYURI ARAKE JOAZEIRO
CUIABÁ – MT
2011
UNIVERSIDADE FEDERAL DE MATO GROSSO
COORDENAÇÃO DE ENSINO DE GRADUAÇÃO EM CIÊNCIA
DA COMPUTAÇÃO
APLICAÇÃO DA LÓGICA FUZZY NO CONTROLE DE UM
SISTEMA DINÂMICO ACOPLADO
SAYURI ARAKE JOAZEIRO
Orientador: Prof. Dr. ELMO BATISTA DE FARIA
Monografia apresentada ao Instituto de
Computação da Universidade Federal de Mato
Grosso, para obtenção do Título de Bacharel
em Ciência da Computação. Área de
Concentração: Ciência da Computação
CUIABÁ – MT
2011
UNIVERSIDADE FEDERAL DE MATO GROSSO
COORDENAÇÃO DE ENSINO DE GRADUAÇÃO EM CIÊNCIA
DA COMPUTAÇÃO
CERTIFICADO DE APROVAÇÃO
Título: Aplicação da Lógica Fuzzy no controle de um sistema dinâmico acoplado
Autor: Sayuri Arake Joazeiro
Orientador: Prof. Dr. Elmo Batista de Faria
Aprovada em ___/___/______
Prof. Dr. Elmo Batista de Faria
IC
(Orientador)
Prof. MSc. Fabiana Freitas Mendes
IC
Prof. Dr. Maurício Fernando Lima Pereira
IC
Sometimes life is going to hit you in the head with a brick. Don’t lose
faith. I’m convinced that the only thing that kept me going was that I
loved what I did. You’ve got to find what you love. And that is as true
for work as it is for your lovers. Your work is going to fill a large part
of your life, and the only way to be truly satisfied is to do what you
believe is great work. And the only way to do great work is to love
what you do. If you haven’t found it yet, keep looking. And don’t
settle. As with all matters of the heart, you’ll know when you find it.
And, like any great relationship, it just gets better and better as the
years roll on. So keep looking. Don’t settle.
Steve Jobs (1955-2011).
DEDICATÓRIA
A Deus graças pela minha vida e bênçãos obtidas.
À minha mãe pelo apoio e amor incondicional.
Ao meu namorado que me compreendeu e me apoiou.
AGRADECIMENTOS
Agradeço a Deus primeiramente por ter iluminado o meu caminho e aberto as portas
para que eu pudesse chegar onde estou hoje.
Aos meus pais, Rosa e Sebastião, pela dedicação, amor e carinho, por me apoiarem em
todas as minhas decisões e por acreditarem na minha capacidade.
Ao meu namorado, Denys, por estar ao meu lado em todos os momentos, me apoiando e
ajudando.
A todos os meus professores que me ensinaram tudo, desde escrever o alfabeto a
programar em paralelo, cada um à sua maneira contribuindo para o meu contínuo
aprendizado.
Especialmente, agradeço ao Prof. Dr. Elmo Batista de Faria pela dedicação e paciência
com que me orientou no desenvolvimento deste trabalho de conclusão de curso e no
projeto de pesquisa, à Prof. Msc. Fabiana Freitas Mendes pela orientação e ajuda neste
trabalho e pelo carinho com que me atendeu toda vez que ia à sua sala e ao Prof.
Mauricio Fernando Lima Pereira por ter aceitado fazer parte deste trabalho.
Aos amigos e colegas da Computação pelo companheirismo e auxílio durante o curso,
por todos os momentos que passamos juntos durante estes quatro anos de curso.
SUMÁRIO
LISTA DE FIGURAS ..................................................................................................... 9
LISTA DE TABELAS .................................................................................................. 11
LISTA DE SIGLAS E ABREVIATURAS.................................................................. 12
RESUMO ....................................................................................................................... 13
ABSTRACT ................................................................................................................... 14
1. INTRODUÇÃO ......................................................................................................... 15
2. INTELIGÊNCIA ARTIFICIAL ............................................................................. 19
2.1. Definições ............................................................................................................ 19
2.2. Histórico ............................................................................................................... 20
3. LÓGICA FUZZY ...................................................................................................... 32
3.1. Lógica Aristotélica ............................................................................................... 32
3.2. Lógicas Clássicas ................................................................................................. 34
3.2.1. Lógica Modal ................................................................................................ 34
3.2.2. Lógica Epistêmica......................................................................................... 35
3.2.3. Lógica Deôntica ............................................................................................ 36
3.3. Lógicas Anticlássicas ........................................................................................... 37
3.3.1. Lógica Paraconsistente ................................................................................. 37
3.3.2. Lógica Paracompleta..................................................................................... 37
3.3.3. Lógica Difusa ................................................................................................ 38
3.4. Lógica Fuzzy ........................................................................................................ 38
4. ESTUDO DE CASO ................................................................................................. 48
4.1. Desenvolvimento do estudo de caso .................................................................... 48
4.1.1. Hardware do Sistema Dinâmico Acoplado .................................................. 48
4.1.1.1. Servo Motores ........................................................................................ 49
4.1.1.2. Microcontrolador ARM ......................................................................... 50
4.1.1.3. Sistema de Aquisição de Dados ............................................................. 50
4.1.2. Software do Sistema Dinâmico Acoplado .................................................... 52
4.1.2.1. Fuzzificação ........................................................................................... 53
4.1.2.2. Base de Dados ........................................................................................ 53
4.1.2.3. Regras de Inferência .............................................................................. 54
4.1.2.4. Defuzzificação ....................................................................................... 55
4.1.2.5. Controlador fuzzy de posição ................................................................ 55
4.1.2.6. Controlador fuzzy de velocidade ........................................................... 56
4.2. Testes e Resultados .............................................................................................. 58
4.2.1. Teste 01 ......................................................................................................... 60
4.2.2. Teste 02 ......................................................................................................... 63
4.2.3. Teste 03 ......................................................................................................... 65
4.2.4. Teste 04 ......................................................................................................... 67
4.2.5. Teste 05 ......................................................................................................... 69
5. CONSIDERAÇÕES FINAIS ................................................................................... 75
5.1. Conclusões ........................................................................................................... 75
5.2. Limitações ............................................................................................................ 76
5.3. Trabalhos Futuros ................................................................................................ 77
6. REFERÊNCIAS BIBLIOGRÁFICAS .................................................................... 78
7. ANEXOS .................................................................................................................... 82
Anexo A – Algoritmos dos controladores fuzzy de posição e velocidade ................. 82
Anexo B – Tabela com os dados da execução do Teste 01 ........................................ 87
Anexo C – Tabela com os dados da execução do Teste 02 ........................................ 94
Anexo D – Tabela com os dados da execução do Teste 03 ...................................... 101
Anexo E – Tabela com os dados da execução do Teste 04 ...................................... 105
Anexo F – Tabela com os dados da execução do Teste 05 ....................................... 109
9
LISTA DE FIGURAS
Figura 1 - Primeira Parte do Teste de Turing ................................................................. 22
Figura 2 - Segunda Parte do Teste de Turing ................................................................. 22
Figura 3 - Versão online do Algoritmo de Eliza ............................................................. 23
Figura 4 - Versão online do Algoritmo do Cleverbot ..................................................... 24
Figura 5 - Arquitetura do Perceptron ............................................................................. 25
Figura 6 – Representação de um SE por meio de Árvore de Decisão ............................ 26
Figura 7 – Neurônio Biológico ....................................................................................... 28
Figura 8 - Componentes do neurônio artificial ............................................................... 29
Figura 9 - Função de ativação ......................................................................................... 30
Figura 10 - Tipos de camadas das redes neurais ............................................................. 30
Figura 11 - Tipos de Lógicas .......................................................................................... 34
Figura 12 - Conjuntos Numéricos ................................................................................... 39
Figura 13 – Representação Gráfica do Conjunto das Pessoas Baixas ............................ 43
Figura 14 – Representação Gráfica do Conjunto das Pessoas Médias ........................... 43
Figura 15 - Representação Gráfica do Conjunto das Pessoas Altas ............................... 44
Figura 16 - Arquitetura do Sistema Dinâmico Acoplado ............................................... 49
Figura 17 – servo motores modificados .......................................................................... 49
Figura 18 - Microcontrolador ARM ............................................................................... 50
Figura 19 - Placa de Aquisição de Dados ....................................................................... 51
Figura 20 - Braço Robótico ............................................................................................ 51
Figura 21 - Diagrama de blocos do Controlador Fuzzy .................................................. 52
Figura 22 – Gráfico dos erros do Teste 01 ..................................................................... 60
Figura 23 - Gráfico das variações de erro do Teste 01 .................................................. 61
10
Figura 24 - Gráfico dos valores defuzzificados do Teste 01 ........................................... 62
Figura 25 – Gráfico dos erros do Teste 02 ..................................................................... 63
Figura 26 – Gráfico das variações de erro do Teste 02 .................................................. 64
Figura 27 – Gráfico dos valores defuzzificados do Teste 02 .......................................... 65
Figura 28 – Gráfico dos erros do Teste 03 ..................................................................... 66
Figura 29 – Gráfico das variações de erro do Teste 03 .................................................. 66
Figura 30 – Gráfico dos valores defuzzificados do Teste 03 .......................................... 67
Figura 31 – Gráfico dos erros do Teste 04 ..................................................................... 68
Figura 32 – Gráfico das variações de erro do Teste 04 .................................................. 68
Figura 33 – Gráfico dos valores defuzzificados do Teste 04 .......................................... 69
Figura 34 – Gráfico dos erros do Teste 05 ..................................................................... 70
Figura 35 – Gráfico das variações de erro do Teste 05 .................................................. 70
Figura 36 – Gráfico dos valores defuzzificados do Teste 05 .......................................... 71
11
LISTA DE TABELAS
Tabela 1 - Definições de inteligência artificial .............................................................. 20
Tabela 2 - Altura das Pessoas na Sala ............................................................................. 41
Tabela 3 - Classificação Nebulosa dos Elementos ......................................................... 42
Tabela 4 - Trabalhos desenvolvidos utilizando lógica fuzzy........................................... 46
Tabela 5 - Conjuntos nebulosos do controlador fuzzy .................................................... 54
Tabela 6 - Resultados dos testes e sentido de movimentação ......................................... 71
Tabela 7 – Análise dos Resultados ................................................................................. 72
Tabela 8 - Dados da execução do Teste 01 ..................................................................... 87
Tabela 9 - Dados da execução do Teste 02 ..................................................................... 94
Tabela 10 - Dados da execução do Teste 03 ................................................................. 101
Tabela 11 - Dados da execução do Teste 04 ................................................................. 105
Tabela 12 - Dados da execução do Teste 05 ................................................................ 109
12
LISTA DE SIGLAS E ABREVIATURAS
CSV Comma Separated Values
IA Inteligência Artificial
IARA Inteligência Artificial, Robótica e Automação
IP Internet Protocol
NQ Nível de Quantização
PWM Pulse Width Modulation
RI Regras de Inferência
RNA Rede Neural Artificial
SDA Sistema Dinâmico Acoplado
SE Sistema Especialista
TCP Transmission Control Protocol
UFMT Universidade Federal de Mato Grosso
13
RESUMO
A lógica fuzzy ou nebulosa é uma extensão da lógica aristotélica, a qual trabalha com os
conjuntos nebulosos que permitem valorar em um intervalo entre verdadeiro e falso. O
principal uso deste tipo de lógica é em sistemas de controle, onde a lógica nebulosa é
utilizada através do que é chamado de controlador fuzzy. Os controladores fuzzy são
sistemas que proveem controle de variáveis pré-definidas fazendo uso da lógica e dos
conjuntos fuzzy. Permitem um controle eficaz e robusto destas variáveis, as quais a
utilização da lógica clássica bivalente não seria satisfatória. Este trabalho objetiva um
estudo aprofundado de um estudo de caso com abordagem em Inteligência Artificial e
Lógica Fuzzy. O estudo de caso em questão é o desenvolvimento de uma aplicação
programada em lógica fuzzy para um sistema dinâmico acoplado: um braço robótico
composto tanto de hardware quanto de software. O software necessário para o braço
robótico é um controlador fuzzy que lida com duas variáveis: sua posição e velocidade.
Os resultados deste trabalho estão presentes em todas as etapas do seu desenvolvimento
contemplando a explicação da fundamentação teórica de forma aprofundada e didática
permitindo o seu fácil entendimento, a programação do algoritmo do controlador fuzzy
de posição e velocidade, a fase de testes com o controlador de posição, análise dos
resultados obtidos com a experiência realizada e considerações finais, conclusões,
limitações e possíveis trabalhos futuros desta pesquisa. Após o desenvolvimento de
todas as etapas deste trabalho, percebeu-se a viabilidade de diversas melhorias e geração
de novos artefatos como trabalhos futuros. O principal trabalho futuro é concernente à
criação de algoritmos proprioceptivos para o sistema dinâmico acoplado utilizado nesta
pesquisa. A criação de tais algoritmos permitirá ao braço robótico a percepção de si
mesmo e do ambiente em que se encontra, resultando em maior equilíbrio e desvio de
obstáculos. Este trabalho tem também gerado discussão na comunidade científica, onde
os resultados desta importante pesquisa tem sido reconhecidos através de publicações
em congressos nacionais e internacionais.
14
ABSTRACT
Fuzzy logic is an extension of aristotelic logic, which works with fuzzy sets that allows
valuing in an interval between true and false. The main use of this kind of logic is in
control systems, where fuzzy logic is what is called fuzzy controller. Fuzzy controllers
are systems that provide control of pre-defined variables using fuzzy logic and sets.
They allow a robust and effective control of these variables, where the use of classical
bivalent logic would not be satisfactory. This work aims a deep learning in the use of
fuzzy controllers through a case study with approaches in Artificial Intelligence and
Fuzzy Logic. The case study in question is the development of an application
programmed in fuzzy logic for a coupled dynamic system: a robotic arm composed of
hardware and software. The software required for the robotic arm is a fuzzy controller
that deals with two variables: its position and speed. The results of this work are present
in every phase of its development considering the explanation of the fundamental theory
in a depth and didactic way allowing its easy understanding, programming of the
position and speed fuzzy controller, the testing phase with the position controller,
analysis of the obtained results with the experience realized and final considerations,
conclusions, limitations and possible future work of this research. After the
development of all phases of this work, we noticed the feasibility of various
improvements and generation of new artifacts as future work. The main future work is
concerned with the creation of proprioceptive algorithms for the coupled dynamic
system used in this research. The creation of these algorithms will allow the robotic arm
perception of itself and its environment, resulting in greater balance and obstacle
avoidance. This work has also generated discussion in the scientific community, where
the results of this important research have been recognized through publications in
national and international conferences.
15
1. INTRODUÇÃO
A lógica fuzzy (também chamada de nebulosa ou difusa), apesar de ser um tema
bastante recente, possui uma grande aplicabilidade. Está presente nas áreas de processos
industriais, ciências ambientais, robótica e também na área de negócios e finanças e se
encontra em diversos equipamentos utilizados no nosso cotidiano, dentre eles: micro-
ondas, elevador, motor de carro e ar-condicionado (KOHAGURA, 2007).
Além da grande aplicabilidade, esta lógica possui como principais características a
robustez e eficiência que ela proporciona ao trabalhar com valores vagos.
Neste trabalho, são discutidas tais características e aplicabilidades através de uma
fundamentação teórica da Inteligência Artificial e Lógica Fuzzy e do desenvolvimento
de uma aplicação utilizando tal tipo de lógica por meio de um estudo de caso.
O objetivo geral deste trabalho é o desenvolvimento deste estudo de caso: um
controlador fuzzy de posição e velocidade para auxiliar o controle de um sistema
dinâmico acoplado (SDA), compreendendo desde a sua fase de programação até a fase
de análise de resultados de testes feitos com o algoritmo implementado. Sistema
dinâmico acoplado é definido como um sistema cujo comportamento é dinâmico, ou
seja, caracterizado por mudanças conforme a variação do tempo. O SDA utilizado neste
projeto de pesquisa é um braço robótico, sendo este o ambiente de estudo da aplicação
da lógica fuzzy.
Tal ambiente de estudo foi escolhido devido à expansão da robótica. Há muita pesquisa
nesta área, onde a cada dia aparece um novo projeto de robô que faz determinada
atividade ou conjunto de tarefas. A capacidade de utilização dos robôs pode ser
percebida até na área educacional onde escolas fazem uso de conceitos desta área para a
facilitação do aprendizado de conceitos complexos nas áreas de ciência, matemáticas e
tecnológicas (MINAMI, 2011).
Um dos exemplos da robótica educacional é a sua utilização nos colégios particulares de
Pernambuco, onde alunos de 7 a 13 anos constroem e programam robôs. O objetivo é
que o estudante possa ter uma melhor compreensão do conteúdo e também facilitar a
inserção deste neste contexto tecnológico, além de compreender os conceitos por trás da
construção e programação de robôs (WANDERLEY, 2011).
16
O robô “representa cada vez mais a tentativa de capacidade intelectual do ser humano
de exercer as funções superiores de sua mente em ação: procurar facilitar a vida”
(HALFPAP, SOUZA e ALVES, 2007). Da mesma maneira que a automação de alguns
processos fez com que houvesse uma revolução industrial, é inevitável o uso de robôs
para atividades diárias que podem ser terceirizadas para eles realizarem, permitindo a
facilidade e o conforto da humanidade.
Acerca dos projetos e desenvolvimento de robôs, uma das pesquisas é a do grupo de
pesquisa Inteligência Artificial, Robótica e Automação (IARA) da Universidade Federal
de Mato Grosso (UFMT) que objetiva desenvolver um robô humanoide proprioceptivo.
A propriocepção, também chamada de cinestesia, é a “capacidade humana de
localização espacial do seu próprio corpo bem como do ambiente em que se encontra”
(JOAZEIRO, FARIA e BUENO, 2011). Trata-se de um conjunto de sensores que
promovem feedback possibilitando a eles a realização de atividades tais como andar e se
mover com equilíbrio e eficiência.
O tema proposto é de interesse da comunidade científica na área de Robótica e
Inteligência Artificial, especialmente na área de implementação fazendo uso de Lógica
Fuzzy.
A proposta do uso destes controladores em lógica nebulosa permitiu a independência de
coordenação motora do braço robótico.
Para alcançar o objetivo proposto neste trabalho, foi necessária a definição de vários
objetivos específicos para o desenvolvimento deste projeto:
Pesquisa bibliográfica a respeito da abordagem utilizada nesta pesquisa:
Inteligência Artificial e Lógica Fuzzy;
Redação dos resultados obtidos com a pesquisa bibliográfica anteriormente
realizada;
Desenvolvimento dos controladores fuzzy de posição e velocidade;
Realização de testes no braço robótico;
Coleta de dados dos testes realizados;
Análise dos dados coletados;
17
Tais objetivos específicos foram também definidos como fases desta pesquisa, onde os
resultados de cada fase são apresentados nos capítulos seguintes.
Após a realização da fase de pesquisa bibliográfica acerca dos assuntos de Inteligência
Artificial e Lógica Fuzzy, foram escritos dois capítulos resultando na fundamentação
teórica necessária para o desenvolvimento deste trabalho. Essa redação está descrita no
Capítulo 2 e Capítulo 3, seguindo a estrutura descrita a seguir.
No Capítulo 2, discorre-se sobre a Inteligência Artificial. Discute-se o conceito do que
vem a ser inteligência e, por conseguinte, são apresentadas diversas definições de
inteligência artificial. Foi também narrada brevemente a história desta área promissora,
explicando sucintamente acerca dos principais assuntos que revolucionaram esta área,
entre elas: Teste de Turing, Sistemas Especialistas e Redes Neurais Artificiais.
No Capítulo 3, o assunto é a lógica fuzzy. Para a compreensão desta lógica, foram
abordadas as características e leis pertinentes à lógica clássica aristotélica. A partir
desta, comenta-se de maneira rápida todas as lógicas oriundas da lógica aristotélica,
baseadas nesta ou não. Dentre estas lógicas apresentadas, será abordada a lógica fuzzy e
sua origem, os conjuntos fuzzy. Para completo aprendizado sobre os conjuntos fuzzy,
contrasta-se esta teoria com a teoria dos conjuntos matemáticos. E, por último, definem-
se alguns trabalhos relacionados acerca da lógica fuzzy, sendo um deles o nosso estudo
de caso.
Após a fase de redação da fundamentação teórica, houve início das fases pertinentes ao
desenvolvimento do estudo de caso, onde seus resultados foram redigidos no Capítulo
4. Neste capítulo, discute-se o desenvolvimento do estudo de caso apresentando-o
através de três fases: desenvolvimento da aplicação, testes e resultados obtidos. A fase
de desenvolvimento é dividida em dois subtópicos: hardware e software do SDA. No
subtópico de hardware, apresenta-se a estrutura do braço robótico, onde são abordados
os seus principais componentes. Na parte de software, explica-se o funcionamento do
controlador fuzzy implementado. Nas fases de testes e resultados, o controlador
desenvolvido é testado, onde seus resultados são analisados criteriosamente.
E, por último, no Capítulo 5, são apresentadas as considerações finais deste trabalho de
conclusão de curso, apresentando os seus principais resultados e incluindo as limitações
18
dessa pesquisa e as possibilidades de estudos futuros acerca da temática desta
monografia.
19
2. INTELIGÊNCIA ARTIFICIAL
Neste capítulo, serão abordados os conceitos de inteligência e inteligência artificial.
Após estas definições, será feito uma breve viagem no tempo, no começo da
Inteligência Artificial (IA), passando pelas principais conquistas dessa área, definindo e
exemplificando de maneira didática os principais assuntos considerados complexos e de
difícil compreensão.
2.1. Definições
Antes de abordar a temática Inteligência Artificial (IA), é importante discutir
primariamente o que significa inteligência.
Quando se pensa a respeito do que é ser inteligente, vários significados surgem:
“raciocínio rápido”, “vasto conhecimento”, “habilidade de entendimento de ideias”,
“capacidade de resolução de problemas”, entre outras. Partindo destes conceitos, define-
se o que é inteligência: “faculdade ou capacidade de aprender, apreender, compreender
ou adaptar-se facilmente” (FERREIRA, 2004).
Assim sendo, a inteligência artificial é a capacidade de dar inteligência de forma não
natural. Mas será que é tão simples assim? De acordo com Norvig e Russel (2004), há
quatro principais categorias de definições de inteligência artificial, sendo estas:
Sistemas que pensam como seres humanos
Sistemas que pensam racionalmente
Sistemas que atuam como seres humanos
Sistemas que atuam racionalmente
Conceitos acerca dessas categorias são apresentados na Tabela 1, onde os conceitos à
esquerda dizem respeito à inteligência de acordo com a humanidade e do lado direito
referencia-se a racionalidade. Os conceitos apresentados na parte superior são de
acordo com comportamento e os na parte inferior são definidos através da importância
do pensamento.
20
Tabela 1 - Definições de inteligência artificial
Humanidade Racionalidade
Com
porta
men
to
Agindo de forma humana Agindo racionalmente
“A arte de criar máquinas que executam
funções que exigem inteligência quando
executadas por pessoas” (KURZWEIL,
1990)
“A Inteligência Computacional é
o estudo do projeto de agentes
inteligentes.” (POOLE,
MACKWORTH e GOEBEL,
1998)
Pen
sam
ento
Pensando de forma humana Pensando racionalmente
“O novo e interessante esforço para fazer
os computadores pensarem... máquinas
com mentes, no sentido total e literal.”
(HAUGELAND, 1985)
“[Automatização de] atividades que
associamos ao pensamento humano,
atividades como a tomada de decisões, a
resolução de problemas, o aprendizado..”
(BELLMAN, 1978)
“O estudo das faculdades mentais
pelo uso de modelos
computacionais.” (CHARNIAK e
MCDERMOTT, 1985)
“O estudo das computações que
tornam possível perceber,
raciocinar e agir.” (WINSTON,
1992)
2.2. Histórico
Ao longo da história da IA, estas definições acima apresentadas se fundem e se
divergem, possibilitando o desenvolvimento dessa área. O início da Inteligência
Artificial foi na década de quarenta, mais especificamente no ano de 1943 com um
trabalho de Warren McCulloch e Walter Pitts (MCCULLOCH e PITTS, 1943), onde
21
estes propuseram um modelo de neurônios artificiais que podiam possuir um dos dois
estados válidos: ligado ou desligado, 0 ou 1.
Em 1949, Donald Hebb também contribuiu para o campo da Inteligência Artificial com
a regra da Aprendizagem de Hebb, “uma regra de atualização simples para modificar as
intensidades de conexão entre os neurônios artificiais” (NORVIG e RUSSEL, 2004).
Ele demonstrou que se um neurônio X for repetidamente estimulado pelo neurônio ativo
Y, X ficará mais sensível aos estímulos de Y, fazendo com que a conexão XY seja mais
eficiente na produção dos valores de saída.
Mas o principal personagem do nascimento da Inteligência Artificial é Alan Turing, um
dos grandes nomes da Ciência da Computação. Além da sua participação na criação do
computador com a máquina de Turing, este plantou as raízes da área de IA. Durante a
Segunda Guerra Mundial, Turing trabalhou para a inteligência britânica quebrando os
códigos de guerra dos alemães e espionando-os, Turing (1950) teve a sua grande ideia,
descrita no artigo “Computing Machinery and Intelligence”: “As máquinas podem
pensar?”. Como definir o que é o pensar é difícil, Turing substituiu a pergunta por uma
mais simples, a qual pudesse obter respostas mais satisfatórias: “Há computadores que
se dariam bem no Jogo de Imitação?”.
O Jogo de Imitação é conhecido comumente como Teste de Turing. Este teste possui
três jogadores, onde um deles é um homem (A), o segundo jogador é uma mulher (B) e
o sexo do terceiro (C) não é importante. Este é o interrogador, o qual fica isolado dos
outros dois jogadores e os interroga. Seu objetivo é descobrir qual o sexo dos jogadores,
onde os interrogados podem mentir para dificultar o jogo, conforme Figura 1.
22
Figura 1 - Primeira Parte do Teste de Turing
Com este “tabuleiro” de jogo, Turing resolve tirar um dos interrogados (qualquer um
dos dois) e substituir por uma máquina, conforme a Figura 2. O interrogado percebe a
mudança? Se não perceber, então há computadores que se dão bem no Jogo de Imitação
e, portanto, podem pensar.
Figura 2 - Segunda Parte do Teste de Turing
23
Ao longo dos anos, vários programas tentaram passar no teste de Turing, sendo o Eliza
o primeiro chatterbot (robô que simula conversas) a ser quase bem sucedido, conforme
ilustrado na Figura 3. O Eliza foi desenvolvido em 1965, no MIT (Massachusetts
Institute of Technology), pelo cientista da computação Joseph Weizenbaum. De acordo
com Wallace (1997), Eliza é um psicoterapeuta rogeriano (método centrado no
paciente), ou seja, se você fala que está deprimido, Eliza pergunta o porquê de você
estar deprimido, mostrando-se ser um robô adorável e amável. Este programa trabalha
com regras definidas e programadas com uma tabela relacional, o que a torna bastante
limitada em suas respostas, pois não há aquisição de novos conhecimentos.
Figura 3 - Versão online do Algoritmo de Eliza (WALLACE, 1997)
Ao contrário do Eliza, o Cleverbot (CARPENTER, 2011) ilustrado na Figura 4 faz uso
das respostas dadas anteriormente por usuários e mantém uma conversação contínua
acerca do assunto discutido. Carpenter, disse em entrevista a Carvalhal (2011):
“Cleverbot é como uma Wikipédia falante. Cada vez que alguém conversa
com ele, ele aprende os diferentes contextos do que a pessoa está dizendo e
usa isso em outras conversas. O objetivo é imitar uma conversa humana, à
medida que se desenvolve, ele fica cada vez mais sensível.”
24
Por causa dessa arquitetura diferenciada, ao ser posto em prova no Festival Technique,
na Índia, em 2011, passou no Teste de Turing. O algoritmo criado em 1988 pelo
cientista Rollo Carpenter conseguiu enganar 59,3% dos participantes da prova.
Apesar do nascimento de IA ter sido nos anos quarenta, o termo Inteligência Artificial
só foi utilizado pela primeira vez em 1956, por John McCarthy em uma conferência no
Darmouth College.
Com a repercussão da primeira conferência de Inteligência Artificial, os cientistas
ficaram entusiasmados com a perspectiva de crescimento desta nova área, fazendo com
que as pesquisas de IA nos anos seguintes crescessem de forma incomensurável.
Figura 4 - Versão online do Algoritmo do Cleverbot (CARPENTER, 2011)
Uma das pesquisas mais significativas dessa época foi o aperfeiçoamento da
Aprendizagem de Hebb por Frank Rosenblatt em 1962, através do que ele chamou de
perceptrons.
O perceptron, ilustrado na Figura 5, é um modelo arcaico de redes neurais contendo
somente as camadas de entrada e saída, as quais podem aprender tudo que podem
representar.
25
Figura 5 - Arquitetura do Perceptron
Os “modelos baseados no perceptron são atrativos porque são rápidos e poderosos para
a modelagem de dados” (GALLANT, 1994).
Ele foi muito utilizado na década de sessenta e seu desuso ocorreu devido ao fato de sua
arquitetura não permitir uma representação ilimitada de seu aprendizado. A sua
limitação se deve ao fato de que entradas similares resultam em padrões de saídas
semelhantes e, consequentemente, sua estrutura não consegue assimilar aprendizados
mais complexos. Este problema foi contornado com a proposta de uma arquitetura de
múltiplas camadas e um algoritmo de treinamento com o nome de backpropagation
(NETO e NICOLETTI, 2005).
Com a prosperidade obtida no começo da área de Inteligência Artificial, os cientistas
fizeram especulações acerca dos resultados que ainda estavam por vir e os seus sonhos
foram grandes demais para a realidade da época. Assim sendo, entre os anos finais da
década de sessenta e os anos iniciais da década de setenta, as pesquisas nesta área
ficaram de lado.
O estudo dos Sistemas Especialistas, na década de setenta, fez com que as pesquisas
voltassem com todo o vapor. Um sistema especialista (SE) é um sistema que soluciona
problemas com base no conhecimento de um especialista humano em uma determinada
área.
26
Este especialista humano “transmite” o seu conhecimento para um interpretador ou
engenheiro do conhecimento, o qual definirá o conteúdo assimilado e necessário para
definir a base do conhecimento, onde são definidas as regras. De acordo com Raynor
(1999), “estes sistemas podem ser usados no lugar de, ou auxiliar, especialistas
humanos na tomada de decisões”.
Os SEs são construídos a partir de um banco de dados de regras pré-definidas, cujas
operações para a busca pela resolução dos problemas são definidas através de
mecanismos de busca e a representação desses sistemas são feitas em árvores de
decisão.
A árvore de decisão, vide Figura 6, possui regras em cada um dos seus nós (exceto pelas
folhas) e as folhas da árvore tem as soluções do problema, de acordo com as regras
definidas pela sua árvore superior.
Figura 6 – Representação de um SE por meio de Árvore de Decisão
Na Figura 6 está representado um sistema especialista para descobrir qual a ordem
crescente de três números quaisquer como, por exemplo: 8 (a), 15 (b) e 13 (c). Ao
verificar a regra raiz a < b, constata-se que 8 é, de fato, menor que 15. Pelo fato da
regra retornar Sim, a regra a ser verificada agora é a que se encontra na subárvore à
27
esquerda da raiz: b < c, ou seja, é examinado se 15 é menor do que 13. Sendo assim,
esta regra retorna Não, pois 15 é maior do que 13. Com o retorno de Não, verifica-se a
regra que está na subárvore à direita a < c, ou seja, é analisado se 8 é menor do que 13.
Esta regra é verdadeira e, sendo assim, retorna Sim e chega à folha da árvore, a qual
representa a solução para o nosso problema. A folha contém a solução a < c < b, ou
seja, 8 < 13 <15.
De acordo com Partridge (1998), um SE nunca estará pronto por duas razões principais:
a. A base de conhecimento (conjunto das regras definidas do SE) é incompleta,
pois há a possibilidade de incluir novas regras para que o sistema melhore seu
desempenho, ficando mais robusto, ou então aumentar o escopo do sistema, para
que este possa resolver mais problemas.
b. Não há resposta absoluta produzida pelo sistema, ou seja, as soluções dos
problemas podem mudar completamente ou então informações serem
acrescentadas a estas. Há também a possibilidade de adicionar ou melhorar as
heurísticas a fim de que os resultados obtidos sejam melhores.
Mas após a ressureição da Inteligência Artificial, a maior contribuição foi o tardio
desenvolvimento do campo de redes neurais artificiais (RNAs), área esta que já possuía
contribuições de McCulloch, Pitts, Hebb e Rosenblatt. Segundo Loesch e Sari (1996),
redes neurais artificiais são modelos computacionais baseados no sistema neurológico
humano, mais especificamente no complexo funcionamento do cérebro humano.
O cérebro humano possui bilhões de neurônios, os quais são interconectados através das
sinapses, que são responsáveis pelo processamento de dados humano.
O funcionamento dos neurônios biológicos, representados pela Figura 7, acontece da
seguinte forma: os dentritos recebem os valores de entrada, os quais causam impulsos
elétricos e são transmitidos através do neurônio. Quando estes impulsos chegam ao
terminal do axônio, esses, por sua vez, possuem conexões com os dentritos de outros
neurônios e transmitem os valores de saída para outros neurônios, através de seus
dentritos.
28
Figura 7 – Neurônio Biológico (SILVA, 2003)
De acordo com Coppin (2004), o cérebro humano possui uma propriedade chamada
maleabilidade a qual permite o aprendizado, onde os neurônios podem mudar a
estrutura das suas conexões com outros neurônios. Essa maleabilidade do cérebro
humano é a implementação natural da regra de Hebb, onde as conexões de neurônios
que levam a respostas certas são mais fortes do que as conexões que resultam em
retornos errôneos.
De maneira análoga, as redes neurais artificiais são o cérebro, e os neurônios biológicos
são os neurônios artificiais que compõem a RNA. O neurônio artificial possui a
estrutura representada na Figura 8, com os seguintes componentes representados na
figura pelas letras enumeradas:
a. Vetor de entrada (x , x x ;
b. Matriz de pesos ( ;
c. Ponto de soma (∑);
d. Limitador de sinais ou θ limiar;
e. Função de ativação;
f. Saída.
29
Figura 8 - Componentes do neurônio artificial
Cada neurônio artificial em uma RNA recebe um vetor de entradas. Esse vetor de
entradas é multiplicado por um valor chamado de peso, armazenados em uma matriz.
Esses valores definem a influência de cada entrada no valor de saída do neurônio. Após
essa multiplicação, os valores são somados e seus sinais são limitados, transformando-
se em um único valor. Este valor é utilizado em uma função de ativação. Existem
diversos tipos de funções de ativação, dentre elas: função degrau, função sigmoide e
função linear, ilustradas na Figura 9. O valor resultante da função é o valor de saída do
neurônio.
30
Figura 9 - Função de ativação (COPPIN, 2004)
As RNAs possuem três tipos de camadas: camada de entrada, camada intermediária e
camada de saída, ilustradas na Figura 10.
Figura 10 - Tipos de camadas das redes neurais
As redes neurais artificiais são classificadas de acordo com a sua topologia: quantidade
de camadas e distribuição dos neurônios. Serão abordadas as seguintes topologias:
perceptron, modelo multicamadas, redes neurais construtivas e redes neuro-fuzzy.
Existem estruturas as quais se consegue identificar claramente as camadas da RNA e
estas são definidas antes do seu treinamento, tais como: o modelo do perceptron (Figura
31
5), a qual possui somente a camada de entrada e saída, e o modelo multicamadas,
aperfeiçoamento do modelo de Rosenblatt que possui uma ou mais camadas
intermediárias (exemplificado na Figura 10).
Porém, há um modelo onde a topologia das camadas da RNA é definida e alterada
conforme o seu treinamento, sendo chamadas de redes neurais construtivas. A ideia
desse tipo de RNA é imitar a propriedade da maleabilidade do cérebro humano, onde a
rede procura uma estrutura das conexões dos neurônios a qual otimiza os resultados
obtidos.
O último tipo de rede neural é a rede neuro-fuzzy. A rede neuro-fuzzy não é
propriamente um tipo de RNA, pois esta faz uso de outros modelos (multicamadas,
redes neurais construtivas). A sua diferença é que, em sua estrutura, uma das camadas
possui implementação de regras escritas em lógica fuzzy. E esta lógica é abordada no
próximo capítulo.
32
3. LÓGICA FUZZY
Neste capítulo, são apresentados conceitos abordados na lógica clássica e as derivadas
desta, cuja ênfase é a lógica fuzzy. A respeito da lógica nebulosa, discute-se sua
definição, base teórica de forma exemplificada e simplificada e trabalhos relacionados
na área de Ciência da Computação.
3.1. Lógica Aristotélica
Antes da explicação acerca da lógica fuzzy, há a necessidade de discussão dos conceitos
que a lógica abrange. Tal discussão vem sido feita por vários séculos, especialmente
pela filosofia.
O começo da lógica se remonta ao século IV a.C., por meio de Aristóteles que exprimiu
pensamentos acerca de proposições, silogismos, premissas e conclusões.
Pode-se definir proposição como “conjunto de palavras ou símbolos que exprimem um
pensamento de sentido completo” (FILHO, 2002). Aristóteles classificou as proposições
em quatro categorias, diferenciando-se em qualidade e quantidade, sendo esta
distribuída em universais ou particulares e aquela subdividida em afirmação e negação
(D'OTTAVIANO e FEITOSA, 2003). As categorias são: universal afirmativa, universal
negativa, particular afirmativa e particular negativa. A seguir, são apresentados
exemplos de proposição para cada uma destas categorias:
Universal afirmativa – “Todos os animais são mortais”;
Universal negativa – “Nenhum animal é imortal”
Particular afirmativa – “Alguns homens são sábios”
Particular negativa – “Alguns homens não são sábios”.
Além da classificação, as proposições fazem parte de sistemas dicotômicos, ou seja,
possuem dois estados excludentes um do outro bem definidos, sendo eles: verdadeiro e
falso.
Esse sistema dicotômico aristotélico possui algumas regras fundamentais: Lei da
Identidade, Lei da Não Contradição e Lei do Terceiro Excluído.
33
Lei da Identidade – Esta lei determina que um elemento seja igual a ele
mesmo, ou seja, a = a.
Lei da Não Contradição – Esta lei determina que uma dada proposição não
pode ser verdadeira e falsa simultaneamente.
Lei do Terceiro Excluído – Esta lei determina que uma dada proposição ou é
verdadeira ou é falsa, ou seja, não há uma terceira opção.
Uma proposição cujo valor é fundamentalmente verdadeiro é chamada de premissa.
Quando se tem duas premissas interconectadas em seu significado de alguma forma e, a
partir daí, infere-se uma terceira proposição, necessariamente verdadeira, tem-se o que
Aristóteles chamou de silogismo.
De maneira mais simples, o silogismo é definido a partir de duas premissas e uma
conclusão (a proposição inferida) obtida a partir daquelas. A seguir, é apresentado um
exemplo de silogismo:
Premissa A: “Todos os homens são mortais”
Premissa B: “Sócrates é homem”
Conclusão: “Sócrates é mortal”.
Devido ao fato da lógica aristotélica ser uma lógica bivalente, ela é muito utilizada na
computação, pois os computadores também são sistemas dicotômicos, cujos valores são
zero (0) e um (1), podendo assim fazer a associação dos valores lógicos aristotélicos aos
valores binários computacionais, associação esta a qual é o principal paradigma de
programação na ciência da computação atualmente.
Além da lógica aristotélica, há também outros tipos de lógicas: lógica modal, lógica
epistêmica, lógica deôntica, lógica paraconsistente, lógica paracompleta e lógica
difusa.
Estas são divididas em dois tipos baseadas em sua origem: clássicas e anticlássicas,
apresentadas na Figura 11.
34
Figura 11 - Tipos de Lógicas
As clássicas são baseadas na lógica de Aristóteles obedecendo às suas regras
fundamentais, sendo elas: lógica modal, epistêmica e deôntica.
As anticlássicas revogam pelo menos uma das leis adotadas pela lógica aristotélica e,
dentre elas, pode-se citar: lógica paraconsistente, paracompleta e difusa.
Todas elas serão abordadas nos tópicos a seguir.
3.2. Lógicas Clássicas
A seguir, serão abordadas as definições das lógicas fundamentadas na lógica clássica,
ou seja, lógicas que obedecem todas as leis aristotélicas.
3.2.1. Lógica Modal
Este tipo de lógica exprime noções de possibilidade e necessidade (MARCOS, 2006),
as quais definem quatro tipos de proposições:
Proposição necessariamente verdadeira: proposição que possui apenas valor
verdadeiro, ou seja, não há situação em que seu valor mude para falso. Pode-se
citar como exemplo esta proposição necessariamente verdadeira: “Todos os
homens são mortais”, pois não há homem imortal.
35
Proposição possivelmente verdadeira: proposição que está verdadeira, porém
podem existir circunstâncias as quais o seu valor está falso, sendo para a
situação em questão verdadeira. Pode-se citar como exemplo esta proposição
possivelmente verdadeira: “O céu está nublado hoje”, ou seja, hoje o tempo está
nublado, mas amanhã pode estar ensolarado.
Proposição necessariamente falsa: proposição a qual o seu valor é falso, ou
seja, não há situação em que seu valor mude para verdadeiro. Pode-se citar
como exemplo esta proposição necessariamente falsa: “Os cães miam”, pois não
existe um cão que mie.
Proposição possivelmente falsa: proposição que está falsa, porém podem
existir circunstâncias as quais o seu valor está verdadeiro, sendo para a situação
em questão falsa. Pode-se citar como exemplo esta proposição possivelmente
falsa: “O céu está ensolarado”, ou seja, o céu está nublado, porém amanhã pode
estar ensolarado.
3.2.2. Lógica Epistêmica
Este tipo de lógica é baseado no conhecimento adquirido e é expresso em noções de
certeza e incerteza, definindo quatro tipos de proposições:
Proposição incertamente verdadeira: proposição verdadeira a qual é possível
que seu valor mude para falso por causa de aquisição de conhecimento sobre o
assunto. Pode-se citar como exemplo esta proposição: “Pode ser que não tenha
vida em outros planetas”, ou seja, de acordo com o conhecimento obtido até o
momento não foi descoberto nenhum extraterrestre, mas não se tem certeza que
estamos sozinhos no universo.
Proposição certamente verdadeira: proposição que permanecerá verdadeira,
devido ao fato de que o conhecimento permite afirmar que tal conjectura é
verdade. A proposição: “É impossível a existência de água em estado líquido
com temperaturas abaixo de zero grau Celsius” é certamente verdadeira, pois tal
afirmação já foi provada.
Proposição incertamente falsa: proposição falsa a qual é possível que seu valor
mude para verdadeiro porque houve aquisição de conhecimento sobre o assunto.
36
Pode-se citar como exemplo esta proposição: “Pode ser que os neutrinos
possuam uma velocidade maior do que a da luz, mas tal fato deve ser provado” –
com o conhecimento da física atual a luz possui a maior velocidade, sendo acima
da dos neutrinos.
Proposição certamente falsa: proposição que permanecerá falsa, devido ao fato
de que o conhecimento permite afirmar que tal conjectura é falsa. A proposição:
“É impossível a existência dos dinossauros” é certamente falsa, pois a existência
dos dinossauros é provada através dos seus esqueletos.
3.2.3. Lógica Deôntica
Este tipo de lógica é baseado em princípios morais e éticos, sendo expresso em noções
de obrigatoriedade e permissão (GOMES, 2008), definindo quatro tipos de
proposições:
Proposição obrigatoriamente verdadeira: proposição a qual seu valor é
verdadeiro por causa de algum princípio moral ou ético. Exemplificando:
“Quando um cidadão não sonega impostos, este é obrigado a pagar impostos”,
ou seja, é verdadeiro porque existem leis que determinam este valor para esta
proposição.
Proposição permitidamente verdadeira: proposição a qual seu valor é
verdadeiro por causa de alguma permissão fundamentada em algum princípio
moral ou ético. Exemplificando: “Nos Estados Unidos, é permitido que as
pessoas doentes fumem maconha com prescrição médica”, ou seja, tal afirmação
é verdadeira, mas não necessariamente obrigatória.
Proposição obrigatoriamente falsa: proposição a qual seu valor é falso por
causa de algum princípio moral ou ético. Exemplificando: “Não é obrigatório o
uso de cinto de segurança para motoristas”, ou seja, é falso porque existe uma lei
que determina o uso do cinto de segurança para motoristas e qualquer ocupante
do carro.
Proposição permitidamente falsa: proposição a qual seu valor é falso por
causa de alguma permissão fundamentada em algum princípio moral ou ético.
Exemplificando, temos: “No Brasil, é permitido que as pessoas doentes fumem
37
maconha com prescrição médica”, ou seja, tal afirmação é falsa, pois não é
permitido o uso de maconha para fins terapêuticos.
3.3. Lógicas Anticlássicas
Agora serão abordadas as lógicas anticlássicas, as quais abolem pelo menos uma das
leis fundamentais da lógica aristotélica.
3.3.1. Lógica Paraconsistente
Esta lógica, criada pelo brasileiro Newton da Costa (COSTA e CARNIELLI, 1986),
suprime a Lei da Não Contradição, ou seja, as proposições podem possuir valores
verdadeiros e falsos conforme o seu contexto.
A lógica paraconsistente trata de inconsistências, paradoxos e ambiguidades, permitindo
um estudo semântico das proposições (NETO e VENSON, 2002).
Exemplificando, pode-se citar esta proposição: “A maçã é vermelha”. Para determinar o
valor lógico desta afirmação, é necessário um contexto, pois as maçãs são vermelhas
quando estão maduras, mas elas podem ser verdes também, ou seja, a afirmação é
verdadeira em um contexto, mas seu valor pode ser falso em outro contexto diferente.
3.3.2. Lógica Paracompleta
Esta lógica revoga a Lei do Terceiro Excluído, ou seja, uma proposição pode possuir um
valor diferente de verdadeiro e falso, como por exemplo: indeterminado e nem
verdadeira e nem falsa.
De acordo com Carneiro (2006), enquanto a lógica paraconsistente trabalha com
contradições, a paracompleta faz uso das lacunas que uma afirmação pode ter em seu
significado, exemplificando: “Esta frase é falsa e verdadeira”. Se o valor desta
proposição for verdadeiro, ou seja, “Esta frase é falsa e verdadeira” é verdadeiro, então
a frase é falsa, pois o conteúdo da frase diz que esta é falsa. Se o valor for falso, ou seja,
“Esta frase é falsa e verdadeira” é falso, então a frase passa a ser verdadeira, pois o
conteúdo da frase diz que esta é verdadeira, contrariando assim o valor assumido. Assim
38
sendo, a proposição não pode ser falsa e também não pode ser verdadeira, possuindo
um valor indeterminado para o seu conteúdo.
3.3.3. Lógica Difusa
Esta lógica abole a Lei da Não Contradição e a Lei do Terceiro Excluído, pois suas
proposições trabalham com graus de pertinência (probabilidade) que são valores que
definem o quanto uma proposição é verdadeira e/ou falsa.
Assim sendo, a proposição possui um valor X% verdadeiro e um valor Y% falso, o que
contraria a Lei da Não Contradição, pois suas afirmações são falsas e verdadeiras ao
mesmo tempo.
Estes valores podem ser expressos em outros termos como é possível, talvez,
provavelmente verdade e provavelmente falso, fazendo com que a Lei do Terceiro
Excluído seja abolida de seu conceito.
Quando o meteorologista informa que amanhã tem 80% de chance de chover, ele está
valorizando a proposição “Choverá amanhã” com 80% verdadeiro.
Dentre todos estes tipos de lógica apresentados, será abordada de forma mais
aprofundada a lógica difusa ou fuzzy.
3.4. Lógica Fuzzy
Em 1965, Lofti Askar Zadeh idealizou o conceito fuzziness (traduzido do idioma inglês,
significa difuso ou nebuloso) em um artigo chamado “Fuzzy Sets” (ZADEH, 1965).
Neste artigo, Zadeh explica a fundamentação dos conjuntos nebulosos, contrastando o
conceito destes à definição de conjuntos proposta por Georg Cantor.
A teoria dos conjuntos de Cantor define a relação de pertinência entre elementos e
conjuntos.
A pertinência determina que certo elemento pertence (simbolizado por ) ou não
pertence (simbolizado por ) a um determinado conjunto. Como exemplo, podem-se
citar dois conjuntos numéricos: o conjunto dos inteiros (simbolizado por ) – números
39
inteiros positivos e negativos – e o conjunto dos números naturais (simbolizado por )
– números inteiros positivos – representados na Figura 12.
Figura 12 - Conjuntos Numéricos
Tendo como exemplo os elementos 5, -2 e ½, pode-se dizer que:
5 , 5 : o número 5 pertence aos dois conjuntos, pois é um número inteiro
positivo.
-2 , -2 : o número -2 pertence ao conjunto dos inteiros, mas não pertence
ao conjunto dos naturais, pois é um número inteiro negativo.
½ , ½ : o número ½ não pertence a nenhum dos conjuntos, pois é um
número fracionário (racional).
A teoria dos conjuntos de Cantor também faz uso das leis da lógica clássica, ou seja:
Lei do Terceiro Excluído: um elemento ou pertence ( ) ou não pertence ) a
um determinado conjunto, não há outra opção. Ou seja, seja a um elemento e A
um conjunto, tem-se que: ou a A ou a A é verdadeiro, pois não há terceira
opção de acordo com esta lei.
Lei da Não Contradição: um elemento não pode pertencer ( ) e não pertencer
( ) a um determinado conjunto. Ou seja, seja a um elemento e A um conjunto,
tem-se que: a A e a A é falso, pois é contrário a Lei da Não Contradição.
40
Em contraste com a teoria dos conjuntos cantoriana, pode-se conceituar o que vem a ser
a teoria dos conjuntos nebulosos, idealizado por Zadeh.
Devido à complexidade dos problemas do mundo real, o pai da lógica fuzzy notou que
os conjuntos cantorianos não admitiam algumas situações reais as quais eram possíveis
e, na verdade, frequentes. Sendo assim, percebeu algo que ninguém havia notado, que o
paradigma até então utilizado era muito limitado e propôs o conjunto nebuloso que é
uma expansão da teoria dos conjuntos de Cantor e é nela baseada. A sua principal ideia
é a que a pertinência de um conjunto é descrita por meio de valores chamados de grau
de pertinência.
O grau de pertinência possui um intervalo de valores o qual pode se limitar. Este
intervalo é chamado de universo de discurso.
Existe também o conceito de cardinalidade que é a quantidade de conjuntos nebulosos
utilizados para a classificação.
Para melhor entendimento, pode-se utilizar o exemplo da Figura 12 com os conjuntos
dos inteiros ( ) e o conjunto dos números naturais ( ), onde se tem que a cardinalidade
é dois.
Será utilizado o elemento -2 da explicação da teoria dos conjuntos de Cantor. Para
Cantor, -2 e -2 . Mas para Zadeh, tem-se que:
-2 , -2 , -2 e -2 (1)
Mas como isso é possível? É possível devido ao grau de pertinência, o valor que
determina o quanto o elemento pertence a um conjunto e não pertence a este conjunto.
E para determinar este valor, determina-se também um universo de discurso e uma
função de pertinência.
O universo de discurso é o intervalo que determina a variação dos valores fuzzy
possíveis.
A função de pertinência é uma função a qual retorna o grau de pertinência de um dado
elemento. Os valores retornados desta função de pertinência devem estar entre os
valores do intervalo definido do universo de discurso escolhido.
41
Sejam escolhidos os valores entre 0% e 100% como universo de discurso, com intervalo
fechado (0% e 100% inclusive). Assim sendo, é possível para Zadeh que (1) aconteça,
onde:
-2 com grau de pertinência 0%: o número -2 pertence 0% ao conjunto dos
naturais.
-2 com grau de pertinência 100%: o número -2 não pertence 100% ao
conjunto dos naturais.
-2 com grau de pertinência 100%: o número -2 pertence 100% ao conjunto
dos inteiros.
-2 com grau de pertinência 0%: o número -2 não pertence 0% ao conjunto
dos inteiros.
Outra forma de se abordar os conceitos envolvidos em conjuntos nebulosos é o descrito
em Breunig (2004): em uma sala, existem quatro pessoas com as alturas descritas na
Tabela 2.
Tabela 2 - Altura das Pessoas na Sala
Pessoa Altura (metros)
Ana 1,2
Maria 1,5
João 1,75
Pedro 2,0
O objetivo é classificar se a pessoa é alta, baixa ou de estatura média. Neste exemplo,
então, a cardinalidade é três, ou seja, existem três conjuntos nebulosos: pessoas baixas,
pessoas altas e pessoas de estatura média. Os elementos a serem classificados são: Ana,
Maria, João e Pedro.
42
Utilizando os valores entre 0 e 1 com intervalo fechado (0 e 1 inclusive) como o
universo de discurso, os elementos serão classificados em pessoas de estatura alta,
mediana ou baixa.
Por exemplo, João tem 1,75m de altura. Ele é uma pessoa alta, média ou baixa? Zadeh o
classificaria conforme os valores do universo de discurso nas três categorias com
valores os quais diria o quanto João pertence ao conjunto dos baixos, médios e altos.
Assim, podem-se classificar as pessoas conforme a Tabela 3.
Tabela 3 - Classificação Nebulosa dos Elementos
Conjunto Nebuloso Pertinência
Pessoa baixa 1 0,3 0 0
Pessoa de estatura média 0 1 0,8 0
Pessoa alta 0 0,1 0,4 1
Elementos Ana Maria João Pedro
Pode-se observar que Ana com seus 1,2 metros de altura é uma pessoa baixa com o
valor máximo do universo de discurso. Pelo fato de sua altura ser pequena, o grau de
pertinência aos outros dois conjuntos é zero. Pedro possui 2 metros de altura e é
considerado uma pessoa alta e o grau de pertinência aos outros conjuntos é zero, pois
uma pessoa com 2 metros de altura não é nem baixa nem média.
Já Maria com a altura de 1,5 metros de altura pode ser considerada como pouco baixa
(0,3), totalmente média (1) e improvavelmente alta (0,1). E, por último, João com 1,75
metros de altura é nada baixo (0), provavelmente de estatura média (0,8) e mais ou
menos alto (0,4).
Para determinar o valor do grau de pertinência de um elemento a um dado conjunto, a
lógica fuzzy faz uso de funções de pertinência. Tais funções de pertinência podem ser
representadas através de equações algébricas ou graficamente.
43
As equações algébricas geram representações gráficas de funções contínuas, ou seja,
para cada valor de entrada existe um valor de saída correspondente.
Quando não há uma equação algébrica definida, usa-se certa quantidade de valores fuzzy
definidos. A esta quantidade dá-se o nome de nível de quantização (NQ). Cada valor
definido do NQ é um ponto descontínuo no gráfico.
A limitação do valor do NQ pode fazer com que vários valores de entrada correspondam
a um mesmo valor de saída, gerando um gráfico pontual de função descontínua.
Pode-se, então, definir as funções de pertinência dos conjuntos de pessoas baixas,
médias e altas conforme Figura 13, Figura 14 e Figura 15, respectivamente.
Figura 13 – Representação Gráfica do Conjunto das Pessoas Baixas (BREUNIG, 2004)
Figura 14 – Representação Gráfica do Conjunto das Pessoas Médias (BREUNIG, 2004)
44
Figura 15 - Representação Gráfica do Conjunto das Pessoas Altas (BREUNIG, 2004)
Foi com esta ideia que Zadeh revolucionou o modo como os conjuntos matemáticos
eram vistos. Mas ele não parou por aí. Ele notou que, da mesma maneira que a lógica
clássica era bivalente, os conjuntos cantorianos também o eram. Assim sendo, os seus
conjuntos poderiam ser descritos de forma mais abrangente. Fazendo o uso da corrente
de lógicas anticlássicas, Zadeh propôs a lógica fuzzy em 1973 (ZADEH, 1973), uma
lógica que era baseada na sua teoria de conjuntos fuzzy.
Da mesma maneira que os conjuntos fuzzy são expansões da teoria dos conjuntos de
Cantor, a lógica fuzzy é uma expansão de todas as lógicas mencionadas neste trabalho:
lógica aristotélica, deôntica, modal, epistêmica, paraconsistente e paracompleta.
Zadeh descreveu quando a lógica fuzzy deve ser utilizada (ZADEH, 1973): “Quanto
mais perto olhamos para um problema do mundo real, mais nebulosa se torna a sua
solução”, ou seja, o pensamento humano não é valorado conforme a lógica clássica, em
dois valores, mas sim baseada em “verdades fuzzy, conectivos fuzzy e regras de
inferência fuzzy”.
Pode-se dividir o funcionamento da lógica fuzzy em três módulos: fuzzificação, regras
de inferência e defuzzificação.
A fuzzificação é o processo de conversão de um valor escalar de entrada em um valor
lógico fuzzy. Para fuzzificar valores escalares, são utilizadas funções de pertinência as
quais determinam o grau de pertinência (KOHAGURA, 2007). Valores são fuzzificados
o tempo todo no nosso cotidiano: quando uma mulher sobe numa balança para ver o seu
45
peso (valor escalar de entrada) e afirma que está gorda (valor fuzzy), ela está
fuzzificando o seu peso.
Após a fuzzificação, chega-se no segundo módulo. É na fase de regras de inferência
que são definidas regras que determinam a ação a ser realizada conforme os dados
advindos da fase anterior. Estas regras de inferência definem ações para todas as
combinações possíveis de valores fuzzy. Conforme o exemplo anterior, pode-se definir
uma regra descrita assim: “Se gorda, então emagreça”.
No último módulo, faz-se uso da ação determinada na fase de regras de inferência e
converte tal dado (que se encontra fuzzificado) em um valor escalar. De maneira
simples, é o processo contrário ao de fuzzificação. Utilizando o mesmo exemplo, a ação
determinada pelo módulo de regras de inferência é que uma pessoa gorda emagreça.
Assim sendo, a defuzzificação poderia retornar a quantia em quilos que esta pessoa
deveria emagrecer.
Em Moraes (2007), são destacadas algumas das principais características que
transformam a lógica fuzzy neste instrumento importante:
A capacidade de facilitar a modelagem de problemas independentes da sua
complexidade;
A modelagem cognitiva que permite aquisição de conhecimento de forma mais
rápida e otimizada;
Simplicidade na sua implementação;
Manipulação do conceito de incertezas e valores indeterminados que permite
auxiliar na solução de problemas do mundo real de diversos tipos.
Tais características somadas ao modo como os dados são tratados e organizados na
lógica fuzzy faz desta uma ferramenta poderosa para diversos tipos de aplicações. Na
Tabela 4, são apresentados alguns trabalhos realizados que utilizam a lógica fuzzy,
explicando sucintamente a respeito do foco de cada uma destas aplicações.
46
Tabela 4 - Trabalhos desenvolvidos utilizando lógica fuzzy
Aplicação Foco
Bancos de dados relacionais fuzzy Adequação do tratamento das informações no
processo de tomada de decisão em bancos de
dados relacionais, fazendo uso de consultas em
lógica fuzzy (PERES e BOSCARIOLI, 2002)
Análise de concessão de crédito
pessoal
Desenvolvimento de método automático para
concessão de crédito pessoal baseado em lógica
fuzzy e sistemas especialistas (CESAR,
MACHADO e JUNIOR, 2006)
“Clusterização” de bancos de
dados
Desenvolvimento de um algoritmo usando lógica
fuzzy para melhoria da tarefa de “clusterização” de
bancos de dados (JUNIOR, MATTOS e SIMÕES,
2010)
Sistema de avaliação para
educação à distância
Desenvolvimento de um sistema de avaliação de
desempenho de alunos de educação à distância
utilizando lógica fuzzy (FARIA et al., 2008)
Sistema de avaliação de qualidade
de software
Desenvolvimento de um sistema que avalia a
qualidade do software, obtém um padrão de
qualidade e estima a sua qualidade utilizando a
lógica fuzzy (BELCHIOR, 1997)
Controle de navegação de robôs Desenvolvimento de um controlador fuzzy de
velocidade e posição para um robô proprioceptivo
(FARIA et al., 2011)
47
Estas aplicações são utilizadas nas seguintes áreas: sistemas especialistas, banco de
dados, robótica, linguagem natural, reconhecimento de padrões, controle de processos e
sistemas de controle.
O sistema de controle implementado por meio de controladores fuzzy (FARIA et al.,
2011) é a aplicação discutida no Capítulo 4.
48
4. ESTUDO DE CASO
O estudo de caso em questão é um controlador fuzzy de velocidade e posição para um
sistema dinâmico acoplado, fazendo a abordagem do estudo de caso nas seguintes fases:
desenvolvimento, testes e resultados.
A fase de desenvolvimento é a definição de como o estudo de caso foi feito, onde será
apresentado o hardware do SDA, detalhando acerca dos principais componentes de sua
arquitetura e o software do controlador fuzzy de velocidade e posição, explicando o seu
funcionamento e implementação.
A fase de testes e resultados é a fase a qual testes foram realizados e, através destes, os
resultados da pesquisa foram colhidos e analisados através de gráficos.
4.1. Desenvolvimento do estudo de caso
Neste tópico, será feita a descrição do hardware do sistema dinâmico acoplado, bem
como a parte do software utilizada, apresentando a arquitetura do controlador fuzzy
implementado no estudo de caso.
4.1.1. Hardware do Sistema Dinâmico Acoplado
O sistema dinâmico acoplado utilizado neste trabalho, conforme dito anteriormente, é
um braço robótico. A estrutura de hardware utilizada para a sua construção é
representada na Figura 16. Dentre a estrutura apresentada, será feita uma breve
explicação acerca dos servo motores, do microcontrolador ARM (Advanced RISC
Machine) e do sistema de aquisição de dados.
49
Figura 16 - Arquitetura do Sistema Dinâmico Acoplado (FARIA et al., 2011)
4.1.1.1. Servo Motores
Os servo motores utilizados no braço robótico são do modelo Futaba 3003 (Figura 17),
cuja estrutura interna foi modificada para melhor utilização no sistema dinâmico
acoplado (FARIA et al., 2011).
Figura 17 – servo motores modificados (FARIA et al., 2011)
50
A função destes no sistema dinâmico acoplado é a mesma função das juntas do corpo
humano que permitem a movimentação dos ossos do esqueleto em vários graus.
4.1.1.2. Microcontrolador ARM
Será utilizado um ARM 7 LPC2368 (Figura 18), o qual possui sistemas digitais,
implementação em PWM (Pulse Width Modulation – modulação por largura de pulso),
conversores analógico-digitais e digital-analógicos, bem como comunicação em
protocolo TCP/IP (Transmission Control Protocol/Internet Protocol) (FARIA et al.,
2011).
Figura 18 - Microcontrolador ARM (FARIA et al., 2011)
É no ARM que o sistema de controle fuzzy implementado neste trabalho funcionará
futuramente, após a sua gravação no microcontrolador com a utilização de uma
ferramenta denominada Yagarto Tools.
4.1.1.3. Sistema de Aquisição de Dados
Placa externa de aquisição de dados da DataQ Instruments, modelo DI-148U (Figura
19). Esta placa possui cinco portas digitais de entrada e saída e oito portas de conversão
analógico-digital. Além de possuir conexão USB, a sua programação é feita em C++.
51
Figura 19 - Placa de Aquisição de Dados (FARIA et al., 2011)
Os dados necessários para o funcionamento do controlador fuzzy estão nesta placa de
aquisição de dados, tais como a velocidade a qual o sistema dinâmico acoplado se mexe
e em que posição este se encontra, sendo utilizado para a leitura e escrita de dados.
Após a definição da arquitetura do sistema dinâmico acoplado, foi feita a sua
construção. O hardware do sistema dinâmico acoplado é apresentado na Figura 20.
Figura 20 - Braço Robótico (FARIA et al., 2011)
52
4.1.2. Software do Sistema Dinâmico Acoplado
Após a construção do hardware do SDA, deu-se início à implementação necessária para
este sistema de controle. Para a implementação, foi escolhida uma abordagem em
Inteligência Artificial e Lógica Fuzzy, por meio de controladores fuzzy.
Para iniciar o desenvolvimento do software do braço robótico, foram definidas a
linguagem de programação e ambiente de desenvolvimento. A escolha foi feita
pensando na compatibilidade entre os componentes da arquitetura de hardware.
A linguagem escolhida foi a linguagem C devido à sua robustez, facilidade de
implementação e compatibilidade com o microcontrolador ARM e a placa de aquisição
de dados.
O ambiente de desenvolvimento escolhido para a implementação foi o Eclipse, pois este
também possui compatibilidade com as ferramentas utilizadas no desenvolvimento do
firmware para microcontroladores ARM, facilitando, após o desenvolvimento do
software, a sua migração para esta plataforma.
O ambiente de estudo em questão necessita de controle de duas variáveis, fazendo com
que o desenvolvimento do controlador fuzzy se dividisse em duas subfases:
Desenvolvimento do controlador fuzzy de posição
Desenvolvimento do controlador fuzzy de velocidade
Após o desenvolvimento dos dois controladores, estes foram integrados em um só. O
controlador fuzzy implementado é definido pelo diagrama de blocos, definido na Figura
21.
Figura 21 - Diagrama de blocos do Controlador Fuzzy
53
Para maior entendimento dos itens 4.1.2.1, 4.1.2.2, 4.1.2.3, 4.1.2.4, 4.1.2.5 e 4.1.2.6,
pode-se verificar o “Anexo A – Algoritmos dos controladores fuzzy de posição e
velocidade” para maior entendimento do funcionamento da implementação
desenvolvida neste trabalho.
4.1.2.1. Fuzzificação
Para a fuzzificação, foi utilizado um nível de quantização de 25 pontos, ou seja, existem
somente 25 valores fuzzy possíveis para este controlador, os quais são armazenados em
uma estrutura de dados do tipo vetor. A quantidade de 25 pontos é o mais comumente
escolhido na literatura para a implementação inicial, podendo ser ajustado e alterado
posteriormente. Primeiramente, valores são adquiridos da placa de aquisição de dados
(como a posição atual do braço robótico, por exemplo). Após a coleta dos dados
necessários, são calculados os valores de erro e variação de erro. O valor de erro é
calculado fazendo a diferença entre a posição/velocidade desejada e a
posição/velocidade atual. Este valor informa o quanto a posição/velocidade atual está
“errada” da posição/velocidade desejada. O valor da variação de erro é calculado pela
diferença entre os valores do erro anterior com o erro atual. Com os valores de erro e
variação de erro, estes são utilizados para a fuzzificação. Esta função é chamada duas
vezes, uma para o valor de erro e outra para o valor de variação de erro. Com o valor
de entrada (erro ou variação de erro), a função de fuzzificação faz uma busca no vetor
de NQ de valores fuzzy com universo de discurso entre -1 e 1 para encontrar um valor
fuzzy “compatível” com o valor escalar de entrada, sendo este valor nebuloso o mais
aproximado do valor escalar correspondente. A busca utilizada divide o vetor de valores
difusos em duas partes para facilitar e agilizar o resultado da busca.
4.1.2.2. Base de Dados
A definição das regras de inferência a serem utilizadas no controlador fuzzy está na base
de dados. A base de dados deste controlador está armazenada em uma matriz. A
cardinalidade desta base de dados é 7, ou seja, são usados sete conjuntos nebulosos
representados por números e nomes específicos, descritos na Tabela 5.
54
Tabela 5 - Conjuntos nebulosos do controlador fuzzy
Abreviatura do nome do
conjunto nebuloso
Nome por extenso do
conjunto nebuloso Número representativo
NG Negativo Grande 0
NM Negativo Médio 1
NP Negativo Pequeno 2
Z Neutro ou Zero 3
PP Positivo Pequeno 4
PM Positivo Médio 5
PG Positivo Grande 6
A partir da base de dados definida que o bloco de regras de inferência obtém as regras
de inferência pertinentes aos valores fuzzificados advindos do bloco de fuzzificação.
4.1.2.3. Regras de Inferência
Este módulo possui duas funções: obter as regras de inferência e unir as regras de
inferência. Com os valores fuzzificados, procura-se na base de dados o conjunto
nebuloso correspondente aos valores de entrada, armazenando as regras de inferência a
ser utilizada. O valor pesquisado é um valor inteiro entre 0 e 6, simbolizando a que
conjunto nebuloso as regras de inferência correspondem. Após a busca, a função de
obter as regras de inferência é chamada. Nesta função, procuram-se os menores valores
fuzzy correspondentes para o conjunto nebuloso da regra de inferência utilizada. Após a
execução desta função, a união das regras de inferência é chamada. Nesta função,
utilizam-se os valores fuzzy encontrados na obtenção das regras de inferência para
55
encontrar o maior valor entre todos os valores. Assim sendo, o método utilizado para
este módulo é o máximo dos mínimos. Os valores fuzzy encontrados após a execução
das duas funções é utilizado no próximo módulo.
4.1.2.4. Defuzzificação
Os valores armazenados após a união das regras de inferência são utilizados na
defuzzificação. Para defuzzificar estes valores, é necessário algum método matemático.
O método escolhido foi a divisão da multiplicação pela soma pela sua larga utilização. É
feita a multiplicação dos valores fuzzy advindos do bloco regras de inferência com
outro valor fuzzy e, depois, estes valores multiplicados são somados. Também é feita a
soma de todos os valores armazenados no vetor da execução do bloco de regras de
inferência. Depois de realizadas a soma e a multiplicação, a divisão destes dois valores
é feita, resultando no valor de saída do controlador fuzzy. A divisão é a conversão do
valor fuzzy para um valor escalar. Este valor simboliza se há movimentação e quanto
falta para que o braço robótico chegue à posição/velocidade desejada. Quanto maior o
valor modular de saída, maior a distância que o braço deve percorrer. Conforme o valor
modular de saída fica menor, menor também é a distância da posição em que o braço se
encontra da posição desejada.
4.1.2.5. Controlador fuzzy de posição
O funcionamento do controlador fuzzy de posição é o seguinte: a placa de aquisição de
dados informa a posição atual (em valor de voltagem) do sistema dinâmico acoplado.
Este valor é convertido por meio de uma regra de três simples em valor de graus.
Define-se a posição desejada para onde o braço robótico deve ir, em graus. Com essas
duas posições, calcula-se o valor de erro e da variação de erro. Para o cálculo do valor
de erro de posição, foi usada uma função que normaliza os valores em graus, ou seja,
transforma ângulos em valores inteiros. Nesta função, os valores da posição desejada e
posição atual são normalizados. O cálculo de variação de erro é a diferença entre o
erro anterior e o erro atual. Estes valores são parâmetros para a função da fuzzificação.
A função da fuzzificação é converter esses valores escalares para valores fuzzy. Após
esta conversão, os valores de entrada são passados para o próximo módulo: regras de
56
inferência. Neste módulo, tem-se duas ações a serem realizadas: obter as regras de
inferência (RI) e unir as RI. Os valores resultantes da função de união das regras de
inferência são os valores a serem utilizados no módulo de defuzzificação.
No módulo de defuzzificação, os valores do vetor são multiplicados por uma matriz
denominada vetorDelta e estas multiplicações são somadas. Também é feita a soma dos
valores do vetor armazenado na função de união de RI.
A multiplicação e a soma permitem unificar os valores em um único e converter este
valor para um valor defuzzificado por meio da divisão do produto pela soma, ou seja,
fazendo-se a conversão para escalar. Este valor é gravado no sistema de aquisição de
dados e o servo motor responsável pelo movimento executa a ação necessária fazendo
com que o sistema dinâmico acoplado possa se movimentar.
O sinal positivo ou negativo do valor resultante da defuzzificação diz para que lado o
braço robótico deve girar para chegar a posição desejada mais rápida: sentido horário ou
sentido anti-horário.
Se a posição desejada for maior que a posição atual, significa que o braço terá que
mover em sentido horário. Quando a posição desejada é menor que a posição atual, o
braço terá que mover em sentido anti-horário.
4.1.2.6. Controlador fuzzy de velocidade
A principal função do controlador fuzzy de velocidade é controlar a velocidade a qual o
braço robótico se move. Sem este controle, o SDA se comportaria como um “braço
bobo”, movendo-se de forma brusca a uma velocidade constante.
O valor de saída do controlador fuzzy de posição também permite ajustar a velocidade,
pois dependendo do seu valor a velocidade é maior ou menor. Quanto maior a distância
da posição a qual o braço se encontra para a posição desejada, é importante que a
velocidade seja maior também para que o braço consiga alcançar seu destino final em
menor tempo. Este controle pode ser analogicamente comparado ao comportamento de
um motorista que está indo em direção a um semáforo fechado: a velocidade do
motorista diminuirá conforme a proximidade do veículo com o farol.
57
Para auxiliar no controlador fuzzy, usa-se o conceito de PWM (Pulse Width
Modulation). A modulação por largura de pulso permite controlar a velocidade
definindo intervalos para que esta trabalhe em maior velocidade e menor velocidade.
Fazendo uso do PWM e do valor de saída do controlador fuzzy de posição, o braço
robótico se movimenta de forma adequada, permitindo que chegue ao local desejado de
maneira mais eficiente e rápida.
O funcionamento do controlador fuzzy de velocidade é o seguinte: a placa de aquisição
de dados informa a velocidade atual (em valor de voltagem) do sistema dinâmico
acoplado. Este valor é convertido por meio de uma regra de três simples em termos de
velocidade. A informação da velocidade desejada é obtida a partir do que foi dito no
parágrafo anterior, onde a velocidade adequada é definida pelo PWM e pelo valor de
saída do controlador fuzzy de posição. Com essas informações, calcula-se o valor de
erro e de variação de erro da velocidade. Estes valores são parâmetros para a função da
fuzzificação.
A função da fuzzificação é converter esses valores escalares de velocidade para valores
fuzzy. Após esta conversão, os valores de entrada são passadas para o próximo módulo:
regras de inferência. Neste módulo, tem-se duas ações a serem realizadas: obter as
regras de inferência (RI) e unir as RI. Os valores resultantes da função de união das
regras de inferência são os valores a serem utilizados no módulo de defuzzificação.
No módulo de defuzzificação, os valores do vetor são multiplicados por uma matriz
denominada vetorDelta e estas multiplicações são somadas. Também é feita a soma dos
valores do vetor armazenado na função de união de RI.
A multiplicação e a soma permitem unificar os valores em um único e converter este
valor para um valor defuzzificado por meio da divisão do produto pela soma, ou seja,
fazendo-se a conversão para escalar. Com este valor, define-se a velocidade adequada
para o movimento requerido.
O sinal positivo ou negativo do valor resultante da defuzzificação informa se a
velocidade do braço robótico será aumentada ou diminuída. Já o valor modular informa
o quanto a velocidade aumentará ou diminuirá.
58
4.2. Testes e Resultados
Nesta seção, serão apresentadas as condições como os testes foram feitos. Também
serão discutidos os resultados obtidos com os testes realizados.
Os testes foram feitos com a implementação redigida no “Anexo A – Algoritmos dos
controladores fuzzy de posição e velocidade” que foi realizada na fase de
desenvolvimento deste trabalho. Apesar de ter sido feito o desenvolvimento dos dois
controladores fuzzy (posição e velocidade) e, depois, a sua integração em um único
controlador, a fase de testes mostra os resultados somente do controlador de posição.
O motivo é a dificuldade de implementação do algoritmo do PWM, uma das bases de
testes fundamentais para o controlador de velocidade, que ainda não havia sido
finalizado.
Os testes foram executados de maneira simulada, não havendo testes reais no braço
robótico. Isso ocorreu em decorrência da funcionalidade incompleta do controlador de
velocidade.
A quantidade de execuções deste algoritmo é definida pelo usuário e, a cada execução, é
criado um arquivo com os resultados do controlador fuzzy, cujo procedimento descrito a
seguir se repete conforme o valor definido de quantidade de vezes a ser executada.
Inicialmente, houve a necessidade de geração de valores randômicos de posições
desejadas, cujo intervalo era de 0º à 180º. A primeira vez que o programa executa
também gera um valor randômico para o valor da posição inicial que seria a posição
onde o braço robótico se encontraria.
Com os valores de posições escolhidos ao acaso, o programa executa em um laço da
posição inicial até a posição final a fim de que se possa verificar a consistência dos
dados obtidos.
Estes dados gerados pelo algoritmo do controlador fuzzy são salvos em arquivos de
extensão CSV (Comma Separated Values), delimitados por ponto-e-vírgula (;). A
escolha do CSV foi feita devido à sua compatibilidade com o programa Microsoft®
Office Excel, onde o fato do arquivo possuir delimitadores fixos faz com que o Excel
insira automaticamente os valores nas colunas. Tal fato facilitou a geração dos gráficos
59
demonstrativos dos resultados obtidos, fazendo do Excel a ferramenta escolhida para
construção destes gráficos.
Assim sendo, os gráficos com os resultados da pesquisa foram construídos a partir do
arquivo criado pelo programa. Sendo a pesquisa do tipo qualitativa, estes gráficos são a
representação visual dos dados dos testes realizados, não havendo nenhum processo
estatístico quanto aos seus valores e, portanto, facilitando a visualização dos dados.
Os dados salvos pela execução do programa são as posições em graus, os valores de
erro, variação de erro e o valor defuzzificado (valor de saída) do controlador fuzzy de
posição.
A posição é o valor que o SDA se encontra no momento, mostrando do valor inicial até
o valor desejado.
Os valores de erro e variação de erro são os valores de entrada para o controlador fuzzy.
Por último, o valor defuzzificado é o valor de saída da execução do algoritmo do
controlador.
Para a fase de testes, o algoritmo foi executado cinco vezes. Esta execução gerou cinco
arquivos com os valores aleatórios de posição desejada e, na primeira execução, valor
aleatório para posição inicial também. São estes os cinco arquivos:
“(1) 41 – 155” – Este arquivo disposto no “Anexo B – Tabela com os dados da
execução do Teste 01” tem os dados da execução do controlador fuzzy com
posição inicial de 41º e posição desejada ou final de 155º.
“(2) 155 – 27” – Este arquivo disposto no “Anexo C – Tabela com os dados da
execução do Teste 02” tem os dados da execução do controlador fuzzy com
posição inicial de 155º (posição em que se encontrava após a primeira execução)
e posição desejada ou final de 27º.
“(3) 27 – 90” – Este arquivo disposto no “Anexo D – Tabela com os dados da
execução do Teste 03” tem os dados da execução do controlador fuzzy com
posição inicial de 27º (posição em que se encontrava após a segunda execução) e
posição desejada ou final de 90º.
“(4) 90 – 21” – Este arquivo disposto no “Anexo E – Tabela com os dados da
execução do Teste 04” tem os dados da execução do controlador fuzzy com
60
posição inicial de 90º (posição em que se encontrava após a terceira execução) e
posição desejada ou final de 21º.
“(5) 21 – 158” – Este arquivo disposto no “Anexo F – Tabela com os dados da
execução do Teste 05” tem os dados da execução do controlador fuzzy com
posição inicial de 21º (posição em que se encontrava após a quarta execução) e
posição desejada ou final de 158º.
Em seguida serão abordados os resultados de cada uma das cinco execuções do
controlador fuzzy de posição.
4.2.1. Teste 01
Nesta execução, a posição inicial do braço robótico foi gerada randomicamente e seu
valor é 41º e a posição desejada definida aleatoriamente é 155º. Os dados detalhados
desta execução estão no “Anexo B – Tabela com os dados da execução do Teste 01”.
O valor de erro informa ao controlador fuzzy que, enquanto seu valor não zerar, a
posição em que o braço robótico se encontra está “errada”. No gráfico da Figura 22,
pode-se observar que quanto mais perto se chega do valor de posição desejada (155º),
menor o valor de erro, fazendo com que a forma do gráfico seja uma reta crescente. Ao
chegar à posição 155º, o erro se torna 0, pois foi alcançada a posição final.
Figura 22 – Gráfico dos erros do Teste 01
61
Nota-se também que todos os valores de erro são negativos, ou seja, o movimento do
braço será no sentido horário, pois a posição desejada (155º) é maior do que a posição
inicial (41º).
Já o gráfico da Figura 23 permite a visualização das variações de erro. Este gráfico é
linearmente constante, pois a variação de erro permite limitar e orientar de forma mais
eficiente e adequada os valores de erro. O fato dos valores da variação de erro não
oscilar significa que não há mudança brusca dos valores de erro (valor de entrada).
Figura 23 - Gráfico das variações de erro do Teste 01
Analogamente, pode-se dizer que o valor de erro é o volante e a variação de erro é o
motorista, ou seja, este faz com que o controle daquele seja feito da maneira correta,
sem movimentações ríspidas.
O valor de variação de erro em 41º (posição inicial) é o mesmo valor em módulo do
erro. Isso acontece devido ao fato de que a variação de erro é calculada com a
diferença dos valores do erro anterior e erro atual. O valor de erro anterior é 0, então a
variação de erro é igual ao valor negativo do erro em 41º.
62
E, por último, os valores de saída do controlador fuzzy de posição nos diz o quanto
“falta” para chegar à posição desejada, conforme ilustrado na Figura 24. Pode-se notar
que o gráfico se assemelha a uma escada crescente, onde existem várias posições as
quais o valor defuzzificado é o mesmo. Isso ocorre devido ao nível de quantização, onde
diversas posições, ao serem fuzzificadas, resultam em um mesmo valor fuzzy. Sendo
assim, o valor de saída será igual, pois os valores de entrada também são iguais.
Figura 24 - Gráfico dos valores defuzzificados do Teste 01
Para que o tamanho do “degrau” da “escada” do gráfico seja menor, pode-se colocar
mais valores fuzzy, ou seja, aumentar o número do nível de quantização, a fim de que
diversas posições não resultem em um mesmo valor fuzzy.
Quanto mais longe do valor 0, seja para valores positivos ou negativos, mais longe da
posição final o braço robótico se encontra. Assim sendo, faz-se uso do valor
defuzzificado para auxiliar também no controle da velocidade, já que quanto maior seu
valor modular, mais rápido o braço pode se movimentar. Isso se deve ao fato de que
quanto maior o módulo do valor defuzzificado, mais longe está da posição desejada,
podendo assim se mover mais rápido para alcançar a posição final de forma mais
eficiente.
63
4.2.2. Teste 02
Nesta execução, a posição inicial do braço robótico é 155º, posição final do SDA na
primeira execução e a posição desejada é 27º. Os dados detalhados desta execução estão
no “Anexo C – Tabela com os dados da execução do Teste 02”.
Na Figura 25, pode-se notar que os valores de erro são todos valores positivos, ou seja,
o sentido em que o braço irá se movimentar é o sentido anti-horário. Isso ocorre devido
ao fato de que a posição final é menor que a posição inicial, significando que o braço
robótico já passou pela posição desejada anteriormente.
Figura 25 – Gráfico dos erros do Teste 02
Para tanto, faz-se necessário que o SDA “volte” para tal posição, indo para “trás”. Para
que seja feito tal movimento, é necessário que o braço robótico inverta o seu sentido.
Para simbolizar essa troca de sentido, o cálculo da variação de erro também é invertido.
Antes, era feita a diferença entre o erro anterior pelo erro atual; agora, a diferença é
entre o erro atual e o erro anterior.
Percebe-se que o gráfico da função do erro representa um gráfico linear decrescente,
onde o valor do erro diminui conforme o valor da posição desejada chega.
64
Assim sendo, similar à primeira execução, o primeiro cálculo da variação de erro é
igual ao valor inicial de erro, onde pode ser observado no “pico” inicial da Figura 26.
Isso ocorre devido ao fato de que o valor de erro anterior é igual ao valor do último
erro calculado e este, por sua vez, é 0. O erro da posição desejada anterior sempre será
0, pois a posição em que o braço se encontra é a desejada e não há mais “erro” de
posição.
Figura 26 – Gráfico das variações de erro do Teste 02
Após esse valor inicial, o gráfico de variação de erro passa a ser novamente constante,
o que indica o controle dos valores de erro até a posição desejada.
Na Figura 27, pode-se observar que o gráfico é semelhante ao gráfico dos valores
defuzzificados do teste anterior. A diferença é que o gráfico presente na Figura 24 é
crescente, enquanto o da Figura 27 é decrescente. Isto ocorre devido ao fato de que o
sentido de movimento do SDA mudou, ou seja, passou de horário para anti-horário.
65
Figura 27 – Gráfico dos valores defuzzificados do Teste 02
Para refletir essa mudança, o cálculo do erro também é alterado para simbolizar através
dos dados a modificação de sentido de movimento. Com essas mudanças, o valor
defuzzificado também demonstra a mudança do sentido, pois seus valores vão
decrescendo conforme a posição em que se encontra chega à posição desejada. E, ao
chegar ao ângulo 27º, o valor de saída é 0, ou seja, o braço parará de se mover.
4.2.3. Teste 03
Nesta execução, a posição inicial do braço robótico é 27º, posição final do SDA na
segunda execução e a posição desejada é 90º. Os dados detalhados desta execução estão
no “Anexo D – Tabela com os dados da execução do Teste 03”.
A execução do Teste 03 é semelhante ao Teste 01, já que a posição final é maior que a
posição inicial. Sendo assim, o braço terá que se mover pra “frente” no sentido horário.
Na Figura 28, nota-se que os valores de erro vão aumentando de forma gradual
linearmente crescente e, quando, a posição desejada é alcançada, o erro se torna nulo.
66
Figura 28 – Gráfico dos erros do Teste 03
Pode-se observar na Figura 29 que a função de variação de erro é constante da mesma
maneira que os resultados dos testes anteriores haviam demonstrado.
Figura 29 – Gráfico das variações de erro do Teste 03
67
A Figura 30 ilustra o gráfico dos valores defuzzificados como sendo um gráfico
crescente. Sendo assim, a movimentação do braço robótico se dará em sentido horário,
pois a posição desejada está à “frente” da posição em que o braço se encontra.
Figura 30 – Gráfico dos valores defuzzificados do Teste 03
Percebe-se que o gráfico é novamente em formato de escada, pois o nível de
quantização do controlador faz com que uma grande quantidade de valores escalares
corresponda ao mesmo valor fuzzy.
4.2.4. Teste 04
Nesta execução, a posição inicial do braço robótico é 90º, posição final do SDA na
segunda execução e a posição desejada é 21º. Os dados detalhados desta execução estão
no “Anexo E – Tabela com os dados da execução do Teste 04”.
O Teste 04 é semelhante ao Teste 02, onde a posição final é menor que a posição inicial,
ou seja, o braço se movimentará no sentido anti-horário.
Na Figura 31, pode-se observar que o gráfico é uma reta decrescente, cujos valores de
erro são positivos. Isso justifica a mudança no sentido de movimento do SDA.
68
Figura 31 – Gráfico dos erros do Teste 04
Na Figura 32, observa-se que o gráfico da variação de erro é novamente constante,
significando que não houve mudança brusca dos valores de erro.
Figura 32 – Gráfico das variações de erro do Teste 04
69
O gráfico representado na Figura 33 é decrescente, mostrando que o sentido de
movimentação do sistema dinâmico acoplado é anti-horário. Percebe-se também que um
mesmo valor fuzzy corresponde a vários valores de graus, da mesma maneira dos testes
anteriores.
Figura 33 – Gráfico dos valores defuzzificados do Teste 04
4.2.5. Teste 05
Nesta execução, a posição inicial do braço robótico é 21º, posição final do SDA na
quarta execução e a posição desejada é 158º. Os dados detalhados desta execução estão
no “Anexo F – Tabela com os dados da execução do Teste 05”.
No Teste 05, tal como ocorre nos Teste 01 e Teste 03, a posição final é maior que a
posição inicial. Para tanto, o braço mudará mais uma vez o sentido de seu movimento:
de anti-horário para horário.
Os valores de erro para a execução do Teste 05 estão dispostos no gráfico ilustrado na
Figura 34. O gráfico é linearmente crescente e os valores do erro são valores negativos
que confirmam que a movimentação do SDA será em sentido horário.
70
Figura 34 – Gráfico dos erros do Teste 05
Na Figura 35, os valores dispostos no gráfico de variação de erro são constantes,
mostrando que o braço se move gradualmente de forma não brusca.
Figura 35 – Gráfico das variações de erro do Teste 05
71
E, por último, a Figura 36 que representa o gráfico dos valores de saída do controlador é
crescente, partindo de valores negativos até chegar ao valor 0, indicando que o braço
robótico chegou à posição desejada.
Figura 36 – Gráfico dos valores defuzzificados do Teste 05
Pode-se observar novamente que o gráfico dos valores defuzzificados possui um
formato de escada, onde vários valores de posição possuem como correspondentes o
mesmo valor fuzzy.
No geral, os resultados obtidos não possuem grandes diferenças de um teste para o
outro, onde o Teste 02 e Teste 04 são semelhantes, assim como o Teste 01, Teste 03 e
Teste 05 são similares entre si, onde os resultados das execuções se encontra na Tabela
6.
Tabela 6 - Resultados dos testes e sentido de movimentação
Número do Teste Sentido de movimentação
Teste 01 Horário
Teste 02 Anti-horário
72
Teste 03 Horário
Teste 04 Anti-horário
Teste 05 Horário
Assim, os resultados obtidos podem ser padronizados de acordo com algumas
características em razão do sentido de movimentação, sendo descritas na Tabela 7.
Tabela 7 – Análise dos Resultados
Características Movimento Horário Movimento Anti-horário
Valor do erro Negativo Positivo
Valor da variação do erro Negativo Positivo
Valor defuzzificado Negativo Positivo
Gráfico do erro Crescente Decrescente
Gráfico da variação de
erro
Constante Constante
Gráfico do valor
defuzzificado
Crescente Decrescente
Cálculo de erro Posição atual – posição
desejada
Posição desejada –
posição atual
Cálculo de variação de
erro
erro anterior – erro erro – erro anterior
Para o primeiro valor executado em cada teste, nota-se que os valores de erro e
variação de erro são iguais em valores absolutos. Após cada execução, o valor de erro
73
atual é 0. Ao executar novamente, este erro atual passa a ser o erro anterior e o erro
atual é recalculado. Como o cálculo do erro anterior é uma subtração, o valor da
variação de erro será modularmente igual ao valor do erro. É por causa do fato de que
estes dois valores sempre serão iguais em valores absolutos que os gráficos possuem um
“pico” no valor inicial de cada execução.
O gráfico dos valores de erro sempre será linear, diferenciando somente no fato de ser
crescente ou decrescente.
Após o “pico” inicial, o gráfico dos valores de variação de erro sempre será constante,
independente do sentido de movimentação. Tal fato representa que não houve mudança
brusca dos valores de erro, ou seja, o braço se movimenta de maneira gradual.
Quanto ao gráfico dos valores defuzzificados, este sempre possuirá um formato de
“escada” com vários degraus. Os degraus, conforme dito anteriormente, são formados
devido ao fato de que vários valores escalares são convertidos em um mesmo valor
fuzzy.
Para que o “tamanho” do degrau diminua, será necessário aumentar o nível de
quantização do controlador, ou então, usar uma função de pertinência contínua. Tal
modificação poderia afetar o desempenho dos movimentos do braço robótico, pois
exigiria maior processamento, tornando-o mais lento.
Ao observar nos gráficos dos cinco testes realizados, nota-se que os valores finais de
erro e valor defuzzificado são sempre 0. Como dito anteriormente, o valor de erro
informa que a posição onde o SDA se encontra está “errada”. Ao chegar à posição
desejada (a “correta”), o erro se torna 0. O valor defuzzificado informa se ainda há
movimentação e quanto falta para os movimentos cessarem. Quando este valor se torna
0, não haverá mais movimentação.
Após tais constatações iniciais, foi percebido que os resultados do braço poderiam ser
classificados de acordo com o sentido da sua movimentação: horário ou anti-horário.
Quando o movimento do SDA é horário, a posição em que o braço deseja ir é maior que
a posição que o braço se encontra, ou seja, a posição desejada está a frente da posição
atual. O sentido do movimento é representado com o sinal dos dados, onde as variáveis
de erro, variação de erro e valor defuzzificado são valores negativos. Pelo fato de que
74
os valores dos dados são negativos, os gráficos de erro e valor defuzzificado são
crescentes.
Quando o sentido do movimento é anti-horário, a posição desejada é menor do que a
posição atual. Para isso, o braço terá que “voltar”, indo pra trás. O sinal dos valores dos
dados de erro, variação de erro e valor defuzzificado é positivo, onde tais valores
geram gráficos decrescentes de erro e valor defuzzificado.
Em todos os testes executados, foi observado que o controlador fuzzy funcionou da
maneira esperada, controlando a posição e ajudando no controle da velocidade.
75
5. CONSIDERAÇÕES FINAIS
Neste capítulo, são discutidos as principais conclusões acerca de todas as etapas de
desenvolvimento deste trabalho, as limitações encontradas durante a realização desta
pesquisa e os trabalhos futuros que podem ser feitos para que esta pesquisa continue.
5.1. Conclusões
A utilização da Inteligência Artificial requer o uso de técnicas para a modelagem de
sistemas computacionais. Dentre os diversos tipos de técnicas existentes, destaca-se a
utilização da lógica fuzzy. A sua utilização é feita em larga escala em sistemas de
controle, devido ao fato de que a lógica difusa é robusta e eficiente para os seus
propósitos.
Os propósitos deste trabalho foram definidos por meio de objetivos específicos que
foram alcançados com o decorrer do seu desenvolvimento, os quais contribuíram
imensamente para a comunidade científica de Inteligência Artificial, Robótica e Lógica
Fuzzy.
Tais contribuições não são notadas somente no que concerne ao desenvolvimento de
uma aplicação em lógica fuzzy, mas também na redação da fundamentação teórica de
tais assuntos. Tal redação contribui para a literatura tanto de Inteligência Artificial
quanto de Lógica Fuzzy, permitindo ao leitor o fácil entendimento de conceitos
complexos envolvendo tais áreas.
No Capítulo 2, são discutidas as principais técnicas usadas em sistemas computacionais
que utilizam inteligência artificial, bem como definições do que é inteligência e o
significado de inteligência artificial.
A discussão da técnica computacional inteligente utilizada no estudo de caso é feita no
Capítulo 3, onde são abordadas a origem da lógica clássica aristotélica e suas derivadas.
Dentre as lógicas originadas a partir da lógica aristotélica, explica-se o funcionamento
da lógica fuzzy por meio de conjuntos nebulosos exemplificando todos os conceitos para
garantir o total entendimento das ideias apresentadas neste trabalho.
76
Também foi feita a união destes três assuntos atuais por meio de um estudo de caso com
a implementação de controladores fuzzy de velocidade e posição no controle do sistema
dinâmico acoplado utilizado neste trabalho, trazendo à tona a discussão acerca do
desenvolvimento dos algoritmos e os resultados obtidos com a geração de testes com o
controlador de posição.
Com a análise dos resultados obtidos com os dados coletados dos testes, foi possível a
classificação do comportamento de movimentação do braço robótico, onde foi notado
um padrão nos valores e sinais das variáveis que fazem o controle da posição do SDA.
A importância das contribuições deste trabalho realizado foi notada pela comunidade
científica com a publicação e apresentação de artigo e resumos.
O artigo “Hardware System for Robot and Proprioceptive Algorithms” discute a
arquitetura de hardware necessária para a implementação de um robô proprioceptivo
fazendo uso de microcontroladores ARM e controladores fuzzy de velocidade e posição
(FARIA et al., 2011).
Durante o desenvolvimento deste trabalho, foram aceitos também dois resumos com os
seguintes títulos: “Aplicação da Lógica Fuzzy utilizando microcontroladores ARM em
um robô proprioceptivo” (JOAZEIRO, FARIA e BUENO, 2011) e “Aplicação da
Lógica Fuzzy no controle de um sistema dinâmico acoplado”.
5.2. Limitações
Com o decorrer do desenvolvimento do trabalho, ocorreram algumas limitações de
pesquisa.
Uma das limitações mais significativas foi a ausência de geração de testes, coleta de
dados e análise dos resultados com o controlador fuzzy de velocidade. Tal empecilho foi
a dificuldade da implementação de uma das bases necessárias, o PWM, que auxilia o
funcionamento do controle da velocidade do sistema dinâmico acoplado de maneira
integral.
Outra limitação foi a ausência de testes com o braço robótico. Os testes foram
simulados para verificar o comportamento e resultados do controlador de posição.
77
5.3. Trabalhos Futuros
As limitações citadas nos tópicos acima podem ser superadas por meio de melhorias
como trabalhos futuros.
A dificuldade da implementação do PWM pode ser suplantada, permitindo a fase de
testes, coleta de dados e análise dos dados obtidos.
Com o controlador fuzzy de velocidade funcional, pode-se aproveitar para realizar uma
fase de testes no braço robótico com o controlador de velocidade e de posição, fazendo
com que não haja mais limitações quanto ao modo de realização dos testes dos
algoritmos.
Além das melhorias, pode-se também citar a criação de novos artefatos como trabalhos
futuros. No Capítulo 1, foi citado o IARA da UFMT que tem como objetivo o
desenvolvimento de um robô proprioceptivo, onde a fase inicial deste projeto é a
utilização de controladores fuzzy. Concernente ao trabalho realizado por este grupo de
pesquisa, o controlador fuzzy é o pontapé inicial para o posterior desenvolvimento de
algoritmos proprioceptivos, sendo somente os valores de entrada para a
proprioceptividade. Mas, apesar de ser somente o começo desta pesquisa mais
abrangente, este trabalho de conclusão de curso traz os seus primeiros resultados.
78
6. REFERÊNCIAS BIBLIOGRÁFICAS
BELCHIOR, A. D. Um Modelo Fuzzy para Avaliação da Qualidade de Software.
Universidade Federal do Rio de Janeiro. Rio de Janeiro, p. 208. 1997.
BELLMAN, R. An Introduction to Artificial Intelligence: Can Computers Think?.
San Francisco: Boyd & Fraser Publishing Company, 1978.
BREUNIG, A. Lógica Fuzzy Aplicada ao Controle de Processos, 2004. Disponível
em:
<http://200.169.53.89/download/CD%20congressos/2004/Sucesu/tut_prat/L%C3%B3gi
ca%20Fuzzy.pdf>. Acesso em: 16 Outubro 2011.
CARNEIRO, M. F. Alguns Aspectos da Lógica e da Informática Jurídicas. Revista
Jurídica Cesumar, Curitiba, v. 6, n. 1, p. 37-45, 2006.
CARPENTER, R. Cleverbot, 2011. Disponível em: <http://cleverbot.com/>. Acesso
em: 29 Setembro 2011.
CARVALHAL, A. Robô que bate papo pode se passar por humano. Tribuna Hoje,
2011. Disponível em: <http://tribunahoje.com/noticia/5254/tecnologia/2011/09/12/robo-
que-bate-papo-pode-se-passar-por-humano.html>. Acesso em: 29 Setembro 2011.
CESAR, B. L.; MACHADO, M. A. S.; JUNIOR, H. A. E. O. Sistema de Apoio à
Decisão na Concessão de Crédito Pessoal usando Lógica Fuzzy. Banco Morada e
Faculdades IBMEC. Rio de Janeiro. 2006.
CHARNIAK, E.; MCDERMOTT, D. Introduction to Artificial Intelligence.
Massachusetts: Addison-Wesley, 1985.
COPPIN, B. Artificial Intelligence Iluminated. Massachusetts: Jones and Bartlett
Publishers, 2004.
COSTA, N. C. A. D.; CARNIELLI, W. A. On Paraconsistent Deontic Logic.
Philosophia, v. 16, p. 293-305, 1986.
CRUZ, T. O Teatro Organizacional. Rio de Janeiro: Editora E-papers, 2006.
D'OTTAVIANO, Í. M. L.; FEITOSA, H. D. A. Sobre a história da lógica, a lógica
clássica e o surgimento das lógicas não-clássicas, 2003. Disponível em:
79
<ftp://www.cle.unicamp.br/pub/arquivos/educacional/ArtGT.pdf>. Acesso em: 9
Outubro 2011.
FARIA, E. B. D. et al. Hardware System for Robot and Proprioceptive Algorithms.
The 15th World Multi-Conference on. Systemics, Cybernetics and Informatics,
Orlando, Julho 2011.
FARIA, M. N. et al. Um Sistema de Avaliação em EAD baseado em Lógica Fuzzy,
Uberlândia, 2008.
FERREIRA, A. B. D. H. Mini Aurélio: o dicionário da lingua portuguesa. 6ª. ed.
Curitiba: Posigraf, 2004.
FILHO, E. D. A. Iniciação à Lógica Matemática. São Paulo: Nobel, 2002.
GALLANT, S. I. Neural Network Learning & Expert Systems. London: The MIT
Press, 1994.
GOMES, Nelson Gonçalves. Um panorama da lógica deôntica. Kriterion: Revista de
Filosofia. 2008, v. 49, n. 117, p. 9-38.
HALFPAP, D. M.; SOUZA, G. C. D.; ALVES, J. B. D. M. Robôs como artefatos.
Ciência & Cognição, Rio de Janeiro, v. 12, p. 203-213, Novembro 2007.
HAUGELAND, J. Artificial Intelligence: The Very Idea. Massachusetts: MIT Press,
1985.
JOAZEIRO, S. A.; FARIA, E. B. Aplicação da Lógica Fuzzy no controle de um
sistema dinâmico acoplado. 2ª Escola Regional de Informática SBC Mato Grosso,
Cuiabá. Caderno de Resumos ERI-MT, 2011. p. 19-21.
JOAZEIRO, S. A.; FARIA, E. B.; BUENO, J. F. Aplicação da lógica fuzzy utilizando
microcontroladores ARM em um robô proprioceptivo. XIX Seminário de Iniciação
Científica, Resumos 2010/2011, Cuiabá, 2011.
JUNIOR, A. C.; MATTOS, M. C. D.; SIMÕES, P. W. T. A. O Algoritmo
Unsupervised Robust C-Prototypes para a Tarefa de Clusterização Utilizando o
Método de Lógica Fuzzy. Periódicos UNESC, Anais V SULCOMP, Santa Catarina,
2010.
80
KOHAGURA, T. Lógica Fuzzy e suas Aplicações. Monografia (Graduação em
Ciência da Computação - Universidade Estadual de Londrina, Londrina, 2007.
KURZWEIL, R. The Age of Intelligent Machines. Massachusetts: MIT Press, 1990.
LOESCH, C.; SARI, S. T. Redes Neurais Artificiais: Fundamentos e Modelos.
Blumenau: Edifurb, 1996.
MARCOS, J. Lógica Modal, 2006. Disponível em:
<http://www.dimap.ufrn.br/~jmarcos/courses/LC/Cap4.pdf>. Acesso em: 12 Outubro
2011.
MCCULLOCH, W. S.; PITTS, W. A logical calculus of the ideas immanent in
nervous activity. Bulletin of Mathematical Biology, v. 5, p. 115–133, 1943.
MINAMI, T. "Robôs em sala de aula aumentam motivação dos alunos", diz
educadora. Uol, 2011. Disponível em:
<http://noticias.uol.com.br/educacao/2011/05/19/robos-em-sala-de-aula-aumentam-
motivacao-dos-alunos-diz-educadora.jhtm>. Acesso em: 07 Junho 2011.
MORAES, C. M. M. Fuzzycom - Componente de Lógica Fuzzy. Resumo PIBIC,
2007. Disponível em: <http://www.puc-
rio.br/pibic/relatorio_resumo2007/relatorios/ele/ele_claudio_magno_martins_moraes.pd
f>. Acesso em: 17 Outubro 2011.
NETO, L. G. P.; NICOLETTI, M. D. C. Introdução às Redes Neurais Construtivas.
São Carlos: EdufSCar, 2005.
NETO, M. C. L.; VENSON, N. Lógica Paraconsistente, 2002. Disponível em:
<http://www.inf.ufsc.br/~barreto/trabaluno/TC_Nerio_Mauricio.pdf>. Acesso em: 12
Outubro 2011.
NORVIG, P.; RUSSEL, S. Inteligência Artificial. 2ª. ed. New Jersey: Prentice Hall,
2004.
PARTRIDGE, D. Artificial Intelligence and Software Engineering. Nova Iorque:
Glenlake Publishing Company, 1998.
81
PERES, S. M.; BOSCARIOLI, C. Sistemas Gerenciadores de Banco de Dados
Relacionais Fuzzy: uma Aplicação em Recuperação de Informação. Acta
Scientiarum, Maringá, 2002. 1733-1743.
POOLE, D.; MACKWORTH, A. K.; GOEBEL, R. Computational Intelligence: A
Logical Approach. Oxford: Oxford University Press, 1998.
RAYNOR, W. The International Dictionary of Artificial Intelligence. Nova Iorque:
Glenlake Publishing Company, 1999.
SILVA, J. M. N. Redes Neurais Artificiais: Rede Hopfield e Redes Estocásticas,
2003. Disponível em: <http://www.ic.uff.br/~jsilva/monografia_RNA.pdf>. Acesso em:
4 Outubro 2011.
TURING, A. M. Computing Machinery and Intelligence. Mind, New York, p. 433-
460, Outubro 1950.
WALLACE, M. Eliza Program. Talk to Eliza, 1997. Disponível em:
<http://www.vistua.com/cgi-bin/eliza.shtml>. Acesso em: 29 Setembro 2011.
WANDERLEY, E. Robótica ganha espaço nas salas de aula. Diário de Pernambuco,
2011. Disponível em:
<http://www.pernambuco.com/ultimas/nota.asp?materia=20110527153736&assunto=1
95&onde=VidaUrbana>. Acesso em: 07 Junho 2011.
WINSTON, P. H. Artificial Intelligence. 3ª. ed. Massachusetts: Addison-Wesley,
1992.
ZADEH, L. A. Fuzzy Sets. Information and Control, Califórnia, v. 8, p. 338-353, 1965.
______. A. Outline of a new approach to the analysis of complex systems and
decision processes. IEEE Transactions on Systems, Man and Cybernetics, p. 28-44,
Janeiro 1973.
82
7. ANEXOS
Anexo A – Algoritmos dos controladores fuzzy de posição e velocidade
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <dos.h>
#include <math.h>
#define CARDINALIDADE 7 //Quantidade de conjuntos nebulosos
#define NQ 25 //Nível de Quantização
/* As variáveis descritas abaixo são as variáveis compartilhadas
* entre o controlador fuzzy de velocidade e posição */
//vetor Erro de valores fuzzy posição e velocidade
double vetorErro[NQ] =
{-1.0, -0.9167, -0.8333, -0.75, -0.6667,
-0.5833, -0.5, -0.4167, -0.3333, -0.25,
-0.1667, -0.0833, 0.0, 0.0833, 0.1667,
0.25, 0.3333, 0.4167, 0.5, 0.5833,
0.6667, 0.75, 0.8333, 0.91767, 1.0};
//vetor de Variação de Erro de valores fuzzy de posição e velocidade
double vetorVariacaoErro[NQ] =
{-1.0, -0.9167, -0.8333, -0.75, -0.6667,
-0.5833, -0.5, -0.4167, -0.3333, -0.25,
-0.1667, -0.0833, 0.0, 0.0833, 0.1667,
0.25, 0.3333, 0.4167, 0.5, 0.5833,
0.6667, 0.75, 0.8333, 0.91767, 1.0};
//vetor Delta de posição e velocidade utilizada na defuzzificação
double vetorDelta[NQ]=
{-1.0, -0.9167, -0.8333, -0.75, -0.6667,
-0.5833, -0.5, -0.4167, -0.3333, -0.25,
-0.1667, -0.0833, 0.0, 0.0833, 0.1667,
0.25, 0.3333, 0.4167, 0.5, 0.5833,
0.6667, 0.75, 0.8333, 0.91767, 1.0};
//matriz controladora Fuzzy de posição e velocidade
double cFuzzy[CARDINALIDADE][NQ]=
{{1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
{0.6, 0.7, 0.8, 0.9, 1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3,
0.2, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
{0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.9, 0.8, 0.7,
0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
{0.0, 0.0, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,
1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0, 0.0, 0.0},
{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5,
0.6, 0.7, 0.8, 0.9, 1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2},
{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1,
0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.9, 0.8, 0.7, 0.6},
83
{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}
};
//matriz das Regras de Implicação dos conjuntos nebulosos de posição e
velocidade
int regrasImplicacao[CARDINALIDADE][CARDINALIDADE] =
//NG NM NP Z PP PM PG
//0 1 2 3 4 5 6
{{0, 0, 1, 1, 2, 2, 3}, //NG - 0
{0, 1, 1, 2, 2, 3, 4}, //NM - 1
{1, 1, 1, 2, 3, 4, 4}, //NP - 2
{1, 2, 2, 3, 4, 4, 5}, //Z - 3
{2, 2, 3, 4, 5, 5, 5}, //PP - 4
{2, 3, 4, 4, 5, 5, 6}, //PM - 5
{3, 4, 4, 5, 5, 6, 6} //PG - 6
};
int npe,npdfi, numeroRegrasInferencia, ncsaida, xnc[5], ync[5];
double erro, variacaoErro, regrasInferenciaObtidas[NQ][NQ],
regrasInferenciaUnidas[NQ], xmi[5], ymi[5], valorDefuzzificacao;
//módulo de Fuzzificação: int fuzzificação(int opcao)
int fuzzificacao(int opcao){
int valorRetorno = NQ/2;
int i;
float difAnt, difAtual;
switch (opcao){
case 1:{ //função fuzzificação para erro
difAnt = fabs (erro - vetorErro[0]);
//divisão da busca pelo vetor
if(erro < 0){
i=0;
while (valorRetorno == NQ/2 && i< NQ/2){
difAtual = fabs (erro - vetorErro[i+1]);
if (difAnt <= difAtual) valorRetorno = i;
difAnt = difAtual;
i++;
}
} else if(erro > 0){
i = valorRetorno + 1;
while (valorRetorno == NQ/2 && i < NQ){
difAtual = fabs (erro - vetorErro[i+1]);
if (difAnt <= difAtual) valorRetorno = i;
difAnt = difAtual;
i++;
}
}
}
case 2: { //função fuzzificação para variacao do erro
difAnt = fabs(variacaoErro - vetorVariacaoErro[0]);
//divisão da busca pelo vetor
if(variacaoErro < 0){
i=0;
while (valorRetorno == NQ/2 && i< NQ/2){
84
difAtual = fabs (variacaoErro -
vetorVariacaoErro[i+1]);
if (difAnt <= difAtual) valorRetorno = i;
difAnt = difAtual;
i++;
}
} else if(variacaoErro > 0){
i = valorRetorno + 1;
while (valorRetorno == NQ/2 && i < NQ){
difAtual = fabs (variacaoErro -
vetorVariacaoErro[i+1]);
if (difAnt <= difAtual) valorRetorno = i;
difAnt = difAtual;
i++;
}
}
}
}
return valorRetorno;
}
/*módulo de Regras de Inferência:
* void obterRegrasInferencia(int valorYmi, int valorXmi)
* void unirRegrasInferencia() */
void obterRegrasInferencia(int valorYmi, int valorXmi){
double minimo;
int i;
minimo = xmi[valorXmi];
if(ymi[valorYmi] < minimo) minimo = ymi[valorYmi];
for(i=0;i< NQ; i++){
if(minimo < cFuzzy[ncsaida][i])
regrasInferenciaObtidas[numeroRegrasInferencia][i] = minimo;
else regrasInferenciaObtidas[numeroRegrasInferencia][i] =
cFuzzy[ncsaida][i];
}
}
void unirRegrasInferencia(){
int i, j;
float maximo;
for(j=0;j<NQ;j++){
maximo = regrasInferenciaObtidas[0][j];
for (i=1;i<numeroRegrasInferencia;i++)
if (regrasInferenciaObtidas[i][j] > maximo) maximo =
regrasInferenciaObtidas[i][j];
regrasInferenciaUnidas[j] = maximo;
}
}
//módulo de defuzzificacao: double defuzzificacao()
double defuzzificacao(){
double soma = 0.0, produto = 0.0;
int i;
for (i=0; i < NQ; i++){
soma+=regrasInferenciaUnidas[i];
85
produto+= regrasInferenciaUnidas[i]*vetorDelta[i];
}
return produto/soma;
}
//chamada aos métodos concernente ao controle de posição
double controladorFuzzyPosicao(double e, double ve){
//para a chamada da fuzzificação, devido ao uso de variáveis
globais,
//uso parâmetro para controle de qual fuzzificação está sendo
calculada
//1 - cálculo posição de erro de posição
//2 - cálculo posição de variação de erro de posição
int posicaoErro, posicaoVarErro;
erro = e;
variacaoErro = ve;
posicaoErro = fuzzificacao(1);
posicaoVarErro = fuzzificacao(2);
npe = 0;
int i,j;
for (i=0; i<CARDINALIDADE;i++)
if(cFuzzy[i][posicaoErro]!=0.0){
xnc[npe] = i;
xmi [npe] = cFuzzy[i][posicaoErro];
npe++;
}
npdfi = 0;
for (i=0; i<CARDINALIDADE;i++)
if(cFuzzy[i][posicaoVarErro]!=0.0){
ync[npdfi] = i;
ymi [npdfi] = cFuzzy[i][posicaoVarErro];
npdfi++;
}
numeroRegrasInferencia = 0;
for (i=0; i<npe; i++)
for (j=0; j<npdfi; j++){
ncsaida = regrasImplicacao[ync[j]][xnc[i]];
obterRegrasInferencia(j, i);
numeroRegrasInferencia++;
}
unirRegrasInferencia();
valorDefuzzificacao = defuzzificacao();
return valorDefuzzificacao;
}
//chamada aos métodos concernente ao controle de velocidade
double controladorFuzzyVelocidade(double e, double ve){
//para a chamada da fuzzificação, devido ao uso de variáveis
globais,
//uso parâmetro para controle de qual fuzzificação está sendo
calculada
//1 - cálculo posição de erro de velocidade
//2 - cálculo posição de variação de erro de velocidade
int velocidadeErro, velocidadeVarErro;
erro = e;
variacaoErro = ve;
86
velocidadeErro = fuzzificacao(1);
velocidadeVarErro = fuzzificacao(2);
npe = 0;
int i, j;
for (i=0; i<CARDINALIDADE;i++)
if(cFuzzy[i][velocidadeErro]!=0.0){
xnc[npe] = i;
xmi [npe] = cFuzzy[i][velocidadeErro];
npe++;
}
npdfi = 0;
for (i=0; i<CARDINALIDADE;i++)
if(cFuzzy[i][velocidadeVarErro]!=0.0){
ync[npdfi] = i;
ymi [npdfi] = cFuzzy[i][velocidadeVarErro];
npdfi++;
}
numeroRegrasInferencia = 0;
for (i=0; i<npe; i++)
for (j=0; j<npdfi; j++){
ncsaida = regrasImplicacao[ync[j]][xnc[i]];
obterRegrasInferencia(j, i);
numeroRegrasInferencia++;
}
unirRegrasInferencia();
valorDefuzzificacao = defuzzificacao();
return valorDefuzzificacao;
}
87
Anexo B – Tabela com os dados da execução do Teste 01
Tabela 8 - Dados da execução do Teste 01
Ângulo Erro Variação de Erro Valor Defuzzificado
41 -1,2667 1,2667 -0,0936
42 -1,2556 -0,0111 -0,289
43 -1,2444 -0,0111 -0,289
44 -1,2333 -0,0111 -0,289
45 -1,2222 -0,0111 -0,289
46 -1,2111 -0,0111 -0,289
47 -1,2 -0,0111 -0,289
48 -1,1889 -0,0111 -0,289
49 -1,1778 -0,0111 -0,289
50 -1,1667 -0,0111 -0,289
51 -1,1556 -0,0111 -0,289
52 -1,1444 -0,0111 -0,289
53 -1,1333 -0,0111 -0,289
54 -1,1222 -0,0111 -0,289
55 -1,1111 -0,0111 -0,289
56 -1,1 -0,0111 -0,289
57 -1,0889 -0,0111 -0,289
88
58 -1,0778 -0,0111 -0,289
59 -1,0667 -0,0111 -0,289
60 -1,0556 -0,0111 -0,289
61 -1,0444 -0,0111 -0,289
62 -1,0333 -0,0111 -0,289
63 -1,0222 -0,0111 -0,289
64 -1,0111 -0,0111 -0,289
65 -1 -0,0111 -0,289
66 -0,9889 -0,0111 -0,289
67 -0,9778 -0,0111 -0,289
68 -0,9667 -0,0111 -0,289
69 -0,9556 -0,0111 -0,2608
70 -0,9444 -0,0111 -0,2608
71 -0,9333 -0,0111 -0,2608
72 -0,9222 -0,0111 -0,2608
73 -0,9111 -0,0111 -0,2608
74 -0,9 -0,0111 -0,2608
75 -0,8889 -0,0111 -0,2608
76 -0,8778 -0,0111 -0,2608
89
77 -0,8667 -0,0111 -0,2341
78 -0,8556 -0,0111 -0,2341
79 -0,8444 -0,0111 -0,2341
80 -0,8333 -0,0111 -0,2341
81 -0,8222 -0,0111 -0,2341
82 -0,8111 -0,0111 -0,2341
83 -0,8 -0,0111 -0,2341
84 -0,7889 -0,0111 -0,2074
85 -0,7778 -0,0111 -0,2074
86 -0,7667 -0,0111 -0,2074
87 -0,7556 -0,0111 -0,2074
88 -0,7444 -0,0111 -0,2074
89 -0,7333 -0,0111 -0,2074
90 -0,7222 -0,0111 -0,2074
91 -0,7111 -0,0111 -0,2074
92 -0,7 -0,0111 -0,1797
93 -0,6889 -0,0111 -0,1797
94 -0,6778 -0,0111 -0,1797
95 -0,6667 -0,0111 -0,1797
90
96 -0,6556 -0,0111 -0,1797
97 -0,6444 -0,0111 -0,1797
98 -0,6333 -0,0111 -0,1797
99 -0,6222 -0,0111 -0,1515
100 -0,6111 -0,0111 -0,1515
101 -0,6 -0,0111 -0,1515
102 -0,5889 -0,0111 -0,1515
103 -0,5778 -0,0111 -0,1515
104 -0,5667 -0,0111 -0,1515
105 -0,5556 -0,0111 -0,1515
106 -0,5444 -0,0111 -0,1515
107 -0,5333 -0,0111 -0,1238
108 -0,5222 -0,0111 -0,1238
109 -0,5111 -0,0111 -0,1238
110 -0,5 -0,0111 -0,1238
111 -0,4889 -0,0111 -0,1238
112 -0,4778 -0,0111 -0,1238
113 -0,4667 -0,0111 -0,1238
114 -0,4556 -0,0111 -0,1081
91
115 -0,4444 -0,0111 -0,1081
116 -0,4333 -0,0111 -0,1081
117 -0,4222 -0,0111 -0,1081
118 -0,4111 -0,0111 -0,1081
119 -0,4 -0,0111 -0,1081
120 -0,3889 -0,0111 -0,1081
121 -0,3778 -0,0111 -0,1081
122 -0,3667 -0,0111 -0,0929
123 -0,3556 -0,0111 -0,0929
124 -0,3444 -0,0111 -0,0929
125 -0,3333 -0,0111 -0,0929
126 -0,3222 -0,0111 -0,0929
127 -0,3111 -0,0111 -0,0929
128 -0,3 -0,0111 -0,0929
129 -0,2889 -0,0111 -0,0791
130 -0,2778 -0,0111 -0,0791
131 -0,2667 -0,0111 -0,0791
132 -0,2556 -0,0111 -0,0791
133 -0,2444 -0,0111 -0,0791
92
134 -0,2333 -0,0111 -0,0791
135 -0,2222 -0,0111 -0,0791
136 -0,2111 -0,0111 -0,0791
137 -0,2 -0,0111 -0,0588
138 -0,1889 -0,0111 -0,0588
139 -0,1778 -0,0111 -0,0588
140 -0,1667 -0,0111 -0,0588
141 -0,1556 -0,0111 -0,0588
142 -0,1444 -0,0111 -0,0588
143 -0,1333 -0,0111 -0,0588
144 -0,1222 -0,0111 -0,0323
145 -0,1111 -0,0111 -0,0323
146 -0,1 -0,0111 -0,0323
147 -0,0889 -0,0111 -0,0323
148 -0,0778 -0,0111 -0,0323
149 -0,0667 -0,0111 -0,0323
150 -0,0556 -0,0111 -0,0323
151 -0,0444 -0,0111 -0,0323
152 -0,0333 -0,0111 0
93
153 -0,0222 -0,0111 0
154 -0,0111 -0,0111 0
155 0 -0,0111 0
94
Anexo C – Tabela com os dados da execução do Teste 02
Tabela 9 - Dados da execução do Teste 02
Ângulo Erro Variação de Erro Valor Defuzzificado
155 1,4222 1,4222 0,552
154 1,4111 -0,0111 0,2331
153 1,4 -0,0111 0,2331
152 1,3889 -0,0111 0,2331
151 1,3778 -0,0111 0,2331
150 1,3667 -0,0111 0,2331
149 1,3556 -0,0111 0,2331
148 1,3444 -0,0111 0,2331
147 1,3333 -0,0111 0,2331
146 1,3222 -0,0111 0,2331
145 1,3111 -0,0111 0,2331
144 1,3 -0,0111 0,2331
143 1,2889 -0,0111 0,2331
142 1,2778 -0,0111 0,2331
141 1,2667 -0,0111 0,2331
140 1,2556 -0,0111 0,2331
139 1,2444 -0,0111 0,2331
95
138 1,2333 -0,0111 0,2331
137 1,2222 -0,0111 0,2331
136 1,2111 -0,0111 0,2331
135 1,2 -0,0111 0,2331
134 1,1889 -0,0111 0,2331
133 1,1778 -0,0111 0,2331
132 1,1667 -0,0111 0,2331
131 1,1556 -0,0111 0,2331
130 1,1444 -0,0111 0,2331
129 1,1333 -0,0111 0,2331
128 1,1222 -0,0111 0,2331
127 1,1111 -0,0111 0,2331
126 1,1 -0,0111 0,2331
125 1,0889 -0,0111 0,2331
124 1,0778 -0,0111 0,2331
123 1,0667 -0,0111 0,2331
122 1,0556 -0,0111 0,2331
121 1,0444 -0,0111 0,2331
120 1,0333 -0,0111 0,2331
96
119 1,0222 -0,0111 0,2331
118 1,0111 -0,0111 0,2331
117 1 -0,0111 0,2331
116 0,9889 -0,0111 0,2331
115 0,9778 -0,0111 0,2331
114 0,9667 -0,0111 0,2331
113 0,9556 -0,0111 0,2157
112 0,9444 -0,0111 0,2157
111 0,9333 -0,0111 0,2157
110 0,9222 -0,0111 0,2157
109 0,9111 -0,0111 0,2157
108 0,9 -0,0111 0,2157
107 0,8889 -0,0111 0,2157
106 0,8778 -0,0111 0,2157
105 0,8667 -0,0111 0,2019
104 0,8556 -0,0111 0,2019
103 0,8444 -0,0111 0,2019
102 0,8333 -0,0111 0,2019
101 0,8222 -0,0111 0,2019
97
100 0,8111 -0,0111 0,2019
99 0,8 -0,0111 0,2019
98 0,7889 -0,0111 0,1902
97 0,7778 -0,0111 0,1902
96 0,7667 -0,0111 0,1902
95 0,7556 -0,0111 0,1902
94 0,7444 -0,0111 0,1902
93 0,7333 -0,0111 0,1902
92 0,7222 -0,0111 0,1902
91 0,7111 -0,0111 0,1902
90 0,7 -0,0111 0,1798
89 0,6889 -0,0111 0,1798
88 0,6778 -0,0111 0,1798
87 0,6667 -0,0111 0,1798
86 0,6556 -0,0111 0,1798
85 0,6444 -0,0111 0,1798
84 0,6333 -0,0111 0,1798
83 0,6222 -0,0111 0,1516
82 0,6111 -0,0111 0,1516
98
81 0,6 -0,0111 0,1516
80 0,5889 -0,0111 0,1516
79 0,5778 -0,0111 0,1516
78 0,5667 -0,0111 0,1516
77 0,5556 -0,0111 0,1516
76 0,5444 -0,0111 0,1516
75 0,5333 -0,0111 0,1239
74 0,5222 -0,0111 0,1239
73 0,5111 -0,0111 0,1239
72 0,5 -0,0111 0,1239
71 0,4889 -0,0111 0,1239
70 0,4778 -0,0111 0,1239
69 0,4667 -0,0111 0,1239
68 0,4556 -0,0111 0,1082
67 0,4444 -0,0111 0,1082
66 0,4333 -0,0111 0,1082
65 0,4222 -0,0111 0,1082
64 0,4111 -0,0111 0,1082
63 0,4 -0,0111 0,1082
99
62 0,3889 -0,0111 0,1082
61 0,3778 -0,0111 0,1082
60 0,3667 -0,0111 0,093
59 0,3556 -0,0111 0,093
58 0,3444 -0,0111 0,093
57 0,3333 -0,0111 0,093
56 0,3222 -0,0111 0,093
55 0,3111 -0,0111 0,093
54 0,3 -0,0111 0,093
53 0,2889 -0,0111 0,0792
52 0,2778 -0,0111 0,0792
51 0,2667 -0,0111 0,0792
50 0,2556 -0,0111 0,0792
49 0,2444 -0,0111 0,0792
48 0,2333 -0,0111 0,0792
47 0,2222 -0,0111 0,0792
46 0,2111 -0,0111 0,0792
45 0,2 -0,0111 0,0588
44 0,1889 -0,0111 0,0588
100
43 0,1778 -0,0111 0,0588
42 0,1667 -0,0111 0,0588
41 0,1556 -0,0111 0,0588
40 0,1444 -0,0111 0,0588
39 0,1333 -0,0111 0,0588
38 0,1222 -0,0111 0,0588
37 0,1111 -0,0111 0,0588
36 0,1 -0,0111 0,0588
35 0,0889 -0,0111 0,0588
34 0,0778 -0,0111 0,0588
33 0,0667 -0,0111 0,0588
32 0,0556 -0,0111 0,0588
31 0,0444 -0,0111 0,0588
30 0,0333 -0,0111 0,0588
29 0,0222 -0,0111 0,0588
28 0,0111 -0,0111 0,0588
27 0 -0,0111 0
101
Anexo D – Tabela com os dados da execução do Teste 03
Tabela 10 - Dados da execução do Teste 03
Ângulo Erro Variação de Erro Valor Defuzzificado
27 -0,7 0,7 0
28 -0,6889 -0,0111 -0,1797
29 -0,6778 -0,0111 -0,1797
30 -0,6667 -0,0111 -0,1797
31 -0,6556 -0,0111 -0,1797
32 -0,6444 -0,0111 -0,1797
33 -0,6333 -0,0111 -0,1797
34 -0,6222 -0,0111 -0,1515
35 -0,6111 -0,0111 -0,1515
36 -0,6 -0,0111 -0,1515
37 -0,5889 -0,0111 -0,1515
38 -0,5778 -0,0111 -0,1515
39 -0,5667 -0,0111 -0,1515
40 -0,5556 -0,0111 -0,1515
41 -0,5444 -0,0111 -0,1515
42 -0,5333 -0,0111 -0,1238
43 -0,5222 -0,0111 -0,1238
102
44 -0,5111 -0,0111 -0,1238
45 -0,5 -0,0111 -0,1238
46 -0,4889 -0,0111 -0,1238
47 -0,4778 -0,0111 -0,1238
48 -0,4667 -0,0111 -0,1238
49 -0,4556 -0,0111 -0,1081
50 -0,4444 -0,0111 -0,1081
51 -0,4333 -0,0111 -0,1081
52 -0,4222 -0,0111 -0,1081
53 -0,4111 -0,0111 -0,1081
54 -0,4 -0,0111 -0,1081
55 -0,3889 -0,0111 -0,1081
56 -0,3778 -0,0111 -0,1081
57 -0,3667 -0,0111 -0,0929
58 -0,3556 -0,0111 -0,0929
59 -0,3444 -0,0111 -0,0929
60 -0,3333 -0,0111 -0,0929
61 -0,3222 -0,0111 -0,0929
62 -0,3111 -0,0111 -0,0929
103
63 -0,3 -0,0111 -0,0929
64 -0,2889 -0,0111 -0,0791
65 -0,2778 -0,0111 -0,0791
66 -0,2667 -0,0111 -0,0791
67 -0,2556 -0,0111 -0,0791
68 -0,2444 -0,0111 -0,0791
69 -0,2333 -0,0111 -0,0791
70 -0,2222 -0,0111 -0,0791
71 -0,2111 -0,0111 -0,0791
72 -0,2 -0,0111 -0,0588
73 -0,1889 -0,0111 -0,0588
74 -0,1778 -0,0111 -0,0588
75 -0,1667 -0,0111 -0,0588
76 -0,1556 -0,0111 -0,0588
77 -0,1444 -0,0111 -0,0588
78 -0,1333 -0,0111 -0,0588
79 -0,1222 -0,0111 -0,0323
80 -0,1111 -0,0111 -0,0323
81 -0,1 -0,0111 -0,0323
104
82 -0,0889 -0,0111 -0,0323
83 -0,0778 -0,0111 -0,0323
84 -0,0667 -0,0111 -0,0323
85 -0,0556 -0,0111 -0,0323
86 -0,0444 -0,0111 -0,0323
87 -0,0333 -0,0111 0
88 -0,0222 -0,0111 0
89 -0,0111 -0,0111 0
90 0 -0,0111 0
105
Anexo E – Tabela com os dados da execução do Teste 04
Tabela 11 - Dados da execução do Teste 04
Ângulo Erro Variação de Erro Valor Defuzzificado
90 0,7667 0,7667 0,4829
89 0,7556 -0,0111 0,1902
88 0,7444 -0,0111 0,1902
87 0,7333 -0,0111 0,1902
86 0,7222 -0,0111 0,1902
85 0,7111 -0,0111 0,1902
84 0,7 -0,0111 0,1798
83 0,6889 -0,0111 0,1798
82 0,6778 -0,0111 0,1798
81 0,6667 -0,0111 0,1798
80 0,6556 -0,0111 0,1798
79 0,6444 -0,0111 0,1798
78 0,6333 -0,0111 0,1798
77 0,6222 -0,0111 0,1516
76 0,6111 -0,0111 0,1516
75 0,6 -0,0111 0,1516
74 0,5889 -0,0111 0,1516
106
73 0,5778 -0,0111 0,1516
72 0,5667 -0,0111 0,1516
71 0,5556 -0,0111 0,1516
70 0,5444 -0,0111 0,1516
69 0,5333 -0,0111 0,1239
68 0,5222 -0,0111 0,1239
67 0,5111 -0,0111 0,1239
66 0,5 -0,0111 0,1239
65 0,4889 -0,0111 0,1239
64 0,4778 -0,0111 0,1239
63 0,4667 -0,0111 0,1239
62 0,4556 -0,0111 0,1082
61 0,4444 -0,0111 0,1082
60 0,4333 -0,0111 0,1082
59 0,4222 -0,0111 0,1082
58 0,4111 -0,0111 0,1082
57 0,4 -0,0111 0,1082
56 0,3889 -0,0111 0,1082
55 0,3778 -0,0111 0,1082
107
54 0,3667 -0,0111 0,093
53 0,3556 -0,0111 0,093
52 0,3444 -0,0111 0,093
51 0,3333 -0,0111 0,093
50 0,3222 -0,0111 0,093
49 0,3111 -0,0111 0,093
48 0,3 -0,0111 0,093
47 0,2889 -0,0111 0,0792
46 0,2778 -0,0111 0,0792
45 0,2667 -0,0111 0,0792
44 0,2556 -0,0111 0,0792
43 0,2444 -0,0111 0,0792
42 0,2333 -0,0111 0,0792
41 0,2222 -0,0111 0,0792
40 0,2111 -0,0111 0,0792
39 0,2 -0,0111 0,0588
38 0,1889 -0,0111 0,0588
37 0,1778 -0,0111 0,0588
36 0,1667 -0,0111 0,0588
108
35 0,1556 -0,0111 0,0588
34 0,1444 -0,0111 0,0588
33 0,1333 -0,0111 0,0588
32 0,1222 -0,0111 0,0588
31 0,1111 -0,0111 0,0588
30 0,1 -0,0111 0,0588
29 0,0889 -0,0111 0,0588
28 0,0778 -0,0111 0,0588
27 0,0667 -0,0111 0,0588
26 0,0556 -0,0111 0,0588
25 0,0444 -0,0111 0,0588
24 0,0333 -0,0111 0,0588
23 0,0222 -0,0111 0,0588
22 0,0111 -0,0111 0,0588
21 0 -0,0111 0
109
Anexo F – Tabela com os dados da execução do Teste 05
Tabela 12 - Dados da execução do Teste 05
Ângulo Erro Variação de Erro Valor Defuzzificado
21 -1,5222 1,5222 -0,0936
22 -1,5111 -0,0111 -0,289
23 -1,5 -0,0111 -0,289
24 -1,4889 -0,0111 -0,289
25 -1,4778 -0,0111 -0,289
26 -1,4667 -0,0111 -0,289
27 -1,4556 -0,0111 -0,289
28 -1,4444 -0,0111 -0,289
29 -1,4333 -0,0111 -0,289
30 -1,4222 -0,0111 -0,289
31 -1,4111 -0,0111 -0,289
32 -1,4 -0,0111 -0,289
33 -1,3889 -0,0111 -0,289
34 -1,3778 -0,0111 -0,289
35 -1,3667 -0,0111 -0,289
36 -1,3556 -0,0111 -0,289
37 -1,3444 -0,0111 -0,289
110
38 -1,3333 -0,0111 -0,289
39 -1,3222 -0,0111 -0,289
40 -1,3111 -0,0111 -0,289
41 -1,3 -0,0111 -0,289
42 -1,2889 -0,0111 -0,289
43 -1,2778 -0,0111 -0,289
44 -1,2667 -0,0111 -0,289
45 -1,2556 -0,0111 -0,289
46 -1,2444 -0,0111 -0,289
47 -1,2333 -0,0111 -0,289
48 -1,2222 -0,0111 -0,289
49 -1,2111 -0,0111 -0,289
50 -1,2 -0,0111 -0,289
51 -1,1889 -0,0111 -0,289
52 -1,1778 -0,0111 -0,289
53 -1,1667 -0,0111 -0,289
54 -1,1556 -0,0111 -0,289
55 -1,1444 -0,0111 -0,289
56 -1,1333 -0,0111 -0,289
111
57 -1,1222 -0,0111 -0,289
58 -1,1111 -0,0111 -0,289
59 -1,1 -0,0111 -0,289
60 -1,0889 -0,0111 -0,289
61 -1,0778 -0,0111 -0,289
62 -1,0667 -0,0111 -0,289
63 -1,0556 -0,0111 -0,289
64 -1,0444 -0,0111 -0,289
65 -1,0333 -0,0111 -0,289
66 -1,0222 -0,0111 -0,289
67 -1,0111 -0,0111 -0,289
68 -1 -0,0111 -0,289
69 -0,9889 -0,0111 -0,289
70 -0,9778 -0,0111 -0,289
71 -0,9667 -0,0111 -0,289
72 -0,9556 -0,0111 -0,2608
73 -0,9444 -0,0111 -0,2608
74 -0,9333 -0,0111 -0,2608
75 -0,9222 -0,0111 -0,2608
112
76 -0,9111 -0,0111 -0,2608
77 -0,9 -0,0111 -0,2608
78 -0,8889 -0,0111 -0,2608
79 -0,8778 -0,0111 -0,2608
80 -0,8667 -0,0111 -0,2341
81 -0,8556 -0,0111 -0,2341
82 -0,8444 -0,0111 -0,2341
83 -0,8333 -0,0111 -0,2341
84 -0,8222 -0,0111 -0,2341
85 -0,8111 -0,0111 -0,2341
86 -0,8 -0,0111 -0,2341
87 -0,7889 -0,0111 -0,2074
88 -0,7778 -0,0111 -0,2074
89 -0,7667 -0,0111 -0,2074
90 -0,7556 -0,0111 -0,2074
91 -0,7444 -0,0111 -0,2074
92 -0,7333 -0,0111 -0,2074
93 -0,7222 -0,0111 -0,2074
94 -0,7111 -0,0111 -0,2074
113
95 -0,7 -0,0111 -0,1797
96 -0,6889 -0,0111 -0,1797
97 -0,6778 -0,0111 -0,1797
98 -0,6667 -0,0111 -0,1797
99 -0,6556 -0,0111 -0,1797
100 -0,6444 -0,0111 -0,1797
101 -0,6333 -0,0111 -0,1797
102 -0,6222 -0,0111 -0,1515
103 -0,6111 -0,0111 -0,1515
104 -0,6 -0,0111 -0,1515
105 -0,5889 -0,0111 -0,1515
106 -0,5778 -0,0111 -0,1515
107 -0,5667 -0,0111 -0,1515
108 -0,5556 -0,0111 -0,1515
109 -0,5444 -0,0111 -0,1515
110 -0,5333 -0,0111 -0,1238
111 -0,5222 -0,0111 -0,1238
112 -0,5111 -0,0111 -0,1238
113 -0,5 -0,0111 -0,1238
114
114 -0,4889 -0,0111 -0,1238
115 -0,4778 -0,0111 -0,1238
116 -0,4667 -0,0111 -0,1238
117 -0,4556 -0,0111 -0,1081
118 -0,4444 -0,0111 -0,1081
119 -0,4333 -0,0111 -0,1081
120 -0,4222 -0,0111 -0,1081
121 -0,4111 -0,0111 -0,1081
122 -0,4 -0,0111 -0,1081
123 -0,3889 -0,0111 -0,1081
124 -0,3778 -0,0111 -0,1081
125 -0,3667 -0,0111 -0,0929
126 -0,3556 -0,0111 -0,0929
127 -0,3444 -0,0111 -0,0929
128 -0,3333 -0,0111 -0,0929
129 -0,3222 -0,0111 -0,0929
130 -0,3111 -0,0111 -0,0929
131 -0,3 -0,0111 -0,0929
132 -0,2889 -0,0111 -0,0791
115
133 -0,2778 -0,0111 -0,0791
134 -0,2667 -0,0111 -0,0791
135 -0,2556 -0,0111 -0,0791
136 -0,2444 -0,0111 -0,0791
137 -0,2333 -0,0111 -0,0791
138 -0,2222 -0,0111 -0,0791
139 -0,2111 -0,0111 -0,0791
140 -0,2 -0,0111 -0,0588
141 -0,1889 -0,0111 -0,0588
142 -0,1778 -0,0111 -0,0588
143 -0,1667 -0,0111 -0,0588
144 -0,1556 -0,0111 -0,0588
145 -0,1444 -0,0111 -0,0588
146 -0,1333 -0,0111 -0,0588
147 -0,1222 -0,0111 -0,0323
148 -0,1111 -0,0111 -0,0323
149 -0,1 -0,0111 -0,0323
150 -0,0889 -0,0111 -0,0323
151 -0,0778 -0,0111 -0,0323
116
152 -0,0667 -0,0111 -0,0323
153 -0,0556 -0,0111 -0,0323
154 -0,0444 -0,0111 -0,0323
155 -0,0333 -0,0111 0
156 -0,0222 -0,0111 0
157 -0,0111 -0,0111 0
158 0 -0,0111 0