Agentes e Inteligência Artificial
Distribuída
Sistema Multi-Agente para automação
inteligente de uma casa
Dezembro de 2006
Trabalho realizado por:
André Lessa (ei02017) - [email protected]
Índice
1. Objectivo.......................................................................... 3
2. Descrição.......................................................................... 4
2.1. Funcionalidades ......................................................... 4
2.2. Estrutura do Programa................................................ 4
2.2.1. Módulo Agente Central........................................ 5
2.2.2. Módulos de Decisão............................................. 5
2.2.3. Módulos Actuadores ............................................ 7
2.2.4. Regras em JESS ................................................... 7
2.3. Detalhes de Implementação ....................................... 8
2.4. Ambiente de Desenvolvimento .................................. 8
3. Conclusão....................................................................... 10
4. Melhoramentos............................................................... 11
5. Bibliografia .................................................................... 12
6. Apêndices....................................................................... 13
6.1. Manual do Utilizador ............................................... 13
6.2. Exemplo de uma Execução ...................................... 13
2
1. Objectivo
Este trabalho tem como objectivo a implementação de um sistema multi-agente
que permita simular a gestão automática de recursos habitacionais, como aquecimento e
iluminação, definindo para isso regras de actuação para a manipulação de diferentes
dispositivos. Assim, haverá agentes distribuídos fisicamente que representam
dispositivos (lâmpadas, persianas, janelas, luzes) e que podem receber comandos com
vista à alteração do seu estado. Outros funcionam como sensores (de iluminação, de
temperatura), permitindo ao sistema obter informações sobre o ambiente.
O sistema possui uma unidade central que recebe informação e que decide, com
base em regras predefinidas, acções a executar, enviando-as para os agentes actuadores
correspondentes.
3
2. Descrição
2.1. Funcionalidades
Este projecto encontra-se dividido em duas componentes de implementação.
Uma consiste na implementação dos agentes em JADE e a outra das regras em JESS. O
sistema possui uma unidade central que recebe informação e que decide, com base em
regras predefinidas, acções a executar, enviando-as para os agentes actuadores
correspondentes. São definidos inicialmente os valores de número de pessoas,
temperatura exterior, temperatura interior, luminosidade exterior, luminosidade interior,
bem como os valores que os utilizadores querem para a temperatura e luminosidade.
2.2. Estrutura do Programa
O projecto encontra-se dividido em 4 módulos essenciais:
•
Módulo Central;
•
Módulo de Decisão (temperatura e luminosidade);
•
Módulo Actuador (um para cada agente actuador);
•
Regras definidas em JESS.
4
Módulo de Decisão
Luminosidade
Módulo Actuador
Lâmpadas
Módulo Actuador
Persianas
Módulo
Central
Regras em JESS
Módulo Actuador
Janelas
Módulo de Decisão
Temperatura
Módulo Actuador
Ar Condicionado
2.2.1. Módulo Agente Central
Este Módulo recebe informação das decisões tomadas pelos Módulos de
Decisão, de luminosidade e temperatura respectivamente.
2.2.2. Módulos de Decisão
Estes Módulos recebem os valores iniciais, enviam-nos para o ficheiro em JESS
e recebem a decisão tomada. Posteriormente enviam esta decisão tanto para o Módulo
Central, bem como a cada Módulo Actuador.
2.2.2.1. Módulo Temperatura
Função mais relevante, responsável por enviar os valores para o JESS e receber
a decisão, enviando-a também aos Agentes Actuadores:
5
void temperatura(String template, String temp_in, String temp_out,
String temp_user, String ac, String janelas, String mov)
Variáveis, tal como definidas no “template” do ficheiro JESS:
ƒ
String template – neste caso vai receber “temperatura”;
ƒ
String temp_in – valor para a temperatura interior;
ƒ
String temp_out – valor para a temperatura exterior;
ƒ
String temp_user – valor para a temperatura desejada;
ƒ
String ac – estado do ar condicionado;
ƒ
String janelas – estados das janelas;
ƒ
String mov – existe ou não movimento.
Decisões Tomadas:
Esta função irá receber do JESS os novos estados do ar condicionado e janelas,
enviando-os para os Agentes respectivos e Módulo Central.
2.2.2.2. Módulo Luminosidade
Função mais relevante, responsável por enviar os valores para o JESS e receber
a decisão, enviando-a também aos Agentes Actuadores:
void luminosidade(String template, String luz_in, String luz_out,
String luz_user, String persianas, String lampadas, String mov)
Variáveis, tal como definidas no “template” do ficheiro JESS:
ƒ
String template – neste caso vai receber “luminosidade”;
ƒ
String luz_in – valor para a luz interior;
6
ƒ
String luz_out – valor para a luz exterior;
ƒ
String luz_user – valor para a luminosidade desejada;
ƒ
String persianas – estado das persianas;
ƒ
String lampadas – estados das lâmpadas;
ƒ
String mov – existe ou não movimento.
Decisões Tomadas:
Esta função irá receber do JESS os novos estados das persianas e lâmpadas,
enviando-os para os Agentes respectivos e Módulo Central.
2.2.3. Módulos Actuadores
Estes Agentes recebem a decisão vinda dos Módulos de Decisão.
Foram implementados os seguintes Agentes Actuadores:
ƒ
Ar Condicionado – recebe a nova temperatura;
ƒ
Janelas – recebe o novo estado (abertas, fechadas)
ƒ
Persianas – recebe o novo estado (abertas, entre-abertas, fechadas)
ƒ
Lâmpadas – recebe o novo estado (ligadas, desligadas)
2.2.4. Regras em JESS
Foram definidas regras em JESS para a temperatura e luminosidade. As regras
prevêem todos os casos possíveis de luminosidade e temperatura interior, exterior e
desejada pelo utilizador, bem como a existência ou não de pessoas dentro da casa. Neste
último caso, as regras devolvem o melhor caso com poupança de energia. Por exemplo
7
se a luz exterior for abundante ele abre as persianas mas nunca irá acender as lâmpadas
se não tiver ninguém em casa.
Para a luminosidade são devolvidos os novos estados das lâmpadas e persianas,
e para a temperatura, os novos estados do ar condicionado e janelas.
2.3. Detalhes de Implementação
A comunicação entre os Agentes foi implementada usando unicamente a
performativa INFORM.
Para facilitar a comunicação e definição de regras em JESS, foi utilizada uma
escala numérica, que posteriormente seria traduzida desta forma:
ƒ
Temperaturas: graus centígrados;
ƒ
Luminosidade: 0, 1 e 2 que corresponde a nenhuma, média e alta,
respectivamente;
ƒ
Janelas: 0 e 1 que corresponde a abertas e fechadas, respectivamente;
ƒ
Persianas: 0, 1 e 2 correspondendo a abertas, entre-abertas, fechadas,
respectivamente;
ƒ
Ar Condicionado: graus centígrados;
ƒ
Lâmpadas: 0 para desligadas e 1 para ligadas.
2.4. Ambiente de Desenvolvimento
O trabalho foi realizado numa máquina com as seguintes características:
Processador: ~2.53GHz
Memória: 1.00GB
8
O sistema operativo utilizado foi o Windows XP Professional Edition.
Foi também utilizada a versão de Java jdk1.5.0_10, a versão 3.4.1 de JADE e a
versão 7.0 de JESS. O desenvolvimento do projecto foi efectuado no software Eclipse
SDK 3.2.1.
9
3. Conclusão
Este trabalho revela-se muito interessante uma vez que sendo uma simulação de
uma situação real e pertinente, permite estudar como seria eficaz a o controlo inteligente
e automatizado de uma casa, sendo a domótica uma área em bastante desenvolvimento e
expansão.
A utilização dos agentes permite que seja implementado um sistema distribuído
mostrando o seu comportamento e interacções. A utilização do JADE (Java Agent
Development Framework) simplifica a implementação de um sistema multi-agente
através de um middleware que opera com especificações FIPA e possui um conjunto de
ferramentas de debugging. Os agentes podem desta forma ser distribuídos por máquinas
e controlados remotamente.
JESS consiste num motor de regras escrito totalmente para Java. Ao utilizarmos
esta plataforma podemos criar software em Java com a capacidade de “racionalizar”,
utilizando a base de conhecimento que introduzimos sob a forma de regras declarativas.
A plataforma JESS utiliza uma versão optimizada do algoritmo Rete para execução de
regras. Rete é um mecanismo bastante eficiente na resolução do problema de atribuição
“muitos para muitos”.
A plataforma JESS apresenta-se assim como ideal para a definição das regras
necessárias à domótica sobre a qual se baseia este projecto.
10
4. Melhoramentos
Seria possível uma série de melhoramentos a este projecto. Eu considero que o
mesmo não ficou concluído, faltando uma Interface Gráfica e uma melhor comunicação
entre os Agentes. Também poderiam ser implementados uma série de novos Agentes,
tornando este projecto mais complexo.
Tal não foi possível, ficando este grupo de trabalho, reduzido a metade dos
elementos, o que afectou em grande escala o bom desenvolvimento do projecto.
11
5. Bibliografia
•
Site da disciplina de AIAD
http://paginas.fe.up.pt/~eol/AIAD/aiad0607.html
•
Site da Plataforma JADE
http://jade.tilab.com/
•
Site do Eclipse
http://www.eclipse.org/
•
Documentação sob a plataforma JADE
http://qos.tecnolink.com.br/doc/Jade.htm
•
Tutoriais sobre JADE
http://www.iro.umontreal.ca/~vaucher/Agents/Jade/JadePrimer.html
•
Site da Plataforma JESS
http://herzberg.ca.sandia.gov/
12
6. Apêndices
6.1. Manual do Utilizador
Correr os executáveis:
¾ run.bat
¾ run2.bat
Ou numa janelas de comandos:
¾ java jade.Boot –gui
¾ java jade.Boot -container central:Central temperatura:Temp
luz:Luz
arcondicionado:ArCondicionado
lampadas:Lampadas persianas:Persianas
6.2. Exemplo de uma Execução
Execução do ficheiro run.bat. Este ficheiro inicializa o JADE.
13
janelas:Janelas
De seguida executa-se o ficheiro run2.bat:
Os valores de entrada para obter estes resultados foram os seguintes:
ƒ
Pessoas: 1
ƒ
Temperatura Interior: 10º
ƒ
Temperatura Exterior: 20º
ƒ
Temperatura Desejada: 22º
ƒ
Luminosidade Interior: 1 (média)
ƒ
Luminosidade Exterior: 1 (média)
ƒ
Luminosidade Desejada: 2 (alta)
14