Plataforma Geradora de Controladores Fuzzy em FPGA · xv RESUMO Resumo: A Lógica Fuzzy tem como...
Transcript of Plataforma Geradora de Controladores Fuzzy em FPGA · xv RESUMO Resumo: A Lógica Fuzzy tem como...
UNIVERSIDADE POSITIVO
NÚCLEO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
CURSO DE ENGENHARIA DA COMPUTAÇÃO
GIOVANNI GERALDO SZYCHTA
PEDRO ANDRIOW
Plataforma Geradora de Controladores Fuzzy em FPGA
Curitiba, Dezembro de 2011
GIOVANNI GERALDO SZYCHTA
PEDRO ANDRIOW
Plataforma Geradora de Controladores Fuzzy em FPGA
Monografia apresentada junto ao Curso de
Engenharia da Computação da Universidade
Positivo, Núcleo de Ciências Exatas e
Tecnológicas, como requisito parcial à
obtenção do título de Bacharel.
Orientador: Prof. Msc. Valfredo Pilla Júnior.
Curitiba, Dezembro de 2011
iii
GIOVANNI GERALDO SZYCHTA
PEDRO ANDRIOW
Plataforma Geradora de Controladores Fuzzy em FPGA
Trabalho de Conclusão de Curso apresentado ao Curso de Engenharia da
Computação, da Universidade Positvo, como requisito à obtenção do título de
Bacharel.
COMISSÃO EXAMINADORA
______________________________ Prof. Msc. Ederson Chichaczewski
Universidade Positivo
______________________________ Prof. Msc. Gilmar Amilton Macohin
Universidade Positivo
______________________________ Prof. Msc. Maristela Regina Weinfurter
Universidade Positivo
______________________________ Prof. Msc. Valfredo Pilla Júnior
Universidade Positivo
iv
v
UNIVERSIDADE POSITIVO Reitor: Prof. José Pio Martins Pró-Reitor de Administração: Prof. Arno Antonio Gnoatto Pró-Reitor Acadêmico: Prof.ª Márcia Sabastiani Coordenador do Curso de Engenharia da Computação: Prof. Leandro Henrique de Souza
vi
vii
A Deus por tudo que me proporciona na vida.
À minha mãe e meu pai, os quais amo muito, pelo
exemplo de vida e família.
Aos encontros inesperados,
por tornarem a vida mais divertida.
Giovanni Geraldo Szychta
Dedico esse trabalho a todos que estiveram ao meu lado,
me ajudando, me apoiando, e me dando toda estrutura
que precisei durante todo o curso.
Pedro Andriow
viii
ix
AGRADECIMENTOS
Durante esse longo período de graduação, muitas pessoas passaram por
minha vida. Deixaram muitas lições, muitas alegrias, proporcionaram novos
conhecimentos e contribuíram para o meu crescimento.
Entre estas pessoas, agradeço aos professores do curso de Engenharia da
Computação, que contribuíram partilhando seus conhecimentos.
Agradeço ao professor Valfredo Pilla Júnior, que além de professor e amigo,
participou deste trabalho como orientador.
Agradeço aos meus amigos, em especial os dos corredores e das salas de
aula, por estarem presentes nos mais diversos momentos.
Agradeço a minha namorada Amanda de Carvalho Nunes, por fazer
novamente parte da minha vida, me apoiando e me enchendo de alegria a cada
nova etapa deste trabalho.
Agradeço finalmente e principalmente à minha família, em especial ao meu
pai e minha mãe, por todo seu apoio, dedicação e esforço durante esta caminhada.
Giovanni Geraldo Szychta
x
xi
Ao longo de todo o curso de Engenharia da Computação muitas pessoas
estiveram presentes, e todas elas contribuíram para o meu conhecimento e
crescimento individual, não apenas em relação aos conteúdos vistos durante o
curso, mas cada uma influenciando de uma maneira ou outra na minha vida.
Antes de todos, gostaria de agradecer à minha família, por ter me dado todos
os valores que eu tenho, por ter me apoiado durante a graduação, e por estar
sempre ao meu lado, independente da situação.
Agradeço à minha namorada, Elisiê Pepino, que acompanhou o processo
desse trabalho sempre me apoiando, sendo compreensiva com as minhas ausências
devidas a dedicação ao projeto, e sempre com aquele sorriso maravilhoso me dando
novas forças a cada nova etapa.
Agradeço também aos meus amigos que sempre estiveram presentes e
muitas vezes ajudando e disponibilizando tempo sempre que precisei de alguma
ajuda, ou mesmo quando precisei desabafar.
Agradeço ao meu chefe e à empresa em que trabalho por sempre entender e
sempre priorizar meus estudos, me liberando sempre que precisei de tempo para o
desenvolvimento desse trabalho.
Gostaria também de agradecer a todos os professores, e em especial ao
nosso orientador, professor Valfredo Pilla Júnior, que com maestria compartilharam
o conhecimento e sempre estiveram disponíveis para sanar minhas dúvidas ou
mesmo para conversas, gerando ideias de novos projetos.
Pedro Andriow
xii
xiii
E quando você pensa que tudo mais pode falhar. Lembre-se,
coisas piores acontecem no mar.
Confraria da Costa – Coisas Piores Acontecem no Mar.
xiv
xv
RESUMO
Resumo: A Lógica Fuzzy tem como principal finalidade o estudo dos princípios formais do raciocínio aproximado e pode ser empregado em inúmeras aplicações práticas tais como controle de temperatura, volume, iluminação, entre outros. Porém o processo de manual de geração das tabelas Fuzzy é um tedioso e sujeito a erros. Buscando facilitar esse processo propomos o desenvolvimento de uma estrutura em hardware que encapsule toda a complexidade da Lógica Fuzzy, deixando ao usuário apenas a tarefa de definir as tabelas de regras Fuzzy utilizando as variáveis linguísticas em formato IF-THEN de cada variável e definições básicas do tipo: valor mínimo de inferência, valor máximo e ponto em que a pertinência é a máxima. O hardware definido para o encapsulamento são as FPGAS, pois possui um maior poder de escalonamento do número de variáveis e paralelismo para a realização dos cálculos Fuzzy. Outra vantagem na utilização das FPGAS é a facilidade na integração com sistemas embarcados. O sistema desenvolvido é constituído por um módulo de processamento no qual o usuário define a tabela de regras, e define os arquivos de memória contendo os valores de pertinências. O sistema se adapta a essas novas diretivas e com esses dados gera a solução Fuzzy já tratada, assim a preocupação do usuário se limita à modelagem do sistema inicial. O sistema Fuzzy projetado é representado em um código VHDL (Very High Speed Integrated Circuits
Hardware Description Language). Para validação da ferramenta projetou-se um controlador de temperatura no qual o usuário determina o valor de temperatura ideal e a tabela de regras. Nesta tabela define-se através de variáveis linguísticas qual a saída ideal do projeto teórico de refrigeração em que o sistema estaria funcionando. A busca das pertinências é realizada pelo circuito digital inferido pelo código VHDL de forma transparente ao usuário. O método de inferência Fuzzy utilizado consiste na leitura dos sensores, a partir desses dados realiza a busca da pertinência relativa à leitura na memória da FPGA, aplica a tabela de regras definida em VHDL no padrão IF-THEN e então aplica o método de centro de gravidade para defuzzificação. O usuário deve gerar os arquivos de memória contendo os valores das pertinências, utilizando o software de definição de pertinências, estes arquivos serão utilizados pela FPGA. A saída é feita na forma de uma máquina de estados implementada em VHDL que transmite as variáveis para um micro controlador externo, cuja função é a leitura dos sensores e o acionamento dos atuadores.
Palavras-chave: Lógica Fuzzy, FPGA, VHDL
xvi
xvii
ABSTRACT
Abstract: Fuzzy Logic has as main purpose to study the formal principles of approximate reasoning and can be used in numerous practical applications such as temperature control, volume, lighting, among others. But the manual process of generating fuzzy tables is a tedious and error prone. Seeking to facilitate this process we propose the development of a hardware structure that encapsulates the complexity of Fuzzy Logic, leaving the user only the task of defining the rules tables Fuzzy linguistic variables using IF-THEN format of each variable and the basic definitions type: minimum of inference, maximum and the point where the relevance is the maximum. The hardware package is set to the FPGAs, which has a greater power scaling of the number of variables and parallel to the calculations Fuzzy. Another advantage of using FPGAs is the ease of integration with embedded systems. The developed system consists of a processing module in which the user defines the rules table, and sets the memory files containing the values of relevance. The system adapts to these new policies and these data generates the solution treated as fuzzy, so the user's concern is limited to modeling the initial system. The fuzzy system designed is represented in a code VHDL (Very High Speed Integrated Circuits Hardware Description Language). For validation tool designed to a temperature controller in which the user determines the value of optimal temperature and the rules table.This table is defined by linguistic variables which the output of the ideal theoretical project in which the cooling system was working. The pertinence of the search is performed by the digital circuit inferred by VHDL code transparent to the user. The fuzzy inference method used consists of reading the sensors, from these data makes the search for relevance on the reading in memory of the FPGA, applies the rules table defined in the VHDL standard IF-THEN and then apply the method of center gravity for defuzzification. The user must generate the memory containing the values of relevance, using the software definition of relevance, these files will be used by the FPGA. The output is in the form of a state machine implemented in VHDL variables to which transmits an external microcontroller, whose function is to read the sensors and driving actuators.
Key-words: Fuzzy Logic, FPGA, VHDL
xviii
xix
LISTA DE ILUSTRAÇÕES
FIGURA 1 - CONTROLADOR FUZZY LÓGICO (LIU ET AL, 2011) .................................................................... 31
FIGURA 2 - GRÁFICOS DE PERTINÊNCIA UTILIZADOS(LIU ET AL, 2011) ........................................................ 32
FIGURA 3 - PERTINÊNCIA FUZZY TRAPEZOIDAL (KHUDHAIR ET AL, 2010) ................................................. 33
FIGURA 4 - PERTINÊNCIA FUZZY PONTUAL (KHUDHAIR ET AL, 2010) ....................................................... 33
FIGURA 5 - ARQUITETURA GERAL DO SISTEMA ........................................................................................... 41
FIGURA 6 - LÓGICA DO CÁLCULO FUZZY.................................................................................................... 42
FIGURA 7- LÓGICA IMPLEMENTADA NO MICRO CONTROLADOR .................................................................... 43
FIGURA 8 - INTERFACE DO SOFTWARE PARA GERAR OS ARQUIVOS DE MEMÓRIA .......................................... 44
FIGURA 9 - ALGORITMO DE CÁLCULO DE PERTINÊNCIA ............................................................................... 45
FIGURA 10 - GRÁFICO DE PERTINÊNCIAS GERADAS PARA O PROJETO ......................................................... 52
FIGURA 11 - CONVERSÃO DA BASE DECIMAL PARA PONTO FIXO .................................................................. 55
FIGURA 12 - RECEBIMENTO DOS DADOS DE FORMA PARALELA NO MICRO CONTROLADOR ............................. 56
FIGURA 13 - CONVERSÃO DA BASE DE PONTO FIXO PARA BASE DECIMAL ..................................................... 57
FIGURA 14 - FÓRMULA DE MÉDIA PONDERADA ........................................................................................... 57
FIGURA 15 - TABELA DE REGRAS IMPLEMENTADA EM VHDL ....................................................................... 61
FIGURA 16 - CONTADOR DE MEMÓRIA IMPLEMENTADO EM VHDL ............................................................... 62
FIGURA 17 - TELA DE RESUMO DA COMPILAÇÃO ......................................................................................... 63
FIGURA 18 - CÁLCULO DO ERRO ............................................................................................................... 66
FIGURA 19 - CÁLCULO DO ERRO MÉDIO ..................................................................................................... 67
xx
xxi
LISTA DE TABELAS
TABELA 1 - TABELA DE REGRAS (LIU ET AL, 2011) .................................................................................... 31
TABELA 2 - TABELA DE REGRAS FUZZY ..................................................................................................... 53
TABELA 3 - IDS E DADOS A SEREM TRANSMITIDOS ...................................................................................... 54
TABELA 4 - TABELA DE REGRAS FUZZY - CONTROLE DE TEMPERATURA TEÓRICO ........................................ 59
TABELA 5 - PORCENTAGEM DE ATIVAÇÃO REAL DO SISTEMA ....................................................................... 65
TABELA 6 - PORCENTAGEM DE ATIVAÇÃO SIMULADA DO SISTEMA ................................................................ 65
TABELA 7 - TABELA COMPARATIVA REAL X SIMULADO ................................................................................ 66
TABELA 8 - COMPARAÇÃO DAS ATIVIDADES A SEREM DESENVOLVIDAS COM E SEM A PLATAFORMA................ 70
xxii
xxiii
LISTA DE ABREVIATURAS E SIGLAS
FPGA – Field programmable gate array
VHDL – VHSIC Hardware Description Language
VHSIC – Very High Speed Integrated Circuits
Waveform – Forma de onda resultada da simulação do software Quartus II
FLC – Fuzzy Logic Controllers
ASIC – Application Specific Integrated Circuit
AGs – Algoritmos Genéticos
QEE – Qualidade de Energia Elétrica
PMLSM – Permanent-Magnet Linear Synchronous Motor
DSP – Digital Signal Processor
CPU – Central Processing Unit
PWM – Pulse Width Modulation
USB – Universal Serial Bus
LED – Light Emitting Diode
xxiv
xxv
SUMÁRIO
1 INTRODUÇÃO ................................................................................................................................... 27
2 FUNDAMENTAÇÃO TEÓRICA ......................................................................................................... 29
2.1 CONTROLE ATRAVÉS DA LÓGICA FUZZY .............................................................................. 32
3 ESPECIFICAÇÃO DO PROJETO ..................................................................................................... 39
3.1 OBJETIVOS................................................................................................................................. 39
3.2 CARACTERÍSTICAS DO PROJETO ........................................................................................... 40
3.2.1 Requisitos ............................................................................................................................. 40
3.3 ARQUITETURA ........................................................................................................................... 41
3.3.1 Módulo de Processamento ................................................................................................... 42
3.3.2 Módulo de Comunicação e Avaliação .................................................................................. 43
3.3.3 Módulo de Desenvolvimento, Configuração e Debug .......................................................... 44
3.3.4 Uso da Plataforma ................................................................................................................ 46
3.4 TESTES DE VALIDAÇÃO DO SISTEMA .................................................................................... 46
3.4.1 Testes de validação de conversões do micro controlador ................................................... 46
3.4.2 Testes de validação da aplicação da lógica Fuzzy .............................................................. 47
4 PROJETO .......................................................................................................................................... 49
4.1 HARDWARE FUZZY ................................................................................................................... 49
4.1.1 Recebimento dos Dados ...................................................................................................... 49
4.1.2 Busca de Pertinências .......................................................................................................... 49
4.1.3 Aplicação da Tabela de Regras ........................................................................................... 50
4.1.4 Envio dos Dados Para Defuzzificação ................................................................................. 50
4.1.5 Digrama em blocos da FPGA ............................................................................................... 51
4.2 MICRO CONTROLADOR ............................................................................................................ 54
4.2.1 Recebimento do Dado a Ser Tratado .................................................................................. 54
4.2.2 Conversão Para Base de Ponto Fixo ................................................................................... 55
4.2.3 Envio do Dado Para a FPGA ............................................................................................... 55
4.2.4 Recebimento do Resultado .................................................................................................. 56
4.2.5 Conversão do Resultado Para Base Decimal ...................................................................... 57
4.2.6 Defuzzificação ...................................................................................................................... 57
4.2.7 Retorno do Resultado Em Decimal Para o Usuário ............................................................. 58
5 RESULTADOS ................................................................................................................................... 59
5.1 CASO DE TESTE ........................................................................................................................ 59
5.2 CONFIGURAÇÕES DO PROJETO ............................................................................................. 60
5.3 RESULTADOS DA MODELAGEM VHDL .................................................................................... 62
5.4 RESULTADOS – MÓDULO DE PROCESSAMENTO ................................................................. 63
5.5 RESULTADOS – SISTEMA COMPLETO .................................................................................... 64
xxvi
5.6 VALIDAÇÕES DOS VALORES ................................................................................................... 66
6 CONCLUSÕES .................................................................................................................................. 69
6.1 CONCLUSÕES GERAIS ............................................................................................................. 69
6.2 FUTURAS IMPLEMENTAÇÕES ................................................................................................. 71
REFERÊNCIAS ..................................................................................................................................... 73
ANEXOS ............................................................................................................................................... 77
27
1 INTRODUÇÃO
Pode-se dizer que fatores como incerteza e ambigüidade na definição de
parâmetros de um sistema são fatores que aumentam muito a complexidade da
modelagem, tornando-a, em muitos casos inviável. Para o tratamento desses fatores
foi desenvolvida, baseada na teoria clássica de conjuntos, a lógica Fuzzy. Este tipo
de lógica permite que sejam quantificadas variáveis lingüísticas, ou seja, que não
possuem valores precisos. Esta quantificação se dá através da teoria de conjuntos
Fuzzy, a qual possibilita ter graus de pertinência entre um elemento e os conjuntos
ao qual pode pertencer. Constrói-se uma base de regras onde os valores são
lingüísticos (imprecisos), dando flexibilidade ao sistema (quanto a estados que este
pode assumir) e facilitando a compreensão do problema (DA COSTA et al, 2003).
Os sistemas Fuzzy são sistemas baseados em regras que utilizam variáveis
lingüísticas difusas (conjuntos difusos) para executar um processo de tomada de
decisão (ADILEA, 2003). Pois embora todo o potencial da lógica Fuzzy seja
divulgado, na prática, sistemas complexos não são fáceis de implementar
(SANTANA et al, 2005).
Controladores de lógica Fuzzy (FLC – Fuzzy Logic Controllers) oferecem um
método simples para controle de sistemas altamente complexos e imprecisos, sem a
necessidade de um modelo com precisão matemática detalhada da planta que será
controlada. A lógica Fuzzy fornece um processo para lidar com as incertezas desses
sistemas complexos usando um método de raciocínio humano, com o uso de
variáveis lingüísticas que são avaliadas por um conjunto de regras do tipo IF-THEN.
A semelhança entre o funcionamento da lógica Fuzzy, e os fundamentos do
processo de pensamento humano, permite ao controlador capturar o conhecimento
de especialistas humanos e transformá-lo em regras usadas para controlar o sistema
(KHUDHAIR et al, 2010).
Já a algum tempo, os controladores Fuzzy têm sido implementados através
de métodos de software puros em um microprocessador de propósito geral, com
uma arquitetura de hardware reconfigurável acoplado a fim de utilizar a flexibilidade
do microprocessador com o desempenho do hardware reconfigurável (TEIXEIRA et
al, 1995, ARANGUREN et al, 2002).
28
Este tipo de design proporciona uma grande flexibilidade com a definição dos
parâmetros Fuzzy (funções de pertinência e regras de inferência), mas a demanda
de alta potência, e da área necessária para a arquitetura completa, faz este tipo de
projeto inadequado para aplicações nas quais o tamanho do controlador é um fator
importante. Isso por si já inviabiliza a utilização em sistemas embarcados que
demandam de processadores com uma área pequena, que tenham um consumo
reduzido, e que também tenham um custo atraente. Projetos de hardware puro, por
outro lado, têm a vantagem de satisfazer a área, potência e desempenho em uma
escala de produção suficiente para obter um alto custo benefício (KHUDHAIR et al,
2010).
A dificuldade na implementação de um sistema de controle em um ASIC
(Application Specific Integrated Circuit), o tempo longo para o mercado, e o fato de
que a modificação dos parâmetros de controle não é possível com projetos
baseados em ASIC, têm incentivado os pesquisadores a olhar para as FPGAs (Field
Programmable Gate Arrays) (KHUDHAIR et al, 2010).
A progressão nas tecnologias de silício e microeletrônica permitiu também a
redução do tamanho das FPGAs e, portanto, seu custo (SANCHES et al, 2007,
WANG et al, 2006, ARANGUREN et al, 2002), permitiu também a disponibilidade de
linguagens de nível de design do sistema, que têm simplificado o processo de
desenvolvimento significativamente, possibilitando que as FPGAs sejam usadas não
apenas como uma tecnologia de prototipagem, mas também como a solução final
para os produtos, e, portanto, tem diminuído drasticamente o tempo de mercado
para soluções de hardware (WANG et al, 2006).
Buscando facilitar a implantação de sistemas baseados em lógica Fuzzy, este
projeto trata do desenvolvimento de uma plataforma que possibilita a aplicação de
lógica Fuzzy em hardware. A plataforma implementada em FPGA, realiza os
cálculos matemáticos responsáveis pela interação da base de regras e a tabela de
valores. Como resultado, a plataforma retorna as informações de pertinência,
caracterizado por ser um valor entre 0 e 1, representando o resultado final do
circuito.
A operação realizada em hardware permite que o projetista do sistema Fuzzy
foque no desenvolvimento e na modelagem do sistema e não no trabalho de
desenvolvimento dos cálculos relativos à lógica Fuzzy.
29
2 FUNDAMENTAÇÃO TEÓRICA
Lidar com fatores como ambigüidade, incerteza e informações vagas na
resolução de problemas é uma característica do pensamento humano, que usa o
conhecimento adquirido e experiências para lidar com esses fatores (KLIR,1997)
(MUKAIDONO, 2001).
Nos problemas de difícil solução, em que se faz necessário o auxílio
matemático/computacional, modelar tais fatores é extremamente difícil. A
modelagem computacional convencional não trabalha com ambigüidades, pois
utiliza o conceito de verdadeiro ou falso (MUKAIDONO, 2001).
A precisão computacional também é limitada, deixando sempre uma margem,
por mínima que seja para a incerteza (KLIR, 1997). A vagueza de informações
advinda da linguagem natural agrava ainda mais os fatores citados. Para lidar com
isso de forma matemática, foi desenvolvida por Zadeh a Teoria dos Conjuntos Fuzzy
(Conjuntos Nebulosos ou Difusos), teoria a qual permitia serem tratados níveis de
incerteza e ambigüidade (DA COSTA et al, 2003).
Na década de 60, um professor de Engenharia Elétrica e Ciência da
Computação, chamado Lotfi Zadeh (1965) desenvolveu uma variação da tradicional
teoria dos conjuntos e lógica booleana para tornar a análise e controle de sistemas
complexos de controle mais tratáveis. Zadeh observou que muitas regras que as
pessoas usavam para fazer inferências não eram conscientes, ou seja, não podiam
ser explicadas pelas pessoas que as usavam. Por exemplo, podemos olhar para
uma pessoa e dizer “ele parece ter por volta de 35 anos”, mas não se está
preparado para explicar como sabemos disso (DA COSTA et al, 2003). A idéia de
Zadeh levou-o a desenvolver o que é conhecido como lógica Fuzzy (RUSS, 1996).
Apesar de ter sido criticada inicialmente, a lógica Fuzzy acabou sendo bem aceita
por engenheiros e cientistas da computação, tornando-se comuns as suas
aplicações.
Do começo da ciência moderna até o fim do século XX a incerteza era
geralmente indesejável, uma idéia a ser evitada. Esta atitude foi gradativamente
mudada com o surgimento dos mecanismos estatísticos (DA COSTA et al, 2003).
Para lidar com grandes complexidades de processos mecânicos no nível
30
molecular, mecanismos estatísticos permitiam o uso de médias e a teoria de
probabilidade era aplicada com sucesso em várias áreas da ciência. Mesmo assim,
a teoria de probabilidade não era capaz de tratar a incerteza em todas as suas
manifestações (KLIR, 1997). Em particular é incapaz de tratar a incerteza resultante
dos termos da linguagem natural vagos.
Um exemplo disso é a palavra meia-idade (MUKAIDONO, 2001). É comum
classificar uma pessoa de meia idade ou não, apesar de não se saber exatamente
quando começa e termina esse período. Vamos assumir um exemplo de que o
período de meia idade vai de 35 a 55 anos. Pela lógica tradicional, um homem de
34 anos só poderia pertencer ao grupo de meia idade depois do dia de seu
aniversário de 35 anos. Da mesma forma, um homem de 56 anos não pertenceria
mais a esse grupo. Mas não é desejado tamanha precisão em relação a este
conceito, dado que o limite de meia idade não pode ser definido precisamente. Na
verdade, se tem uma idéia vaga a respeito dos limites de meia idade (DA COSTA et
al, 2003).
Na teoria clássica de conjuntos são definidos os limites são requeridos para
determinar a pertinência de um elemento a um conjunto com toda a certeza (KLIR,
1997). Porém a maioria dos conjuntos e proposições não pode ser caracterizada de
maneira tão exata. Um exemplo é o conjunto de pessoas altas é um conjunto onde o
limite exato não pode ser precisamente definido. Na lógica Fuzzy, a pertinência de
um elemento a um conjunto ocorre gradativamente, expressa através de uma função
de pertinência.
Cada conjunto Fuzzy, A, é definido em termos de relevância a um conjunto
universal, X, por uma função denominada de função de pertinência, associando a
cada elemento x um número, A(x), no intervalo fechado [0,1] que caracteriza o grau
de pertinência de x em A (KLIR, 1997).
Pode-se dizer que os sistemas difusos são sistemas baseados em regras que
utilizam variáveis lingüísticas difusas (conjuntos difusos) para executar um processo
de tomada de decisão (ADILEA, 2003).
Um FLC (Fuzzy Logic Controller) pode ser dividido em três seções:
fuzzificação, o motor de inferência Fuzzy, e defuzzificação, como podem ser vistas
na Figura 1. Durante a seção de fuzzificação os dados de entrada são convertidos
em valores lingüísticos adequados, como “grande” ou “pequeno”, com funções de
pertinência (LIU et al, 2011). O motor de inferência Fuzzy trabalha com a aplicação
31
da tabela de regras, e a defuzzificação trabalha com o resultado de forma a retornar
um valor em porcentagem, ou em alguma outra forma que facilite a visualização do
resultado (LIU et al, 2011).
Figura 1 - Controlador Fuzzy Lógico (LIU et al, 2011)
Como exemplo de um controle lógico Fuzzy, é possível citar um controlador
Fuzzy para fontes chaveadas baseado em FPGA, que será utilizado abaixo como
exemplo de utilização de Fuzzy.
Três conjuntos linguísticos, ou seja, positivo (P), zero (Z) e negativo(N), foram
escolhidos para as variáveis de entrada e (nT) e v(nT) são Funções de pertinência
triangular como mostrado na Figura 2. Da Figura 2, as funções de pertence são
igualmente espaçadas ao longo da faixa de operação de cada variável Fuzzy. Para a
variável de saída, três valores (L, 0 e L-) são utilizados. De acordo com o
conhecimento do sistema, regras de controle Fuzzy podem ser derivadas no motor
de inferência Fuzzy da seguinte forma:
Tabela 1 - Tabela de regras (LIU et al, 2011)
Regra e(nT) v(nT) Saída R(1) en vn On R(2) en vp Oz R(3) ep vn Oz R(4) ep vp Op
32
Figura 2 - Gráficos de pertinência utilizados(LIU et al, 2011)
Neste exemplo, "Saída" é o controle Fuzzy da ação ∆u(nT), "en" significa
"erro negativo", "op" significa "saída positiva", etc. Na seção de defuzzificação, o
Fuzzy Logic Controller (FLC) processa a saída Fuzzy das regras e gera um valor
numérico. Usa o conhecido método de centro de gravidade (realizado através de
uma media ponderada) para defuzzificação (LIU et al, 2011).
2.1 CONTROLE ATRAVÉS DA LÓGICA FUZZY
O conceito básico fundamental de controle de lógica Fuzzy é descrever uma
relação entre as entradas e saídas do sistema em termos de graus de adesão e um
conjunto de regras Fuzzy do tipo IF-THEN. Com estes parâmetros de controle o
controlador Fuzzy é capaz de estabilizar o sistema controlado. Para executar a
operação de controle exigido, o controlador de lógica Fuzzy utiliza um conjunto de
operações Fuzzy seguindo os estágios (KHUDHAIR et al, 2010):
• Interface de fuzzificação: Na lógica Fuzzy, existe uma série de funções de
pertinência diferentes, como na (Figura 3) triangular, trapezoidal, sino, e
formas pontuais (Figura 4). Estas funções de pertinência definem a
pertinência do valor de entrada do sensor (KHUDHAIR et al, 2010).
33
Figura 3 - Pertinência Fuzzy Trapezoidal (KHUDHAIR et al, 2010)
Figura 4 - Pertinência Fuzzy Pontual (KHUDHAIR et al, 2010)
• Inferência de regras Fuzzy: No controle de lógica Fuzzy, as regras são
consideradas como o conhecimento do especialista. As regras de controle
Fuzzy assumem a forma de uma declaração IF-THEN da seguinte forma:
IF x is A and y is B THEN z is C (1)
A regra vista em (1) descreve uma condição que a planta pode apresentar em
um determinado ponto, utilizando variáveis (x e y), e conjuntos Fuzzy (A e B). O
operador "E" na regra Fuzzy acima é a operação mínima entre os dois conjuntos
Fuzzy. Esta regra é utilizada na fase de inferência de regra do FLC para calcular o
grau em que os dados de entrada correspondem à condição de uma determinada
regra. Estas regras são na sua maioria extraídas da experiência do projetista, ou o
conhecimento da dinâmica das plantas. Vários tipos de técnicas de otimização são
geralmente utilizadas para obter essas regras (como algoritmos genéticos (ZHANG
et al, 2006, TABOADA et al, 2009), ou redes neurais (BIGARBEGIAN et al, 2008).
Estes sistemas são geralmente referidos como sistemas de controle adaptativos
Fuzzy (KHUDHAIR et al, 2010).
34
• Interface de defuzzificação: A saída do estágio de inferência da regra é
representada como conclusões com graus de adesão. Antes de a saída ser
passada para a planta deve ser convertida para um valor de saída real,
sendo necessário o estágio de defuzzificação. Dependendo do tipo de
controle, precisão requerida e do tipo da função de pertinência de saída,
existem três tipos principais de métodos de defuzzificação:
o Metodo de Centro Maximo (COM)
o Metodo do Centro de Gravidade (COG)
o Metodo da Media Maxima(MOM) (KHUDHAIR et al, 2010)
O método COG é um dos métodos de defuzzificação mais populares devido à
sua precisão. Uma vez que funciona calculando a área sob as funções relacionadas,
entretanto a alta precisão do método está no custo do aumento computacional, no
tempo e na complexidade (KHUDHAIR et al, 2010).
Recentemente muitos projetos vêm sendo trabalhados com a adição de lógica
Fuzzy. Entre os projetos, podemos citar: controle de sistemas, aprendizado,
detecção de objetos e padrões, inversores etc. Alguns projetos utilizando lógica
Fuzzy também estão presentes na área médica, em que se pode trabalhar com o
monitoramento de sinais vitais e também realizar a organização de dados
resultantes de pesquisas médicas. Paralelamente temos ainda uma série de projetos
que aliam lógica Fuzzy a outros paradigmas de inteligência artificial, como a rede
neural e o algoritmo genético. Grande parte desses projetos vem sendo trabalhadas
em FPGA.
Utilizando FPGA é possível fazer um controle adaptativo Fuzzy para motores
lineares síncronos permanentemente magnetizados. O PMLSM (Permanent-Magnet
Linear Synchronous Motor) não utiliza engrenagens convencionais ou fusos de
esferas, de modo que a carga sobre o motor afeta grandemente o desempenho de
posicionamento (LIU et al, 2004). Para lidar com este problema, muitas técnicas de
controle avançado (QINGDING et al, 2002, LIN et al, 2007, WAI et al, 2007), tais
como o controle Fuzzy, redes neurais, e controle robusto, têm sido desenvolvidos e
aplicados para o controle da posição da unidade PMLSM para obter um alto
desempenho operacional. No entanto, a execução de uma rede neural ou
controlador Fuzzy (FC) requer um alto esforço computacional para a implementação
desses algoritmos de controle altamente complexos e dependem de em um PC
35
(Personal Computer) na maioria dos estudos (LIU et al, 2004, QINGDING et al,
2002). Nos últimos anos, os processadores de sinais digitais (DSP – Digital Signal
Processor) e as FPGA’s fornecem uma solução possível neste assunto (KUNG,
2008, LIN et al, 2005).
Comparando com as FPGA’s, as técnicas inteligentes de controle usando
DSP, fornecem uma habilidade flexível, em contrapartida sofrem de um longo
período de desenvolvimento e esgotam muitos recursos da CPU (Central Processing
Unit) (KUNG et al, 2009).
Outro trabalho interessante envolvendo Fuzzy e FPGA é o desenvolvimento
de um inversor multinível. Normalmente, o controlador e o modulador de inversores
são separados. O inversor multinível proposto consiste em um controlador integrado
com modulação por largura de pulso (PWM – Pulse Width Modulation), ambos
implementados em um FPGA. O controlador considera a diferença entre a tensão da
linha de referência de energia (Vref) e a tensão de saída do inversor (Voutput inverter).
Então, dependendo do estado do inversor, calcula o padrão a ser aplicado. Os
parâmetros do controlador de entrada são AVdif f i.e (Voutput inverter - Vref), que
representa o erro entre a referência e o sinal de saída, e AVntfilt que está relacionado
com a saída do inversor antes do filtro passa-baixa. O projeto de um controlador de
lógica fuzzy exige a definição de "funções de pertence" e "regras de inferência". As
funções de pertinência escolhidas para os dois parâmetros de entrada, em que os
rótulos"NB", "NS", "ZE", "PS" e "PB" significam: "NB" = negativa grande,"NS" =
negativo pequeno, "ZE" = zero, e assim por diante (CECATI et al, 2009).
Na área médica existem trabalhos que também aplicam Fuzzy em FPGAS
para auxilio em Diagnósticos. Sistemas médicos de diagnóstico capazes de tomar
decisões sobre o estado fisiopatológico dos pacientes com base em dados passados
requerem processadores Fuzzy para fuzzificar adequadamente os dados coletados.
Em tempo real, processos que usam uma grande quantidade de informação exigem
alta velocidade de processamento Fuzzy. O trabalho tem por objetivo definir uma
arquitetura de processador que explora plenamente o paralelismo inerente de
inferências Fuzzy. Assim, reduzindo o número de regras processadas e permitindo
que o processador também explore o fato de que apenas partes das regras têm um
grau positivo de validação. O método reduz consideravelmente a quantidade de
memória necessária para armazenar as regras ativas. O processador em questão é
implementado em uma matriz de (FPGA). A implementação do processador em uma
36
arquitetura reconfigurável permite modificar ainda mais a sua lógica funcional com
mínimo esforço de programação (CHOWDHURY et al, 2008).
Isoladamente o Fuzzy também vem sendo trabalhado em adição a outros
paradigmas de inteligência artificial, como por exemplo, o algoritmo genético, em que
pode ser possível para trabalhar com o dimensionamento de sistemas de
monitoração para redes de transmissão de energia elétrica. O principal fator que
torna a utilização de AGs (Algoritmos Genéticos) uma alternativa interessante se
deve ao fato de que o problema de alocação ótima de medidores de QEE
(Qualidade de Energia Elétrica) constitui-se, basicamente, em um problema de
busca. Isto é, a possibilidade de instalação de equipamentos de monitoração em
cada barra da rede elétrica em estudo faz com que o universo de possíveis soluções
cresça de forma binária. Logo, para uma rede elétrica com N barras, o universo de
soluções (possíveis configurações do sistema de medição) seria 2N. Utilizando-se
uma modelagem baseada em AGs e Conjuntos Fuzzy, restrições e objetivos não
lineares, mesmo aqueles que não podem ser expressos explicitamente por
expressões matemáticas, podem ser facilmente incorporados ao processo de
avaliação das possíveis soluções. Além disso, foi empregada a Teoria dos Conjuntos
Fuzzy de forma a permitir definição dos diferentes objetivos/restrições de forma
heurística: maximização da Observabilidade e minimização do número de
equipamentos.
No processo de busca, o número de equipamentos sugeridos, bem como o
número de defeitos "observado" em cada possível solução podem, muitas vezes,
interferir de forma negativa, comprometendo a convergência. Com o emprego da
Teoria dos Conjuntos Fuzzy, os objetivos e as restrições do problema passam a ser
modelados por funções matemáticas alternativas, trocando-se a avaliação
quantitativa do atendimento aos mesmos por uma avaliação qualitativa, e que está
mais aderente à realidade do problema. Com essa mudança na forma de definição
dos objetivos e das restrições do problema, também é facilitada a inclusão de
diferentes aspectos do problema (pontos de instalação permitidos, cargas com
monitoração obrigatória, etc.), que seriam bem mais difíceis de serem considerados
em modelagens utilizando Programação Linear-Inteira (ALMEIDA et al, 2010).
O Fuzzy aliado a redes neurais é uma ferramenta poderosa para detecção de
padrões, como por exemplo, o reconhecimento de múltiplos objetos. A proposta de
implementação de algoritmo neuro-Fuzzy de detecção de objeto consiste em 4
37
etapas. Na primeira etapa, o algoritmo de atenção, de dinâmica visual (OUERHANI,
2003) e realizada por LEE e VAE (LEE et al, 2008) para gerar o mapa de saliência.
Os pontos mais salientes são selecionados como pontos de sementes na segunda
etapa. Na terceira etapa, uma região homogênea da imagem que pertence ao
mesmo objeto é delineada em torno dos pontos de sementes selecionados pelo
algoritmo de crescimento de regiões. Na etapa final, cada região objeto é
representada como a região de interesse (KIM et al, 2009).
39
3 ESPECIFICAÇÃO DO PROJETO
A plataforma geradora de controladores Fuzzy tem como objetivo a utilização
de FPGAS com o intuito de facilitar a implementação de lógica Fuzzy e também uma
aplicação em hardware permitindo um ganho de desempenho em sistemas
baseados em software interpretado.
A plataforma pode ser utilizada em projetos nos quais a aplicação do
paradigma de lógica Fuzzy possa ser aplicado, permitindo um controle automatizado
em áreas que necessitem de uma maior precisão no resultado final.
3.1 OBJETIVOS
Desenvolver uma plataforma que facilite a implementação de lógica Fuzzy em
que o usuário deve apenas se preocupar em definir os seguintes itens:
• Tabela de regras no formato IF-THEN
• Valor mínimo de inferência
• Valor máximo de inferência
• Ponto de pertinência máxima
Outro foco é permitir que a plataforma trabalhe como um co-processador
Fuzzy, concentrando os cálculos que são relativos à lógica Fuzzy e diminuir a
alocação de mais um processo em uma CPU.
A plataforma trabalhando como um co-processador, permite a facilidade na
integração com projetos de sistemas embarcados, que em muitos casos possuem
diversas limitações quanto à CPU.
40
3.2 CARACTERÍSTICAS DO PROJETO
• Uma plataforma em FPGA para realizar os cálculos utilizando os valores de
pertinência gerados para lógica Fuzzy.
• Utilização de um Micro controlador para realizar a conversão dos valores
entre as bases utilizadas (Decimal e binário) e também realizando a
comunicação entre a FPGA e o ambiente de utilização, seja ele um
computador ou um hardware específico.
• Resolução: 7 bits em que 6 dígitos na estrutura de ponto fixo reservados para
representação dos decimais e 1 digito reservado para representação do
inteiro.
• Forma de representação considerando apenas inteiros positivos utilizando
variáveis do tipo unsigned, pois o trabalho com Fuzzy não permite saídas
negativas.
• Utilização de pelo menos 3 variáveis linguísticas para a implementação de
Fuzzy.
3.2.1 Requisitos
1. FPGA, da Altera com pelo menos 15mil unidades lógicas internas. Podem
ser utilizados os kits listados a baixo, ou qualquer outro kit com
componentes equivalentes ou superiores:
• DE2 da Altera que utiliza uma FPGA CycloneII 2C35.
• EP3C25 da FPGA4Fun que utiliza uma FPGA CycloneIII 3C25.
2. Micro controlador que tenha características equivalentes ou superiores a:
• Clock de 16Mhz.
• Portas de entrada e saída (I/O) digitais : 54.
• Portas de saída com PWM: 14.
• Corrente DC por pino de I/O: 40mA.
• Memória Flash 128kb.
41
• Capacidade de transmitir dados utilizando protocolo UART.
3. Software Quartus II da Altera, versão 9.0.
4. Suíte de desenvolvimento para Arduino, que acompanha o micro
controlador escolhido.
5. Computador que atenda os requisitos mínimos do Quartus II.
3.3 ARQUITETURA
A arquitetura do projeto está dividida em três módulos, visando uma maior
facilidade na implementação do sistema em qualquer ambiente. A primeira trata
sobre a FPGA propriamente dita, que os cálculos Fuzzy são realizados, a segunda,
sobre o micro controlador que serve de interface de funcionamento, e a terceira,
sobre o projeto onde a plataforma está inserida. A Figura 5 demonstra esses três
módulos e como eles se comunicam.
Figura 5 - Arquitetura geral do sistema
42
3.3.1 Módulo de Processamento
O cálculo Fuzzy é dividido em quatro etapas, entre elas estão o recebimento
do dado a ser trabalhado, a busca de pertinências, a aplicação da tabela de regras,
envio dos dados para defuzzificação.
Inicialmente o módulo de processamento, recebe do módulo de comunicação
e avaliação (detalhado mais a frente), o dado relativo a última leitura. Utilizando
então as definições de Fuzzy previamente gravadas na FPGA, ele busca as
pertinências das variáveis, com o valor dessas pertinências aplica-se a tabela de
regras para cada variável, e então retorna os valores lidos para o módulo de
comunicação e avaliação.
Após isso no módulo de comunicação e avaliação aplica-se uma média
ponderada somando os resultados únicos de cada variável e dividindo pela soma
das pertinências, resultando assim em um ponto médio entre todas. Esse valor
representa o valor de saída, em uma representação de porcentagem. A Figura 6
exemplifica em um fluxograma a parte relativa ao módulo de processamento desse
cálculo.
Figura 6 - Lógica do Cálculo Fuzzy
43
3.3.2 Módulo de Comunicação e Avaliação
O módulo de comunicação e avaliação tem a função de servir como uma
ponte entre a FPGA que executa a lógica Fuzzy e o projeto externo. O módulo de
comunicação e avaliação recebe um valor decimal proveniente do projeto externo,
realiza a conversão desse valor para a base binária com ponto fixo, utilizada na
FPGA, aguardar o resultado do as pertinências e das regras, realizar a conversão
novamente da base de ponto fixo para base decimal, aplicar a média ponderada
entre os valores de pertinência e da tabela, e então retornar para o projeto esse
valor. A Figura 7 exemplifica esse funcionamento.
Para esse projeto foi escolhido o micro contolador ATmega 1280 utilizando
bootloader do Arduino Mega. Esse micro controlador foi escolhido por atender todas
as especificações exigidas e ainda permitindo se comunicar com o computador
utilizando a porta USB, evitando que seja necessária uma saída serial, uma vez que
vários computadores mais modernos não possuem mais porta serial.
Figura 7- Lógica implementada no micro controlador
44
3.3.3 Módulo de Desenvolvimento, Configuração e Debug
Para a configuração do sistema utiliza-se um computador pessoal com
sistema operacional compatível com todos os softwares citados no subcapítulo 3.2.1.
O módulo de desenvolvimento, configuração e debug é responsável pela
programação do arduíno e da FPGA. Nele são executados os software utilizado para
gravação do programa no arduíno e a suíte Quartus II que é responsável pela
programação e validação da FPGA.
Também é utilizado para rodar o software que permite gerar as tabelas de
pertinência. Este software (plataforma Java) foi desenvolvido juntamente com o
projeto e é responsável pelo cálculo das pertinências e por gerar os arquivos de
memória e de valores. Sua interface pode ser vista na Figura 8.
Figura 8 - Interface do software para gerar os arquivos de memória
Na interface trabalha-se definindo qual o tamanho da memória utilizada, o
menor valor que a variável poderá assumir, o maior valor assumido pela variável e o
valor de pertinência máxima.
45
Com essas definições é possível gerar os arquivos de valor e pertinência, que
serão exibidos no campo de texto central da interface. Caso o usuário prefira, poderá
exportar o arquivo direto no formato .mif (formato que se importa diretamente no
elemento de memória da FPGA).
Para esse software foi desenvolvido um algoritmo para gerar a curva de
pertinência de forma triangular, em que a pertinência inicial é 0 e vai aumentando de
forma linear até o ponto de pertinência máxima, e então diminui também de forma
linear até que chegue ao ponto em que a pertinência é 0 novamente. Esse algoritmo
que pode ser visto na Figura 9.
Figura 9 - Algoritmo de cálculo de pertinência
O Módulo de desenvolvimento, configuração e Debug também é utilizado para
realização dos testes de forma isolada, em que é possível validar de forma
independente as funcionalidades dos módulos, tanto um módulo como um todo,
como também as partes do módulo de forma a garantir que cada algoritmo utilizado
no desenvolvimento esteja retornando o resultado desejado.
46
3.3.4 Uso da Plataforma
O usuário que utiliza a plataforma deve preocupar-se apenas com os
seguintes itens:
• Gerar a tabela de regras no formato IF-THEN em linguagem VHDL
• Definir o valor mínimo de inferência
• Definir o valor máximo de inferência
• Definir o ponto de pertinência máxima
As definições de valor mínimo de inferência, valor máximo de inferência e
ponto máximo de pertinência, referem-se à utilização de um software em Java. Este
software gera os arquivos de memória (com extensão .mif) com os valores e
pertinências, os quais serão utilizados pela FPGA.
Também é necessário que o usuário codifique a tebela de regras na
linguagem VHDL.
3.4 TESTES DE VALIDAÇÃO DO SISTEMA
O teste do sistema utiliza o circuito montado com três sensores LM35 de
temperatura, trabalhando em temperatura ambiente, e simulando um aumento de
temperatura com alguma fonte externa de calor.
A confirmação da validade das tabelas de pertinência tem com base, realizar
múltiplas verificações.
3.4.1 Testes de validação de conversões do micro controlador
Para validar as conversões e verificar se estão sendo feitas corretamente
tanto a conversão de binário para decimal, quanto a conversão de decimal para
binário, insere-se manualmente um valor em decimal na programação do micro
47
controlador. Então executa-se a rotina de conversão para base de ponto fixo. Logo
após isso é executada a rotina de conversão de binário para decimal, utilizando o
valor resultante da conversão da rotina anterior.
Assim é comparado o valor de entrada e o valor de saída. Ambos devem ser
iguais ou pelo menos muito próximos, levando em consideração o fator de que ao se
trabalhar com uma base de ponto fixo podem ocorrer perdas de precisão.
3.4.2 Testes de validação da aplicação da lógica Fuzzy
Para a validação da lógica Fuzzy aplica-se o mesmo valor e as mesmas
tabelas em uma aplicação implementada em software, utilizando as mesmas
diretivas, tabelas de regras e variáveis. Por fim é realizada uma comparação de
resultados, tendo como base uma mesma entrada. Os resultados devem ser iguais
ou bastante próximos permitindo apenas a diferença causada pela perda de
informações na conversão para a base de ponto fixo.
48
49
4 PROJETO
4.1 HARDWARE FUZZY
O cálculo Fuzzy é dividido em quatro etapas, entre elas estão o recebimento
do dado a ser trabalhado, a busca de pertinências, a aplicação da tabela de regras,
e envio dos dados para defuzzificação, como exibido na Figura 5. O hardware Fuzzy
pode também ser visto como diagrama em blocos no Anexo 2.
4.1.1 Recebimento dos Dados
A entrada de dados é realizada através dos pinos de IO disponíveis na FPGA,
esses dados serão enviados de forma paralela em 7 bits através do micro
controlador.
Para o kit DE2 da Altera essa entrada será realizada pelos pinos de expansão
assinalados como JP0 e JP1.
4.1.2 Busca de Pertinências
No momento em que já tem um valor de entrada válido, respeitando a
definição de ser um número de 7 bits na forma de ponto fixo, em que o primeiro
dígito é relativo ao valor inteiro e os 6 dígitos seguintes são relativos ao valor
decimal, inicia-se a busca pelas pertinências.
Na tabela de pertinências previamente gerada pelo usuário, utilizando um
software externo, em que as entradas são: o intervalo existente para a pertinência, a
quantidade de pontos que serão gerados internamente e qual o ponto de pertinência
máxima. Este algoritmo está descrito no Anexo 1.
50
A tabela de pertinência gerada fica armazenada em um elemento de memória ROM
criado dentro do chip da FPGA.
Para realizar a busca de pertinências, realiza-se uma varredura na tabela
gerada, buscando o valor de pertinência relativo ao valor de entrada. Porém como o
valor de entrada pode ser um valor que não foi gerado dentro do range do algoritmo,
é necessário que a busca seja feita em pares. Assim, procurando o valor acima e
abaixo do número de entrada mais próximo até que se chegue exatamente entre
quais valores o valor pesquisado encontra-se.
Realiza-se então a soma dos dois valores encontrados e divide-se por dois
para fazer uma média simples, aproximando assim o valor de pertinência para o
valor de entrada.
4.1.3 Aplicação da Tabela de Regras
Após encontrar o valor da pertinência para o dado de entrada é necessário
aplicar a tabela de regras para cada variável.
Essa tabela deverá estar em um arquivo VHDL e trabalhará como um
multiplexador, pois dependendo da entrada, existe apenas uma única saída. Essa
saída deverá ser em valores de porcentagem, com um range de 1 a 100%. Após
escolhido o valor de saída multiplica-se o valor de saída pela pertinência encontrada,
gerando assim o valor final para aquela variável com o valor de entrada.
Cada variável trabalhará com uma flag indicativa de que já tem o valor final
pronto ou não.
4.1.4 Envio dos Dados Para Defuzzificação
O envio dos dados para a defuzzificação é feito forma serializada, em que
utilizamos uma tabela de estados, que se mantém em cada estado por
aproximadamente 500 milissegundos. Em cada estado e realizada a alteração um
51
valor de 4 bits que indica qual o ID do dado que está sendo transmitido e um valor
de 7 bits que representa o dado.
O micro controlador sabe qual o dado que está recebendo através do ID, e
assim armazena o dado na sua variável relativa.
4.1.5 Digrama em blocos da FPGA
No Anexo 2 está a representação do diagrama em blocos da implementação
na FPGA. O diagrama consiste em cinco blocos básicos:
• Memory count
• Elementos de memória ROM
• Maquina de estados para busca na memória
• Tabela de regras Fuzzy
• Maquina de estados para transmissão serializada dos dados
Para realizar a busca nas memórias dos dados lidos são utilizados os blocos
de memory count, dois elementos de memória, em que no elemento data estão
armazenados os valores padrões para a leitura dos sensores, e no elemento value
estão os valore das pertinências para os valores que estão na mesma posição do
elemento de memória data, e uma maquina de estados, que controla o memory
count.
No estado A da maquina de estados, ocorre à ativação do subclock
responsável pelo incremento dos endereços de memória apontados pelo memory
cont. Ocorrendo esse incremento, o memory count atualiza a posição e envia para
os elementos de memória a posição atual. Os elementos de memória retornam no
barramento os dados relativos a aqueles endereços e a maquina de estados entra
no estado B, em que ocorre a desativação do subclock e a verificação se o dado
encontrado é o dado que foi lido pelo sensor. Se o dado atual da memória não foi o
dado lido pelo sensor, retorna para o estado A e continua nessa troca entre estado A
e estado B até que o dado seja encontrado. Se o dado for encontrado, entra no
52
estado C, que repassa para a tabela de regras os dados encontrados e uma
sinalização, representada pela flag "C" que indica os dados já estão prontos para
serem trabalhados pela tabela de regras.
Para este projeto, definimos a pertinência máxima em 23ºC. Obtendo como
resultado a Figura 10, onde no eixo das ordenadas está representado o valor das
temperaturas, e no eixo das abscissas está representado o valor de pertinência
relativo a cada temperatura.
Figura 10 - Gráfico de Pertinências geradas para o projeto
O valor lido pelo sensor é arredondado pelo micro controlador para o dado
mais próximo existente nas memórias, evitando assim que seja procurado por um
dado não existente nas memórias, o que implicaria em não encontrar nenhum valor
na máquina de estados, então dessa forma evita-se que entre em um loop de busca
de pertinências.
53
A tabela de regras segue a seguinte estrutura:
Tabela 2 - Tabela de regras Fuzzy
Valores lidos no sensor Valor de saída a ser trabalhado
Se temperatura lida for menor ou igual a
20ºC - "FRIO"
Então a saída é o ar condicionado ligado a
10%
Se temperatura lida for maior do que 20ºC e
menor ou igual a 25ºC - "AGRADÁVEL"
Então a saída é o ar condicionado ligado a
30%
Se temperatura lida for maior do que 25ºC e
menor ou igual a 30ºC - "MODERADO"
Então a saída é o ar condicionado ligado a
50%
Se temperatura lida for maior do que 30ºC e
menor ou igual a 35ºC - "QUENTE"
Então a saída é o ar condicionado ligado a
70%
Se temperatura lida for maior do que 35ºC -
"MUITO QUENTE".
Então a saída é o ar condicionado ligado a
100%
Na tabela de regras fazemos a conversão das variáveis lingüísticas do Fuzzy
em valores de temperatura, conforme descrito na Tabela 3. Após encontrar a regra
relativa ao valor lido é ativada uma flag de controle que sinaliza para a maquina de
estados que transmissão que o valor já está pronto para ser transmitido.
Para cada sensor utiliza-se um conjunto de blocos contendo memory count,
dois elementos de memória, uma maquina de estados de busca nas memórias e
uma tabela de regras.
Na maquina de estados que realiza a transmissão, existe uma condição que
só permite começar a transmitir quando todas as regras já foram aplicadas, e todos
os dados já foram encontrados. A transferência é realizada de uma forma serializada
baseada em ID e em Valor, em que cada estado realiza a transferência de um
determinado valor de uma determinada variável a ser trabalhada.
54
Os IDs seguem a seguinte organização:
Tabela 3 - IDs e dados a serem transmitidos
ID Informação a ser transmitida
0000 Nenhum dado a ser enviado
0001 Pertinência do dado lido pelo sensor 1
0010 Pertinência do dado lido pelo sensor 2
0011 Pertinência do dado lido pelo sensor 3
0100 Resultado da tabela de regra para o sensor 1
0101 Resultado da tabela de regra para o sensor 2
0111 Resultado da tabela de regra para o sensor 3
1111 Envio de dados finalizados
4.2 MICRO CONTROLADOR
O micro controlador desempenha o papel de ponte entre o sistema a ser
trabalhado e a FPGA. O ciclo do micro controlador é dividido em sete etapas:
1. Recebimento do dado a ser tratado
2. Conversão pra base de ponto fixo
3. Envio do dado convertido pra a FPGA
4. Recepção do resultado da FPGA
5. Conversão do valor do resultado para base decimal
6. Defuzzificação
7. Retorno do valor em decimal para o usuário
4.2.1 Recebimento do Dado a Ser Tratado
O dado a ser tratado será proveniente de três sensores LM35, que é um
sensor de temperatura linear com função de retorno de Temperatura Lida /100
retornando um valor entre 0 e 1 contendo o valor relativo a temperatura lida nas casa
55
decimais, por exemplo para uma temperatura ambiente de 23º Celsius o valor
retornado é de 0.23 Volts.
4.2.2 Conversão Para Base de Ponto Fixo
A Conversão para a base de ponto fixo será feita utilizando algoritmo de
conversão de base abaixo, desenvolvido na linguagem C específica para o Arduino.
Figura 11 - Conversão da base decimal para ponto fixo
4.2.3 Envio do Dado Para a FPGA
O envio do dado para a FPGA é feito de forma paralela, utilizando os pinos de
IO do micro controlador e os pinos de IO existentes na FPGA.
56
4.2.4 Recebimento do Resultado
O recebimento do resultado será em formato paralelo utilizando os pinos de
IO do micro controlador, utilizando o algoritmo demonstrado na Figura 12.
Figura 12 - Recebimento dos dados de forma paralela no micro controlador
57
4.2.5 Conversão do Resultado Para Base Decimal
A Conversão para a base decimal será utilizando o algoritmo abaixo, que se o
valor do pino for ‘1’ ele realiza a soma do valor binário convertido para decimal
utilizando a formula de 2^(-n) ou 1/(2^n), pois o número que está sendo convertido é
menor do que 0.
Figura 13 - Conversão da base de ponto fixo para base decimal
4.2.6 Defuzzificação
Utilizamos o método do centro de gravidade (média ponderada), definido pela
seguinte fórmula:
Figura 14 - Fórmula de média ponderada
Seguindo a fórmula, multiplicando cada valor retornado pela tabela de regras,
que foi obtido através das leituras dos sensores, pela pertinência relativa a
temperatura lida (presentes na memória da FPGA). Em seguida somam-se todos os
valores, e divide-se pela soma das pertinências.
58
4.2.7 Retorno do Resultado Em Decimal Para o Usuário
O retorno do resultado para o usuário é feito através de um LED de alto brilho
ligado a um pino PWM do micro controlador e transmitido de forma serial para o
computador exibindo o valor exato do resultado em uma janela de debug existente
no próprio software de gravação do micro controlador.
59
5 RESULTADOS
5.1 CASO DE TESTE
Para realizar a validação dos Resultados foi implementado um sistema de
controle de temperatura teórico, em que as variáveis de entrada são três sensores
de temperatura e a partir da aquisição desses sensores realiza-se o cálculo Fuzzy.
Realizamos as seguintes definições:
• Valor mínimo de inferência: 0ºC
• Valor máximo de inferência: 50ºC
• Valor de pertinência máximo: 23ºC (temperatura ideal)
Em sequência, aplicamos a seguinte tabela de regras:
Tabela 4 - Tabela de regras Fuzzy - Controle de Temperatura Teórico
Valores lidos no sensor Valor de saída a ser trabalhado
Se temperatura lida for menor ou igual a
20ºC - "FRIO"
Então a saída é o ar condicionado ligado a
10%
Se temperatura lida for maior do que 20ºC e
menor ou igual a 25ºC - "AGRADÁVEL"
Então a saída é o ar condicionado ligado a
30%
Se temperatura lida for maior do que 25ºC e
menor ou igual a 30ºC - "MODERADO"
Então a saída é o ar condicionado ligado a
50%
Se temperatura lida for maior do que 30ºC e
menor ou igual a 35ºC - "QUENTE"
Então a saída é o ar condicionado ligado a
70%
Se temperatura lida for maior do que 35ºC -
"MUITO QUENTE".
Então a saída é o ar condicionado ligado a
100%
O retorno do resultado obtido pode ser visto ao acender um LED (Light
Emitting Diode) utilizando uma das saídas PWM (Pulse Width Modulation) do módulo
de comunicação e avaliação. Para a busca das pertinências é retornado, através do
gráfico de pertinências, qual o valor em hexadecimal relativo à pertinência no valor
de temperatura lido. Para cada variável é aplicada a tabela de regras (Tabela 4), em
60
que se obtém o valor de saída relativo a aquela temperatura lida, e então se obtém o
valor de saída a ser trabalhado na defuzzificação.
A defuzzificação é realizada pelo método do centro de gravidade, e o retorno
é um valor variável entre 0 e 1, que representa a porcentagem da potência utilizada
na saída. Também convertemos o valor de porcentagem para um intervalo entre 0 e
255, utilizando uma regra de três simples, que é transmitido através da saída PWM
do micro controlador.
Dessa forma, a saída representa Valor em porcentagem com o qual o
dispositivo que iria resfriar o ambiente estaria funcionando para, que a temperatura
ficasse próxima da ideal em todos os pontos de medição, com o menor consumo de
energia, por exemplo:
Ar condicionado ligado a 83%.
O caso de teste modelado tem como objetivo representar um problema
teórico de controle de temperatura. Com isso proporcionar a visualização da
plataforma em funcionamento em um ambiente facilmente reproduzível no cotidiano,
servindo apenas para fins de validação.
5.2 CONFIGURAÇÕES DO PROJETO
Para a configuração do projeto inicialmente é feita a definição das variáveis a
serem utilizadas. Para o caso de teste definiu-se a utilização de três variáveis de
temperatura, que seriam o equivalente a três sensores alocados em posições
diferentes do ambiente a ser monitorado. A partir da definição das variáveis definem-
se os valores de pertinência dessas variáveis, no caso analisado foi escolhido o
valor de 23ºC. A partir dessa informação é interessante utilizar o software de
definição de pertinências para gerar os arquivos de memória que irão conter os
valores das pertinências para cada variável.
Na utilização desse software é necessário entrar com o valor mínimo que a
variável possa assumir, o valor máximo, e o ponto de pertinência máxima definido
anteriormente, como saída são gerados dois arquivos de memória, onde um contém
os valores a serem lidos pelos sensores, e o outro contém os valores de pertinência
61
correspondente aos valores, como pode ser observado nos anexos 4.1 e 4.2. Tendo
os dois arquivos, define-se no software Quartus II quais serão os arquivos .mif
carregados na memória de valores e de pertinências de cada variável.
Com as memórias prontas trabalha-se nas tabelas de regras, que deverá ser
implementada utilizando VHDL no bloco relativo a regras. Para o caso de teste foi
utilizada a tabela de regras visível na Figura 15.
Figura 15 - Tabela de regras implementada em VHDL
A partir da tabela de regra não é necessário que o usuário realize mais
nenhuma alteração na plataforma, uma vez que terá já o valor defuzzificado
disponível no modulo de comunicação e avaliação.
62
5.3 RESULTADOS DA MODELAGEM VHDL
Os códigos VHDL produzidos ficam por conta da máquina de estados da
busca das pertinências, visto no Anexo1, um contador de posição de memória que
pode ser visto na Figura 16 e a tabela de regras demonstrada na Figura 15.
Figura 16 - Contador de memória implementado em VHDL
Os códigos VHDL geram o diagrama RTL que pode ser visto no Anexo 5 e o resumo
de compilação que pode ser visto na Figura 17.
63
Figura 17 - Tela de resumo da compilação
5.4 RESULTADOS – MÓDULO DE PROCESSAMENTO
A FPGA foi testada e validada através da geração de um waveform, que é a
própria simulação do circuito desenvolvido através do software Quartus II. O
resultado da simulação pode ser visto no Anexo 3.
Nas linhas 2, 10 e 18 foram inseridos valores manualmente. Estes valores
representam dados lidos pelos sensores e então convertidos para a base de ponto
fixo. Estes valores já estão presentes na memória de dados, que pode ser vista no
Anexo 4.1, e também possuem um valor de pertinência associado, que pode ser
visto no Anexo 4.2.
A simulação, da linha 26 a linha 34, está representada a máquina de estados
que representa a busca nas memórias em funcionamento.
Nas linhas 35 a 99 estão os dados relativos à tabela de regras, em que temos
o SinalA1 por exemplo, representando o dado de entrada. O SinalB1 representa o
dado de pertinência encontrado, e o sinal res1 indica a saída da tabela de regras
que é um número na base hexadecimal. Essa representação é relativa ao sensor 1.
64
Já para o SinalA2, por exemplo, este trabalha com os dados do sensor 2 e o SinalA3
trabalha com os dados relativos ao sensor 3.
As linhas 107, 108 e 109, são relativas às flags de ativação. Pois o envio de
informações para o micro controlador só é possível depois que todos os dados
estiverem prontos, e essas flags são responsáveis por sinalizarem essa informação.
Nas linhas 110 e 115 está a transmissão de dados da FPGA para o micro
controlador. Na linha 110, está representado o ID de transmissão de cada dado, e
na linha 115 está o valor em binário que será transmitido.
5.5 RESULTADOS – SISTEMA COMPLETO
Como a realização do trabalho foca no desenvolvimento de uma plataforma
genérica, para realizarmos a análise de resultados, foi desenvolvido um controle de
temperatura, pois é um sistema com uma complexidade baixa de implementação, e
também pode-se trabalhar com uma implementação teórica em que poderia ser
utilizado um ar condicionado, uma vez que o escopo principal do projeto é o
desenvolvimento da plataforma genérica.
Para o resultado final do sistema, foi feito um controle de temperatura. A
pertinência máxima para o sistema foi definida em 23ºC, ou seja, o ponto onde a
temperatura está no valor ideal. A implementação foi feita utilizando as regras
descritas na Tabela 2 como regras Fuzzy. A mesma tabela é aplicada aos três
sensores.
Apos realizadas as leituras e selecionada a saída da tabela Fuzzy no
processo de defuzzificação, multiplicamos os valores da tabela pelos valores de
pertinência, dividindo então pela soma das pertinências, realizando assim uma
média ponderada.
Para a seqüência de testes realizados, podem-se observar na Tabela 5 os
valores lidos pelos sensores e após a realização do cálculo Fuzzy, temos a
porcentagem que representa a potência com que o dispositivo deve ser acionado.
65
Tabela 5 - Porcentagem de ativação real do sistema
Situação Sensor1 Sensor2 Sensor3 Potência
1 20 20 20 23,43%
2 19 20 20 16,76%
3 21 23 23 23,83%
4 27 22 21 38,12%
5 26 24 23 36,1%
6 27 26 25 42,64%
7 30 31 22 47,11%
8 30 32 28 58,67%
Durante o teste, realizamos a aquisição dos sensores de forma amostrada,
assim para cada sensor não temos uma leitura sequencial. Para cada leitura de valor
de temperatura dos sensores é calculada uma potencia de saída que varia de 0 a
100% e cada leitura não influencia nos dados que serão adquiridos.
Para realizar a comprovação dos valores reais, utilizamos valores que foram
simulados, segundo a Tabela 6, para realizar uma comparação.
Tabela 6 - Porcentagem de ativação simulada do sistema
Situação Sensor1 Sensor2 Sensor3 Potência
1 20 20 20 10%
2 19 20 20 9,99%
3 21 23 23 29,99%
4 27 22 21 36,16%
5 26 24 23 36,17%
6 27 26 25 43,04%
7 30 31 22 47,25%
8 30 32 28 56,08%
Para obter os valores simulados para comparação, fornecemos os mesmos
valores lidos pelos sensores à um software, que retornou como resposta valores
simulados relativos à potência de ativação do dispositivo.
66
5.6 VALIDAÇÕES DOS VALORES
Para realizar a validação dos valores utilizou-se um sistema genérico de
lógica Fuzzy, implementado em Java, que já foi utilizado em anos anteriores para
desenvolver um sistema de análise de mercado financeiro, retornando resultados
bastante satisfatórios, sendo inclusive apresentada na Mostra de Projetos do Curso
de Engenharia da Computação do ano de 2010.
Esse sistema foi alterado para trabalhar com a mesma pertinência máxima de
23ºC e a mesma tabela de regras exibida na Tabela 3.
Colocando como entrada desse sistema os mesmos valores de entrada de
leitura dos sensores obtivemos os seguintes resultados:
Tabela 7 - Tabela comparativa Real x Simulado
Situação Sensor1 Sensor2 Sensor3 Real Simulado Erro
1 20 20 20 23,43% 10% 13,43
2 19 20 20 16,76% 9,99% 6,77
3 21 23 23 23,83% 29,99% 6,16
4 27 22 21 38,12% 36,16% 1,96
5 26 24 23 36,1% 36,17% 0,07
6 27 26 25 42,64% 43,04% 0,4
7 30 31 22 47,11% 47,25% 0,14
8 30 32 28 58,67% 56,08% 2,59
Média 3,94
Tendo os valores reais e os valores simulados, realizamos o seguinte cálculo
para determinar o erro entre as leituras:
Figura 18 - Cálculo do erro
67
Após calcular o erro relativo a cada leitura, determinamos o erro médio,
através do cálculo:
Figura 19 - Cálculo do erro médio
Levando em consideração, por exemplo, uma sala em que um dos sensores
estaria mais próximo de um ar condicionado, esse teria uma temperatura
constantemente mais baixa do que o os outros sensores, mantendo um padrão de
funcionamento mais linear. Assim o ar condicionado iria ligar em uma potencia para
equilibrar a temperatura da sala, sem prejudicar quem está mais próximo do
aparelho que está sendo controlado.
A tabela traduz a perda de precisão na hora da conversão dos valores da
base decimal para a base de ponto fixo.
Com isso é possível observar que houve um erro médio de 3,94, que é um
valor que não destoa muito em uma escala de funcionamento de 0 a 100%.
Neste caso a causa do erro deve-se a estrutura de ponto fixo que utiliza 7
bits, ocorrendo perda de precisão devido ao truncamento dos valores. Isso ocorre
pois o ambiente de simulação trabalha com a estrutura de ponto flutuante de 32 bits.
68
69
6 CONCLUSÕES
6.1 CONCLUSÕES GERAIS
A utilização de lógica Fuzzy para modelagem de sistemas genéricos que
tenham como base a utilização de controle de potência baseado em dados
recebidos de sensores mostrou-se bastante satisfatória.
A modelagem do sistema teórico de temperatura é feita utilizando três
sensores de temperatura que fornecem os dados iniciais a serem trabalhados, assim
é realizada a busca dos valores de pertinência para cada leitura realizada, e então
aplica-se a tabela de regras.
A utilização da plataforma desenvolvida proporcionou uma maior velocidade
para o desenvolvimento de um ambiente Fuzzy comparado ao desenvolvimento
manual de uma aplicação que utilize o paradigma. Para realizar a comparação
utilizou-se a experiência que obtivemos na disciplina de Inteligência Artificial no ano
de 2010, em que foram utilizadas 2 semanas de trabalho para modelarmos uma
aplicação Fuzzy simples. Já utilizando a plataforma desenvolvida foi possível
desenvolver o caso de testes em 1 dia de trabalho.
Ao modelar um ambiente Fuzzy é preciso se preocupar com a definição da
parte de variáveis, com a tabela de regras, com as rampas de pertinência, com o
método de defuzzificação, com a forma de busca das pertinências e com o retorno
do resultado final. Neste contexto o ganho de velocidade na implementação ocorre
pois utilizando a plataforma o usuário deve apenas preocupar- se com a definição
das variáveis, da tabela de regras e o ponto de pertinência máximo, como pode ser
visto na Tabela 8 abaixo.
70
Tabela 8 - Comparação das atividades a serem desenvolvidas com e sem a plataforma
Sem a Plataforma Com a Plataforma
Definição das variáveis Definição das variáveis
Tabela de Regras Tabela de Regras
Rampas de pertinência Rampas de pertinência
Método de Defuzzificação
Busca de pertinências
Retorno do resultado final
Para o caso de teste proposto, a utilização do método de centro de gravidade
para defuzzificação mostrou-se a melhor opção por sua facilidade de implementação
e pela homogeneidade do resultado final. Uma vez que todas as variáveis descritas
têm o mesmo intervalo de variação, o mesmo gráfico de pertinência e são
submetidas à mesma tabela de regras. Entretanto esta definição de utilizar os
mesmos intervalos de variação, o mesmo gráfico de pertinência e a mesma tabela
de regras não é uma limitação do projeto, pois a plataforma permite que cada
variável seja definida independentemente.
Como pode ser verificado no capítulo 5, ao confrontar os dados simulados
com os dados obtidos por meio da modelagem do sistema de temperatura,
obtivemos uma diferença de apenas 3,94 devido a perda de precisão causada pelo
truncamento da variável em apenas 7 bits, contra os 32 bits da plataforma simulada.
Pois dos 7 bits um está reservado para a representação da parte inteira, restado 6
bits para os dados reais a serem trabalhados.
Isto demonstra que o valor está próximo do comportamento real e que a
plataforma apresenta o comportamento esperado.
Essa quantidade de 7 bits foi definida em virtude da quantidade de pinos
existentes no micro controlador e na FPGA para realizar a troca de informação. O
aumento da quantidade de bits trabalhados interfere diretamente na precisão, pois
conforme aumenta-se o número de bits, a precisão aumenta, sendo possível retratar
com uma maior veracidade os dados trabalhados dentro da FPGA.
A utilização de FPGAs permite uma maior viabilidade de implementação de
lógica Fuzzy em dispositivos embarcados. Pois ao ter um co-processador especifico
para essa finalidade é possível obter um menor uso de CPU do dispositivo em
comparação a aplicação de lógica Fuzzy implementada inteiramente por software.
71
Assim mantemos a mesma flexibilidade de alteração da lógica Fuzzy que se obtém
ao desenvolvê-la em software.
6.2 FUTURAS IMPLEMENTAÇÕES
Como futuras implementações é possível pensar na utilização de outros
hardwares tão robustos quanto a FPGA com uma complexidade de desenvolvimento
menor e também com um custo menor, como por exemplo, uma arquitetura ARM de
32 bits.
Também é interessante o estudo do aumento da quantidade de sensores
utilizados. Pode-se também realizar o aumento da precisão do calculo de 7 para 16
ou 32 bits.
Utilizar um protocolo de troca de informações entre o micro controlador e a
FPGA de forma serial, permitindo assim a manipulação de variáveis de tamanho
maior, não ficando limitado a apenas 7 bits.
Outra implementação a se pensar é a alteração do algoritmo de
defuzzificação, pois utilizamos uma média ponderada, podendo, em virtude da
aplicação e dependendo do sistema a ser utilizado, ser mais interessante outro tipo
de abordagem, como uma média quadrática ou uma média simples.
No micro controlador pode-se aplicar uma interpolação dos dados lidos,
evitando que seja necessário arredondar o valor lido pelo sensor para um valor já
existente dentro da memória de dados da FPGA. Permitindo assim que exista uma
maior precisão na leitura dos resultados.
72
73
REFERÊNCIAS
DA COSTA, Alex; RODRÍGUEZ, Antonio Gabriel; SIMAS, Etiene P. Lazzeris;
ARAÚJO, Roberto Da Silva. Lógica fuzzy: Conceitos e Aplicações. Porto Alegre:
Universidade do Vale do Rio dos Sinos – UNISINOS, 2003.
SANTANA, Henrique; CHAPUR, Raphael Saulors. Teoria e Aplicação da Lógica
Fuzzy em Sistemas de Apoio à Decisão. Porto Alegre: Universidade do Vale do
Rio dos Sinos, 2005.
ADILÉA, Wagner. Extração de Conhecimento a partir de Redes Neurais aplicada
ao Problema da Cinemática Inversa na Robótica. Dissertação (Mestrado em
Computação Aplicada) Porto Alegre: Universidade do Vale do Rio dos Sinos –
UNISINOS, 2003.
KLIR, George; CLAIR, Ute H. St.; YUAN, Bo. Fuzzy Set Theory – Foundations and
Applications, Estados Unidos : ed. Prentice Hall, 1997.
MUKAIDONO, Masao. Fuzzy Logic for beginners, Singapore: ed. World
Scientific, 2001.
RUSS, Eberhart; SIMPSON, Pat; DOBBINS, Roy. Computational Intelligence PC
tools, London: ed. AP Professional, 1996.
KHUDHAIR-Abu, Aws, MURESAN Radu, YANG Simon X. FPGA Based Real-Time
Adaptive Fuzzy Logic Controller, School of Engineering - University of Guelph,
Canada, 2010.
74
TEIXEIRA, E; ARAUJO, M.,; BREUNING, A.; Azevedo, H.; CORREA, G. . Hardware
Implementation of a fuzzy controller for nonlinear applications. In Proc. of 21st
IEEE Int. Conf. on Industrial Electronics, Control, and Instrumentation, Florida, USA,
1995, pp. 1520-1524.
ARANGUREN, G.; NOZAL, L.A.L; BASOGAIN, X.; MATIN, J.L; ARROYBE, J.L. .
Hardware implementation of a pipeline fuzzy controller and software tools.
Fuzzy Sets and Systems, vol. 128, no.1, pp. 61-79, 2002.
SANCHEZ-Solano, S.; CANRERA, A.J.; BATURONE, I.; MORENO-Velo, F.J.;
BROX, M. . FPGA implementation of embedded fuzzy controllers for robotic
applications, IEEE Transactions on Industrial Electronics, vol. 54, no. 4, pp. 1937-
1945, 2007.
WANG Dali; BAI Ying. Implementation of fuzzy logic control systems, Springer,
London, 2006, pp. 37-52.
LIU, Yi-Hua; YANG, Zong-Zhen; HUANG, Shi-Qing; WEI, Jo-Fang. Design and
Implementation of an FPGA-Based Fuzzy Controller for Switched-Mode Power
Supplies Department of Electrical Engineering. National Taiwan University of
Science and Technology - Taipei, TAIWAN, 2011.
ZHANG, J.Y.; LI, Y. . Application of genetic algorithm in optimization of fuzzy
control rules, in Proc. of 6th IEEE International Conference on Intelligent Systems
Design and Applications, Shandong, China, 2006, pp. 529-534.
TABOADA K.; MABU S.; GONZALES, E. . Genetic network programming for
fuzzy association rule-based classification, in Proc. of 7th IEEE Congress on
Evolutionary Computation, Trondheim, Norway, 2009, pp.2387-2394.
BIGARBEGIAN M.; MELEK W.; GOLNARAGHI F. . A novel neuro-fuzzy controller
to enhance the performance of vehicle semi-active suspension systems,
Vehicle System Dynamics, vol. 45, no.8, pp. 691-711, 2008.
75
LIU T. H.; LEE Y. C.; CHANG Y. H. . Adaptive controller design for a linear motor
control system, IEEE Trans. Aerosp. Electron. Syst., vol. 40, no. 2, pp. 601–613,
Apr. 2004.
QINGDING G.; QINGTAO H.; YANLI Q. . Neural network real-time IP position
controller on-line design for permanent magnetic linear synchronous motor, in
Proc. 7th Int. Advanced Motion Control, 2002, pp. 386–389.
LIN F. J.; HUANG P.K.; CHOU W. D. . Recurrent fuzzy neural network controlled
linear induction motor servo drive using genetic algorithm, IEEE Trans. Ind.
Electron., vol. 54, no. 3, pp. 1449–1461, Mar. 2007.
WAI R. J.; CHU C. C. . Motion control of linear induction motor via petri fuzzy
neural network, IEEE Trans. Ind. Electron., vol. 54, no. 1, pp. 281–295, Feb. 2007.
KUNG Y. S. . Design and implementation of a high-performance PMLSM drives
using DSP chip, IEEE Trans. Ind. Electron., vol. 55, no. 3, pp. 1341–1351, Mar.
2008.
LIN F. J.; WANG D. H.; HUANG P. K. . FPGA-based fuzzy sliding mode control
for a linear induction motor drive, Proc. Inst. Elect. Eng.—Elect.Power Appl., vol.
152, no. 5, pp. 1137–1148, Sep. 2005.
KUNG Y. S.; FUNG R. F.; TAI T. Y. . Realization of a motion control IC for X–Y
table based on novel FPGA technology, IEEE Trans. Ind.Electron., vol. 56, no. 1,
pp. 43–53, Jan. 2009.
CECATI C.; CIANCETTA F.. A Multilevel Inverter for Renewables with Fuzzy
Logic-based Control, in Proc. of Int. Conf. on Clean Electrical Power (lCCEP 2009),
Capri, 9-11 June, 2009.
CHOWDHURY, Shubhajit Roy; SAHA Hiranmay . A High-Performance FPGA
Based Fuzzy Processor Architecture for Medical Diagnosis, Jadavpur University,
India, 2008.
76
ALMEIDA, C. F. M.; KAGAN N. . Aplicação de algoritmos genéticos e teoria dos
conjuntos Fuzzy no dimensionamento de sistemas de monitoração para redes
de transmissão de energia elétrica, Sba Controle &
Automação, vol.21 no.4, Campinas, Julho/Agosto, 2010.
OUERHANI , Nabil. Visual Attention: From Bio-inspired Modeling to Real-Time
Implementation, in Ph.D. Thesis, Dec. 2003.
LEE S.; et al., The Brain Mimicking Visual Attention Engine: An 80X60 Digital
Cellular Neural Network for Rapid Global Feature Extraction, in IEEE Symposium
on VLSI. May. 2008.
KIM , J.Y.; et al. A 201.4GOPS 496mW Real-Time Multi-Object Recognition
Processor with Bio-Inspired Neural Perception Engine, in IEEE ISSCC, Feb.
2009. Session 8.3.
77
ANEXOS
ANEXO 1 - BUSCA DE PERTINÊNCIAS NAS MEMÓRIAS DA FPGA
78
ANEXO 2 - DIAGRAMA EM BLOCOS DA FPGA
79
ANEXO 3 - RESULTADO DA SIMULAÇÃO COMPLETA DA FPGA
80
ANEXO 4 - ARQUIVOS DE MEMÓRIA DA FPGA
4.1 - Arquivo de memória relativo aos Dados
4.2 - Arquivo de memória relativo às Pertinências
81
ANEXO 5 – DIAGRAMA RTL