eFLL - Uma Biblioteca Fuzzy para Arduino e Sistemas Embarcados

Read this article in English


Lógica Fuzzy é uma extensão da lógica booleana tradicional que através de variáveis linguísticas permite expressar valores lógicos intermediários entre o FALSO e VERDADEIRO, descrevendo com maior eficiência o princípio da incerteza do mundo real.

Sistemas Fuzzy são aplicações praticas que empregam a Lógica Fuzzy nas tomadas de decisões com base nos termos e variáveis linguísticas, tendo na robótica e na eletrônica um grande espaço e utilidade.

Desenvolvida pelo Robotic Research Group (RRG) na Universidade Estadual do Piauí (UESPI-Teresina) a biblioteca eFLL (Embedded Fuzzy Logic Library) é uma opção versátil, leve e eficiente de trabalhar com a Lógica Fuzzy em sistemas embarcados.

Por favor, reporte Bugs e sugestões via comentários ou na página oficial do projeto no GitHub.

Como instalar

Modo Fácil

1º Passo: Abra o Arduino IDE

2º Passo: No menu principal, vá em SKETCH >> INCLUIR BIBLIOTECA >> GERENCIAR BIBLIOTECAS

3º Passo: Procure por "eFLL" ou "Fuzzy"

4º Passo: eFLL aparecerá na listagem, para finalizar, apenas aperte em INSTALAR, agora já pode incluir a eFLL nos seus sketchs

Modo Antigo

1º Passo: Vá a página oficial do projeto no GitHub: eFLL

2º Passo: Faça um clone do projeto usando o Git ou faço o download em  Donwload pelo botão "Downloas as zip".

3º Passo: Clone ou descompacte os arquivos para a pasta de bibliotecas do Arduino:

Obs: Renomeie a pasta de "eFLL-master" para "eFLL"

no Ubuntu (/usr/share/arduino/libraries/) caso instalado via apt-get;
no Windows, Mac ou Linux (Onde você baixou o IDE Arduino, a pasta de biblioteca está dentro)

Pronto, a biblioteca está pronta para ser usada.

Como importar

Caso a instalação da biblioteca tenha sido realizada com sucesso, para importar a biblioteca é fácil:

1º Passo: Abra o seu Arduino IDE, vá a aba no menu superior SKETCKS → BIBLIOTECA → Importar eFLL

Características

Escrita em C++/C, usa apenas a biblioteca padrão da linguagem C "stdlib.h", por isso a eFLL é uma biblioteca destinada não somente ao Arduino, mas qualquer Sistema Embarcado ou não que tenham seus comandos escritos em C.

Não possui limitações explicitas de quantidade de Conjuntos Fuzzy, Regras Fuzzy, Entradas ou Saídas, estas limitam-se a capacidade de processamento e armazenamento de cada microcontrolador

A biblioteca utiliza o processo:
(MAX-MIN) e (Mínimo de Mamdani) para a inferência e composição e (Centro de Área) para a desfuzzyficação, no universo contínuo.

Testes realizados utilizando a biblioteca GTest para C, Google Inc

Exemplo simples:

Controle de velocidade de um robô, entrada: Distância obstáculo frontal.



Breve documentação

Objeto Fuzzy - Este objeto engloba todo o Sistema Fuzzy, através dele, é possível manipular os Conjuntos Fuzzy, as Regras Linguísticas, entradas e saídas.

Objeto FuzzyInput  - Este objeto literalmente agrupa todos os Conjuntos Fuzzy de entradas que pertencem ao mesmo domínio

Objeto FuzzyOutput  - Este objeto é semelhante ao FuzzyInput, é usado para agrupa todos os Conjuntos Fuzzy de saída que pertencem ao mesmo domínio.

Objeto FuzzySet - Este é um dos principais objetos da Biblioteca Fuzzy, com é possível modelar cada conjunto do sistema em questão. Atualmente a biblioteca suporta as funções de pertinência triangular, trapezoidal e singleton, que são montadas com base nos pontos A, B, C e D que são passados por parâmetro no construtor FuzzySet(float a, float b, float c, float d), exemplos:

Função de pertinência triangular:

FuzzySet* fs = FuzzySet(10, 20, 20, 30);

FuzzySet* fs = FuzzySet(10, 33, 33, 33);

FuzzySet* fs = FuzzySet(5, 5, 5, 30);

Função de pertinência trapezoidal:

FuzzySet* fs = FuzzySet(10, 20, 30, 40);

FuzzySet* fs = FuzzySet(0, 0, 10, 20);

Qualquer valor abaixo de 10 terá pertinência = 1

FuzzySet* fs = FuzzySet(20, 30, 40, 40);

Qualquer valor acima de 30 terá pertinência = 1

Função de pertinência Singleton:

FuzzySet* fs = FuzzySet(20, 20, 20, 20);

Objeto FuzzyRule - Este objeto é usado para montar a base de regras do objeto Fuzzy, que contem um ou mais deste. Instanciado com FuzzyRule fr = new FuzzyRule(ID, antecedent, consequente)

Objeto FuzzyRuleAntecedent - Este objeto é usado para compor o objeto FuzzyRule, responsável por montar a expressão condicional do antecedente de um FuzzyRule, exemplos:

"SE distancia = pequena ENTAO velocidade = lenta"

FuzzyRuleAntecedent* ifDistanceSmall = new FuzzyRuleAntecedent(); ifDistanceSmall->joinSingle(small);

O método joinSingle(FuzzySet* fuzzySet); é usado para montar expressões simples de SE isto ENTÃO aquilo. Para compor expressões mais complexas existem outros métodos especiais.

"SE temperatura = quente E pressão = alta ENTAO risco = grande"

FuzzyRuleAntecedent* ifTemperatureHotAndPressureHight = new FuzzyRuleAntecedent();
ifTemperatureHotAndPressureHight->joinWithAND(hot, hight); 

"SE temperatura = quente OU pressão = alta ENTAO risco = grande"

FuzzyRuleAntecedent* ifTemperatureHotAndPressureHight = new FuzzyRuleAntecedent();
ifTemperatureHotAndPressureHight->joinWithOR(hot, hight);

Os métodos joinWithAND(FuzzySet* fuzzySet1, FuzzySet* fuzzySet2); e joinWithOR(FuzzySet* fuzzySet1, FuzzySet* fuzzySet2); podem fazer composições logicas entre os Conjuntos Fuzzy. Estes métodos possuem ainda variações mais avançadas que permitem aprimorar mais ainda a expressão, são eles:

bool joinWithAND(FuzzySet* fuzzySet, FuzzyRuleAntecedent* fuzzyRuleAntecedent);
bool joinWithAND(FuzzyRuleAntecedent* fuzzyRuleAntecedent, FuzzySet* fuzzySet);
bool joinWithOR(FuzzySet* fuzzySet, FuzzyRuleAntecedent* fuzzyRuleAntecedent);
bool joinWithOR(FuzzyRuleAntecedent* fuzzyRuleAntecedent, FuzzySet* fuzzySet);
bool joinWithAND(FuzzyRuleAntecedent* fuzzyRuleAntecedent1, FuzzyRuleAntecedent* fuzzyRuleAntecedent2);
bool joinWithOR(FuzzyRuleAntecedent* fuzzyRuleAntecedent1, FuzzyRuleAntecedent* fuzzyRuleAntecedent2);

exemplos:

"SE (velocidade = alta E distância = pequena) OR combustível = pouco ENTAO velocidade = pequena E consumo = baixo"

FuzzyRuleAntecedent* speedHightAndDistanceSmall = new FuzzyRuleAntecedent();
speedHightAndDistanceSmall->joinWithAND(hight, small); 

FuzzyRuleAntecedent* fuelLow = new FuzzyRuleAntecedent();
fuelLow->joinSingle(low); 

// Este objeto FuzzyRuleAntecedente é que será usada para compor o objeto FuzzyRule 
FuzzyRuleAntecedent* ifSpeedHightAndDistanceSmallOrFuelLow = new FuzzyRuleAntecedent();
ifSpeedHightAndDistanceSmallOrFuelLow->joinWithOR(speedHightAndDistanceSmall, fuelLow); 

Se fazendo valer destes métodos, qualquer expressão pode ser montada, pois um objeto FuzzyRuleAntecedent pode ser usado para compor outro objeto FuzzyRuleAntecedent, das mais diversas formas. OBS:. no exemplo anterior, o antecedente final foi composto pelos objetos speedHightAndDistanceSmall e
fuelLow mas este último poderia ser substituído sem perda pelo objeto FuzzySet low, já que o mesmo é uma expressão simples, sem nenhum operador condicional:

FuzzyRuleAntecedent* speedHightAndDistanceSmall = new FuzzyRuleAntecedent();
speedHightAndDistanceSmall->joinWithAND(hight, small); 

// Este objeto FuzzyRuleAntecedente é que será usada para compor o objeto FuzzyRule 
FuzzyRuleAntecedent* ifSpeedHightAndDistanceSmallOrFuelLow = new FuzzyRuleAntecedent();
ifSpeedHightAndDistanceSmallOrFuelLow->joinWithOR(speedHightAndDistanceSmall, low); 

Objeto FuzzyRuleConsequente - Este objeto é usado para compor o objeto FuzzyRule, responsavel por montar a expressão de saída de um FuzzyRule, exemplos:

"SE distancia = pequena ENTAO velocidade = lenta"

FuzzyRuleConsequent* thenSpeedSlow = new FuzzyRuleConsequent(); 
thenSpeedSlow->addOutput(slow);

O que resultaria em um objeto FuzzyRule:

FuzzyRule* fuzzyRule = new FuzzyRule(2, ifDistanceSmall, thenSpeedSlow);

"SE (velocidade = alta E distância = pequena) OR combustível = pouco ENTAO velocidade = pequena E consumo = baixo"

FuzzyRuleConsequent* thenSpeedSmallAndFeedTine = new FuzzyRuleConsequent(); thenSpeedSmallAndFeedSmall->addOutput(small);

thenSpeedSmallAndFeedSmall->addOutput(tine);  

Para o objeto FuzzyRuleConsequent toda a expressão é montada com o método addOutput(FuzzySet* fuzzySet);

O que resultaria em um objeto FuzzyRule:

FuzzyRule* fuzzyRule = new FuzzyRule(2, ifSpeedHightAndDistanceSmallOrFuelLow, thenSpeedSmallAndFeedTine);

Após montar um objeto FuzzyRule, use o método addFuzzyRule(FuzzyRule* fuzzyRule); do objeto Fuzzy para adicionar a regra na base de regras, repita o mesmo processo para todas as regras.

Dica

Estes são todos os objetos da biblioteca eFLL que são utilizados no processo. O passo seguinte, e geralmente interativo é manipulado por três métodos do objeto Fuzzy, o primeiro:

bool setInput(int ID, float valor);

É utilizado para repassar o valor de entrada crispe para o sistema, note que o primeiro parâmetro é o ID do objeto FuzzyInput ao qual o parâmetro valor é destinado.

bool fuzzify();

É utilizado para iniciar o processo de fuzzyficação, composição e inferência.

E por fim: float defuzzify(int ID);

É utilizado para finalizar o processo de fuzzyficação,  note que o ID que é passado por parametro é o ID do FuzzyOutput ao qual se deseja obter o valor desfuzzificado.

Dica: Algumas vezes é necessário conhecer a pertinência com a qual algum, ou cada Conjunto Fuzzy foi ativado. Para isso, utilize o método float getPertinence(); do objeto FuzzySet para objet esse valor, exemplo:

FuzzySet* hot = new FuzzySet(30, 50, 50, 70);
...
... // Após a fuzzyficação com ->fuzzyfy();
...
float pertinenceOfHot = hot->getPertinence();

Ou saber se determinada regra foi ativada, utilize o método bool isFiredRule(int ruleId) do objeto Fuzzy.

FuzzyRule* fuzzyRule = new FuzzyRule(2, ifDistanceSmall, thenSpeedSlow);
...
... // Após a fuzzyficação com ->fuzzyfy();
...
bool wasTheRulleFired = fuzzy->isFiredRule(2);

Exemplo avançado: