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


PEDRO ANDRIOW


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


PEDRO ANDRIOW


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


______________________________ Prof. Msc. Maristela Regina Weinfurter


______________________________ Prof. Msc. Valfredo Pilla Júnior


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

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

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

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

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.

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

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

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

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

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

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.

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"


30%


menor ou igual a 30ºC - "MODERADO"


50%


menor ou igual a 35ºC - "QUENTE"


70%

Se temperatura lida for maior do que 35ºC -

"MUITO QUENTE".


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



0100 Resultado da tabela de regra para o sensor 1



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"


10%


menor ou igual a 25ºC - "AGRADÁVEL"


30%


menor ou igual a 30ºC - "MODERADO"


50%


menor ou igual a 35ºC - "QUENTE"


70%

Se temperatura lida for maior do que 35ºC -

"MUITO QUENTE".


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.

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.

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

Plataforma Geradora de Controladores Fuzzy em FPGA · xv RESUMO Resumo: A Lógica Fuzzy tem como...

Documents

Transcript of Plataforma Geradora de Controladores Fuzzy em FPGA · xv RESUMO Resumo: A Lógica Fuzzy tem como...