CENTRO UNIVERSITÁRIO SANTANNA CURSO DE ENGENHARIA DA COMPUTAÇÃO

CARLILIAN OLIVEIRA ERICK CARRIJO DE OLIVEIRA

JOICE CRISTINA CANDIDO JOSÉ OLAIRSON VALENTIM

LEANDRO ORTEGA

OSÉIAS VIEIRA MELO PABLO INÁCIO DUTRA

Projeto Integrador

São Paulo

2012

CARLILIAN OLIVEIRA ERICK CARRIJO DE OLIVEIRA

JOICE CRISTINA CANDIDO JOSÉ OLAIRSON VALENTIM

LEANDRO ORTEGA

OSÉIAS VIEIRA MELO PABLO INÁCIO DUTRA

Projeto Integrador

Projeto apresentado ao Centro Universitário Santanna, como requisito obrigatório para obtenção da nota do Projeto Integrador.

Orientador: Prof. Paulo Cezar Souza

São Paulo

2012

Dedicamos este projeto a todo professor que acredita no potencial de seu aluno, tornando-se seu principal incentivador.

Resumo

O projeto consiste em desenvolver um sistema de controle microprocessado

baseado em lógica Fuzzy, utilizando microprocessador Arduino. No projeto será

demonstrado como é possível controlar a posição de um objeto, utilizando a lógica

Fuzzy, microcontroladores, sensores e uma turbina de ar e também demonstrar que

ao utilizar a lógica Fuzzy o nível de precisão é maior do que quando utilizamos

outras formas de controle, como o PID por exemplo. No projeto utiliza-se a

linguagem C# com a biblioteca DotFuzzy para efetuar a fuzzificação e enviar a

informação ao microprocessador Arduino, utiliza-se a linguagem C++ para configurar

os microcontroladores que tem a função de receber as informações do sensor e

controlar a velocidade da turbina. A automação é feita através de controle

microprocessado, motor e sensor ultrassônico.

Abstract

The project is to develop a microprocessor control system based on fuzzy logic,

using Arduino microprocessor. In the design will be demonstrate how it is possible to

control the position of an object using a fuzzy logic, microcontrollers, sensors, and an

air turbine, and also demonstrate how better is fuzzy logic than other forms of control,

like as PID for example. In this project will be used the C# program language with the

library to make DotFuzzy fuzzification and send the information to the Arduino

microprocessor, use C++ program language to configure the microcontroller whose

function is to receive the sensor information and control the speed of the turbine. The

automation is done by microprocessor control, motor and ultrasonic sensor.

Sumário

1. Diretivas do Projeto Integrador ................................................. 7

2. Introdução .................................................................................... 8

3. Desenvolvimento ........................................................................ 9

3.1. Arduino .................................................................................... 10

3.1.1. Composição Básica da Placa do Arduino ........................ 11

3.1.2. Como Programar ................................................................. 12

3.1.3. Integração com o Computador .......................................... 13

3.2. Sensor Ultrassônico .............................................................. 14

3.3. Driver para acionamento da turbina .................................... 17

3.4. C# e dot.Net............................................................................. 19

3.5. Sistemas de Controle Fuzzy ................................................. 20

3.6. DotFuzzy .................................................................................. 22

3.6.1. Funções da Biblioteca DotFuzzy ....................................... 23

3.6.2. Exemplo de um código fonte em C# usando DotFuzzy .. 24

4. Diagramas .................................................................................. 27

5. Programação ............................................................................. 31

6. Interface gráfica ........................................................................ 34

7. Montagem da parte física ......................................................... 36

8. Conclusão .................................................................................. 38

9. Bibliografia: ............................................................................... 39

7

1. Diretivas do Projeto Integrador

O TEMA: Sendo o tema livre, foi escolhido um projeto que de certa forma engloba

todas as disciplinas abordadas até o momento. Empenhamo-nos em moldar o

projeto aos requisitos de cada disciplina.

Neste projeto, foi aplicado o conhecimento dos seguintes módulos:

INTELIGÊNCIA ARTIFICIAL

Foram programados mecanismos de buscas em espaços de soluções para permitir o

desempenho em saídas geradas por microcontroladores e computadores

inteligentes sobre atuadores.

SISTEMAS ESPECIALISTAS

Foi especificada uma arquitetura de sistema que descreve os componentes de um

Sistema Especialista, como interface de aquisição de conhecimento, base de

conhecimento, motor de inferência e interface de avaliação do resultado.

INTERFACE HOMEM MÁQUINA

Desenvolveu-se uma avaliação de usabilidade para garantir a facilidade do uso e a

tolerância à falha humana. A meta de usabilidade determinada é “não erro”.

CONTROLE INTELIGENTE

Produziu-se um sistema de malha fechada de controle alimentado por

comportamento inteligente pela lógica Fuzzy; garantindo a precisão dos resultados,

mesmo com entradas vagas ou imprecisas.

8

2. Introdução

O objetivo do projeto é utilizar a lógica Fuzzy para estabilizar um objeto em um

túnel de vento gerado por uma turbina. Utiliza-se o Arduino para receber as

informações coletadas do sensor ultrassônico que são processadas pelo programa

rodando no computador que envia a outro Arduino responsável por controlar a

velocidade da turbina, estabilizando assim o objeto em uma posição enviada pelo

computador. Esse controle inteligente é baseado nas regras Fuzzy.

Este projeto utiliza controle inteligente que é o sucessor do campo de controle

adaptativo, muito usado na década de 70. Modelagens de controle inteligente

buscam aprender para reduzir incertezas e melhorar o desempenho de um sistema

fechado em loop, baseando-se em aproximações e técnicas de passo a passo a fim

de possibilitar a solução de problemas ainda não cobertos por outros métodos de

solução, incluindo-se medidas complicadas baseadas em sistemas não lineares.

Como os campos de controle não linear estão se tornando bem fundamentados, as

ferramentas de controle como redes neurais, logica fuzzy tem se tornando populares

e bem utilizadas.

Os autores do projeto optaram por utilizar regras fuzzy em consequência desse

aumento de popularidade e confiabilidade demonstrada.

9

3. Desenvolvimento

No desenvolvimento do trabalho foram utilizados alguns softwares e ferramentas

que facilitaram todo o processo da automatização. Foi desenvolvido um software na

linguagem C# juntamente com a biblioteca DotFuzzy que faz a fuzzificação e

interface entre os dois microcontroladores, estes programados na própria IDE do

Arduino em linguagem C++. Na parte de hardware, temos um motor retirado de um

secador de cabelos, um sensor ultrassônico.

10

3.1. Arduino

Arduino é uma plataforma open-source de protótipos eletrônicos com

hardware e software flexíveis e fáceis de usar. Pela sua simplicidade e baixo custo é

muito utilizado por artistas, designers, e qualquer pessoa interessada em criar

objetos ou ambientes interativos.

As placas podem ser construídas à mão ou compradas, o software pode ser

baixado gratuitamente. Os projetos de hardware estão disponíveis sob uma licença

open-source e você está livre para adaptá-los às suas necessidades.

11

3.1.1. Composição Básica da Placa do Arduino

A placa é basicamente composta de um micro-controlador (o cérebro da

placa), um circuito para gerar o clock (velocidade de processamento, dado em MHz)

composto de um cristal e dois capacitores, um chip FTDI de conversão Serial-USB,

para que possamos enviar o programa do computador para o Arduino, ou para

fazermos alguma leitura da placa.

Temos quatorze pinos de entrada/saída digitais sendo que seis destes pinos

são PWM (modulação por largura de pulso), ou seja, através do ajuste da

frequência, conseguimos ter um valor entre zero e cinco Volts na saída, alternando a

variável com um número entre zero e quinhentos e doze, respectivamente.

Temos seis pinos de entradas analógicas onde podemos fazer leitura

analógica. O Arduino tem um circuito embutido chamado conversor analógico digital

que lê a variação na tensão causada pelo potenciômetro e converte-a em números

entre 0 e 1023.

12

3.1.2. Como Programar

No site do Arduino na seção de downloads, temos disponível gratuitamente a

IDE (Integrated Development Environment), um ambiente integrado para

desenvolvimento de software. Através desta IDE, escrevemos um código em

linguagem C++, com algumas bibliotecas já pré-dispostas, que nos possibilita o

controle total da placa do Arduino. Após o código escrito, verificamos se o código

está correto compilando o mesmo na própria IDE. Se estiver tudo correto, basta

fazer o upload do programa para o Arduino via cabo USB e pronto! Seu Arduino

estará programado para executar seu programa.

13

3.1.3. Integração com o Computador

O Canal Serial, além de servir para passar os programas da IDE do Arduino

para o micro controlador, também serve para que o Arduino se comunique com

outros dispositivos, por exemplo, Arduino + GPS, Arduino + Celular, Arduino+

Computador, Arduino + Arduino, Arduino + Display, etc.

O Canal Serial utiliza-se de dois cabos, um para transmitir informações (TX), e outro

para receber informações (RX). No Arduino, os pinos zero e um fazem estes papéis.

Em seu computador, geralmente, temos uma porta padrão DB9 para esta

comunicação. No nosso caso, iremos utilizar o cabo USB, já que o Arduino vem

equipado com o conversor Serial-USB.

14

3.2. Sensor Ultrassônico

A principal vantagem do sonar além do seu baixo custo é a necessidade de

poucos recursos computacionais. Mas a informação retornada é limitada devido ao

seu de raio de atuação muito largo, o que causa leituras imprecisas do ambiente. O

sonar é bastante empregado robótica móvel também por ser um dos mais simples

de operar. O seu funcionamento se resume a: um transdutor emite uma pequena

onda de som em alta frequência; quando esta onda atinge um objeto ela se reflete e

é novamente captada pelo transdutor. A distância pode ser calculada usando o

tempo entre a emissão e o recebimento de uma onda de som, dividindo-se o tempo

decorrido por dois, e multiplicando o resultado pela velocidade do som.

15

Características do Módulo Ultrassônico

Tensão - 5v

Corrente - 30mA Tip. 50mA Max.

Freqüência - 40KHz

Distância Max. - 3 m

Distância Min. - 3 cm

Sensibilidade - Detecta um cabo de vassoura com 3cm de diâmetro, a mais de 2m de distância

Disparo (Trigger)

- 10uS Min. nível TTL

Pulso de eco - Sinal TTL positivo, proporcional à distância ao obstáculo

Dimensões - 43mm x 20mm x 17mm

O sensor é controlado por um impulso de nível lógico “1”, com a duração de

20µS. Após receber este impulso de disparo, o sensor envia um sinal acústico

ultrassônico e coloca a linha de eco no nível lógico “1”, ficando de seguida à espera

pelo sinal acústico do eco. Assim que o eco é recebido, o sensor coloca a linha de

eco novamente a “0”. O microcontrolador pode ser facilmente programado para

medir o tempo que o eco demorou a ser detectado, isto é, o tempo que a linha de

eco esteve a “1”, e dessa forma calcular a distância a que se encontra o obstáculo

que provocou o eco. O diagrama temporal da figura abaixo ilustra o que foi dito.

Diagrama Temporal do Sensor Ultrassônico

16

A dispersão do sinal acústico não é uniforme para todo o espaço, e apesar do

sensor trabalhar com um ângulo de dispersão de 90º (noventa graus), a sua

precisão melhora consideravelmente se for diminuído o ângulo para o qual se

pretende que seja efetivada a detecção para um ângulo de 45º de dispersão.

Padrão de dispersão do sinal ultrassônico do sensor

Ligação entre o sensor e o Arduino

OBS.: Na ilustração os pinos utilizados foram o 12 e o 10, mas no projeto utilizamos os pinos 8 e 4 respectivamente.

17

3.3. Driver para acionamento da turbina

Como a turbina de ar utilizada é alimentada por 12 volts e uma corrente muito maior

do que a fornecida pela saída PWM do Arduino, foi preciso montar um circuito que

atuasse como driver para a turbina utilizando um transistor TIP120. Abaixo, as

especificações técnicas retiradas do datasheet do fabricante.

18

A configuração do circuito foi a seguinte:

Resistor de 2,2K ligado à base do transistor e ao pino PWM do Arduino. Diodo

1N4007 ligado entre os terminais da turbina de ar para que evite uma corrente

reversa ao ser desligada a turbina, pois ela é construída a partir de enrolamentos de

cobre, o que faz com que seja induzida uma corrente ao ser desligada a alimentação

da mesma. Alimentação de 12 volts e 1 Ampére. Nunca se esquecendo de tornar o

aterramento comum entre todos os circuitos.

19

3.4. C# e dot.Net

A programação no computador foi feita com a ajuda do Visual Studio, onde

iremos iniciar um novo Projeto, selecionando Visual C# como linguagem de

programação, Windows Form Application como o tipo do nosso Projeto, e

selecionaremos o framework .NET Framework 3.5. Uma breve explicação para

Framework: Nós, humanos, escrevemos uma linguagem de programação em um

nível mais próximo da nossa linguagem, então este código é compilado e o

Framework é o responsável em pegar nosso código e transformá-lo em códigos que

o computador entenda e possa interagir com os dispositivos.

Para adicionar um controle pela porta serial ao programa, basta selecionar

SerialPort na caixa de ferramentas e arrastar para dentro da janela programa criado.

Depois de adicionada, pode-se configurar as suas propriedades da seguinte forma:

20

3.5. Sistemas de Controle Fuzzy

A Lógica Fuzzy (Nebulosa) é a lógica que suporta os modos de raciocínio que

são aproximados ao invés de exatos. Modelagem e controle Fuzzy de sistemas são

técnicas para o tratamento de informações qualitativas de uma forma rigorosa.

Derivada do conceito de conjuntos Fuzzy, a lógica Fuzzy constitui a base para o

desenvolvimento de métodos e algoritmos de modelagem e controle de processos,

permitindo a redução da complexidade de projeto e implementação, tornando-se a

solução para problemas de controle até então intratáveis por técnicas clássicas.

A ideia básica em controle Fuzzy é modelar as ações a partir de

conhecimento especialista, ao invés de, necessariamente, modelar o processo em

si. Isso nos leva a uma abordagem diferente dos métodos convencionais de controle

de processos, onde os mesmos são desenvolvidos via modelagem matemática dos

processos de modo a derivar as ações de controle como função do estado do

processo. A motivação para esta nova abordagem veio de casos onde o

conhecimento especialista de controle era disponível, seja por meio de operadores

ou de projetistas, e os modelos matemáticos envolvidos eram muito custosos, ou

muito complicados para serem desenvolvidos.

A estrutura de um processo controlado por um controlador Fuzzy é mostrada

na figura abaixo enfatizando-se seus componentes básicos: a interface de

fuzzyficação, a base de conhecimento, a base de dados, o procedimento de

inferência e a interface de defuzzyficação.

21

A interface de fuzzyficação toma os valores das variáveis de entrada, faz um

escalonamento para condicionar os valores ao universo de discurso normalizado e

fuzzyfica os valores, transformando números em conjuntos Fuzzy, de modo que

possam se tornar instâncias de variáveis linguísticas. A base de conhecimento

consiste de uma base de regras, caracterizando a estratégia de controle e suas

metas. A base de dados armazena as definições necessárias sobre discretizações e

normalizações dos universos de discurso, as partições Fuzzy dos espaços de

entrada e saída e as definições das funções de pertinência. O procedimento de

inferência processa os dados Fuzzy de entrada, junto com as regras, de modo a

inferir as ações de controle Fuzzy, aplicando o operador de implicação Fuzzy e as

regras de inferência da lógica Fuzzy. A interface de defuzzyficação transforma as

ações de controle Fuzzy inferidas em ações de controle não-fuzzy. Em seguida,

efetua um escalamento, de modo a compatibilizar os valores normalizados vindos do

passo anterior com os valores dos universos de discurso reais das variáveis.

Após a inferência da ação de controle fuzzy, é necessária a determinação de

uma ação de controle não fuzzy que melhor represente a decisão fuzzy, para ser

efetivamente enviada ao controle. Apesar de não haver nenhum procedimento

sistemático para a escolha da estratégia de defuzzyficação, as mais comuns

incluem: o critério do máximo (MAX), que escolhe o ponto onde a função inferida

tem seu máximo, a média dos máximos (MDM), que representa o valor médio dentre

todos pontos de máximo quando existe mais de um máximo, e o método do centro

de área (CDA), que retorna o centro de área da função inferida.

22

3.6. DotFuzzy

DotFuzzy é uma classe de biblioteca open source, sob a licença LGPL,

desenvolvida para resolver problemas ligados à Lógica Fuzzy. A biblioteca foi

construída em C# e pode ser implementada por todas as linguagens que o .NET

suporta.

Por ser totalmente orientada a objetos tem-se uma facilidade de uso e

implementação muito grande. O DotFuzzy foi desenvolvido para ser flexível, robusto

e escalável.

O DotFuzzy implementa a fuzzyficação, as regras de validação e a

defuzzyficação com o método centroide, um dos mais utilizados pela lógica Fuzzy.

23

3.6.1. Funções da Biblioteca DotFuzzy

A biblioteca DotFuzzy.dll é compilada com os seguintes arquivos, sendo que

todos são open source, livres para consulta e alteração se preciso. As funções

utilizadas estão todas dentro dos arquivos .CS, que por sua vez estão compiladas

dentro do arquivo DotFuzzy.dll.

Referenciaremos a biblioteca ao projeto no Visual Studio, ficando da seguinte

forma:

24

3.6.2. Exemplo de um código fonte em C# usando DotFuzzy

Com o Visual Studio preparado, agora basta começar a programar usando a

linguagem C#. Adiante, será mostrado um pequeno exemplo do uso da biblioteca,

onde os parâmetros serão fixos e escritos no próprio código fonte, portanto,

funcionará apenas para um exemplo específico.

Código fonte do arquivo

25

Este programa demonstrado, ao ser executado irá ter a seguinte resposta:

Seria uma espécie de “Hello World” para o DotFuzzy. Ao clicar no botão “Exemplo”,

ele chama a função descrita no código acima como:

private void button1_Click(object sender, EventArgs e)

Quando esta função é chamada, temos a linha:

LinguisticVariable water = new LinguisticVariable("Water");

Que cria uma variável linguística chamada “water”, e irá acrescentar os parâmetros

de frio, morno ou quente, nas seguintes linhas:

water.MembershipFunctionCollection.Add(new MembershipFunction("Cold", 0, 0, 20, 40));

water.MembershipFunctionCollection.Add(new MembershipFunction("Tepid", 30, 50, 50, 70));

water.MembershipFunctionCollection.Add(new MembershipFunction("Hot", 50, 80, 100, 100));

Ela executa o mesmo procedimento para criar a variável linguística chamada

“Power”.

Depois disso, ela cria o objeto fuzzyEngine, que é como se fosse o motor de

inferência Fuzzy, com a seguinte função:

FuzzyEngine fuzzyEngine = new FuzzyEngine();

Agora são adicionadas as variáveis linguísticas ao objeto criado:

fuzzyEngine.LinguisticVariableCollection.Add(water);

fuzzyEngine.LinguisticVariableCollection.Add(power);

É estipulada qual é a variável de saída:

fuzzyEngine.Consequent = "Power";

26

São acrescentadas as regras de inferência:

fuzzyEngine.FuzzyRuleCollection.Add(new FuzzyRule("IF (Water IS Cold) OR (Water IS Tepid)

THEN Power IS High"));

fuzzyEngine.FuzzyRuleCollection.Add(new FuzzyRule("IF (Water IS Hot) THEN Power IS Low"));

É estipulado um valor de entrada para a variável water:

water.InputValue = 60;

Ao final é chamada a função que abre uma caixa de mensagens com a resposta:

39,72.

MessageBox.Show(fuzzyEngine.Defuzzify().ToString());

27

4. Diagramas

Para a criação dos programas, foram levantados os fluxos principais e os

diagramas são mostrados a seguir.

O primeiro fluxograma mostra uma visão superficial do sistema.

28

Nos próximos três fluxogramas foram divididos os códigos de cada

componente do sistema: Sensor, Processo e Atuador, que ficaram da seguinte

forma:

29

30

31

5. Programação

Baseado nos sistemas e dispositivos acima citados, começaremos a montagem do

projeto. A lógica do sistema será descrita a seguir, com informações detalhadas de

cada trecho do código:

Sensor ultrassônico faz medição da distância do objeto através do código abaixo e

envia o valor ao computador

Computador recebe o valor da distância e envia o valor para ser fuzzyficado.

O processo de fuzzyficação funciona da seguinte forma: A distância é comparada

com o gráfico a seguir, para a obtenção da pertinência:

Entrada: Distância

muitoPerto = (0,0) ; (0,1) ; (12,1) ; (20,0) Perto = (12,0) ; (23,1) ; (26,1) ; (30,0) Meio = (26,0) ; (30,1) ; (33,1) ; (38,0) Longe = (35,0) ; (38,1) ; (42,1) ; (52,0) muitoLonge = (42,0) ; (50,1) ; (60,1) ; (60,0)

32

Na biblioteca DotFuzzy é programado da seguinte maneira:

Depois de obtido o valor, executa-se a função, que pelo método centróide vai

retornar o valor de saída fuzzyficado, sendo que a saída é regida pelo seguinte

gráfico:

Saída: potência do motor

muitoFraco = (60,0) ; (60,1) ; (60,1) ; (65,0) Fraco = (60,0) ; (65,1) ; (66,1) ; (67,0) Medio = (66,0) ; (74,1) ; (76,1) ; (84,0) Forte = (76,0) ; (84,1) ; (85,1) ; (90,0) muitoForte = ( 85,0) ; (90,1) ; (90,1) ; (90,0)

Na biblioteca DotFuzzy programa-se da seguinte maneira:

As regras utilizadas neste processo são as seguintes:

Regras de Fuzzificação

33

Na biblioteca, já com o comando de fuzzificação, funciona da seguinte forma:

Na sequencia, o programa envia o valor para o segundo Arduino, que está ligado à

turbina de ar:

O segundo Arduino, ligado à turbina recebe o valor que será convertido em um sinal

PWM compreendido entre zero e cinco volts.

Na sequencia, o drive PWM recebe o valor entre zero e cinco volts, convertendo-o

em um valor entre zero e doze volts, este sim que alimentará a turbina, fazendo com

que o objeto permaneça suspenso no ar, praticamente fixo nessa posição. Caso o

objeto desloque-se para baixo ou para cima, o sistema detecta o movimento e

informa à turbina a rotação necessária para a permanência do objeto na mesma

posição.

34

6. Interface gráfica

A interface gráfica criada no Visual Studio C# tem a função de verificar as portas

seriais, receber a informação que foi lida pelo microcontrolador no sensor

ultrassônico, fazer a fuzzificação da informação recebida e enviar esta informação

para o segundo microcontrolador, que tem a função de controlar a turbina, variando

sua velocidade através do controle de corrente, assim possibilitando a permanência

do objeto a uma determinada distancia.

Interface criada para o controle

Conforme figura, ele contém os seguintes botões e componentes em sua interface:

Botão Ativar/Desativar, utilizado para ativar as portas serias e iniciar a leitura

e envio de informações;

Caixa de seleção Porta Sensor e Porta Turbina: contém as opções de portas

seriais no exemplo “COM5 e COM3”, que podem ser utilizadas com os

microcontroladores.

Barras de progresso: uma indicação visual dos valores recebidos e enviados

para os dois microcontroladores. Esta visualização permite ter informações

detalhadas do valor lido pelo sensor ultrassônico e o valor enviado para a

turbina através do segundo microcontrolador.

35

Este conjunto faz toda a parte de comunicação e ajuste de potência. O software

em si, tem todo o controle que permite ao usuário efetuar a melhor opção de portas

e velocidade utilizando a lógica Fuzzy.

Buscamos desenvolver o software de uma maneira bem minimalista e intuitiva,

tendo como meta de usabilidade o não acesso ao erro, em caso de erro, o usuário

consegue facilmente reverter o resultado através da interface.

36

7. Montagem da parte física

Inicialmente houve a tentativa de montar com um cooler de doze (12) volts /

doze mili (0,12) amperes em uma garrafa pet adaptada, porém, notou-se que este

modelo não tinha potência suficiente para levitar a bolinha, então foi usada uma

turbina de secador de cabelos e colocada em um tubo transparente de sessenta cm,

com o sensor localizado no topo do tubo, e então conseguimos o resultado

esperado.

Protótipo inicial (à esquerda) e Protótipo Final (à direita)

37

Depois começamos a fazer os testes com o sensor ultrassônico para definir qual

seria o range do mesmo, e como ele se comportava em ambientes abertos e dentro

do tubo.

Sensor ultrassônico sendo testado

Agora é a vez de ajustar qual é a tensão máxima e mínima de alimentação da

turbina de ar para setar os valores máximos e mínimos a serem assumidos através

do pino PWM que injeta a corrente no driver.

Turbina de ar sendo testada

38

8. Conclusão

Com a elaboração deste projeto consegue-se avaliar o quanto o sistema de

controle baseado em lógica Fuzzy é mais veloz para atingir a estabilidade de

resposta sem necessidade de ficar oscilando entre picos.

Leva-se um tempo para aferir os valores para a estruturação dos gráficos de

entrada e saída no processo de fuzzificação. Neste projeto, como é apenas de

caráter educacional, os ajustes foram feitos pelos próprios autores até chegar ao

padrão ideal, mas quando for implementado em alguma aplicação que exija

precisão, é necessário a consulta com um especialista no auxílio da plotagem de tais

gráficos.

39

9. Bibliografia:

DEITEL, H. M.; “C# - Como programar”, São Paulo, Pearson Education, 2003 BOYLESTAD, R. L.; “Dispositivos eletrônicos e teoria de circuitos”; 8ª Edição, São Paulo, Prentice Hall, 2004. “Departamento de Engenharia da Computação e Automação Industrial da Universidade de Campinas”. Disponível em: < dca.fee.unicamp.br/pub/docs/gudwin/publications/ifsa95.pdf>. Acesso em: 20 jun. 2012 Arduino. Disponível em: <http://www.arduino.cc>. Acesso em: 20 jun. 2012. BERTOLI, M.; ”DotFuzzy”. Disponível em: http://www.havana7.com/dotfuzzy. Acesso em

22/04/2012.