Aulas 14 e 15 - Projeto

Objetivo

O objetivo destas aulas é fazer com que o aluno desenvolva um projeto individual utilizando a tecnologia de arquiteturas cognitivas, em uma aplicação de sua escolha. O aluno deve escolher um tema para desenvolver seu projeto e discutir a viabilidade do mesmo como válido para o curso, antes de começar suas atividades.

Tema

Em conversa com o professor, a proposta feita foi de gerar um controlador para o robô Khepera II, sendo que a arquitetura cognitiva escolhida para realizar este projeto foi a CLARION. Tendo em vista a dificuldade de acesso a um robô real Khepera II, escolhemos implementar o controlador para um simulador de ambiente e navegação do robô Khepera, o WSU KSuite 1.1.2.

Este simulador foi utilizado durante a minha iniciação científica e foi devidamente adaptado para suportar a simulação e treinamento de controladores autônomos através de algoritmos evolutivos. A tela principal do simulador é a seguinte:

Nesta tela temos todas as funcionalidades disponiveis, inclusive com diversos ambientes de simulação no lado direito da tela. É possivel adicionar obstáculos ("Wall") , Luz e outros atravravés do botão "Add", bem como o próprio robo Khepera, através do botão "Set" no painel superior.

Estrutura de Código e Relatório Técnico

O simulador é feito em JAVA, tendo seu código fonte original disponibilizado em diversos repositórios do github. O código pode ser compilado com Eclipse ou Nebeans, sendo que para o desenvolmento do projeto eu utilizei o Eclipse. A seguir apresento algumas classes principais do simulador:

KSMain: Classe principal para o início do aplicativo. A partir dela todo o Look And Fell do projeto é contruído.

WorldDrawManager: Classe responsável pelo desenho da interface do mundo e suas entidades para o usuário. 

RobotControllerDirector: Classe responsável pela ligação entre o mundo de simulação e o controlador do robô.

CurrentRobotState: Classe que guarda as informações sensoriais e de estado do robo durante a simulação.

RobotController: Classe abstrata que é a base de todos os controladores desenvolvidos para o simulador. Ela define todas as interfaces de interação com o RobotControllerDirector, o estado do robo e o mundo. Toda implementação de controlador deve estender esta classe.

ClarionController: Classe criada para este projeto que representa o controlador do robo controlado pela coginição da arquitetura Clarion. Para simplificar o load de controladores no simulador, as classes que implementam controladores ficam em um pacote separado chamado "controllers".

Como estudamos nas aulas anteirores, a arquitetura Clarion é implementada em C# e para que pudessemos tornar a intereoperação possível entre o JAVA e o C#, foi preciso implementar uma estrutura de comunicação via sockets. Esta implementação é mais simples e bem menos complexa que uma integração nativa utilizando JNI e C++ no Java.

A estrutura básica de operação do ciclo cognitivo do Clarion foi reaproveitada da aula 11, com alguns ajustes para simplificar a troca de mensagens via sockets e o fluxo de execução, diminuindo o numero de thread envolvidas entre as partes, sendo que a conexão é estabelecida assim que a solução C# é executada enquanto o ClarionController já está em execução no Java.

Basicamente, assim que o ClarionController é carregado no Java, ele abre um servidor para receber conexões da solução C#, por isso deve-se sempre iniciar a simulação com o ClarionController e só então em seguida rodar a solução C#. Por falta de tempo hábil não foi possivel fazer um mecanismo mais sofisticado de controle de conexão entre os dois projetos, sendo assim ambos tem a porta de conexão hardcoded e não possuem outro fluxo alternativo de conexão. 

O diagrama a seguir ilustra de forma simplificada o processo de controle do robo a cada ciclo de execução do simulador, ou seja como foi implementado o ciclo cognitivo.

A cada ciclo de simulação do mundo no simulador, o ClarionController tem seu método doWork() executado para que o controlador possa atuar sobre o robô naquele ciclo. Neste método doWork, fazemos a leitura dos sensores do robô (a principio apenas as informações dos sensores de distância estão disponíveis) e enviamos estes dados através do método sendData() da inner class ServerThread através do socket estabelecido com o Clarion no C#.  É importante notar que a atuação do controlador se restringe a determinar os valores de velocidade para as rodas direita e esquerda do robo. Não há sistema de coordenadas nem posicionamento, por isso não existem comandos tão alto nível quando GoTo() ou Rotate().

Já no C#, na classe principal Program, o aplicativo está esperando os dados no método listen(), assim que os recebe, os mesmos são enviados para o ClarionAgent, para que o ciclo de cognição do clarion seja executado através do método RunOneCognitionCycle(). Neste método é feito o Perceive da informação sensorial bem como todo o processo de cognição até que uma escolha de ação seja feita.

Como já reaproveitamos a solução da aula 11 para o controlador, decidimos manter o sistema baseado em regras para a cognição neste controlador, apenas ajustando os critérios para a ativação de cada regra, baseados nos valores recebidos pelos sensores do robo.

Apenas levando em conta duas regras básicas, uma pra rotacionar caso um obstáculo seja encontrado adiante e outra pra seguir em frente já foi possivel, através da experimentação dos parametros de distância do sensores, obter um controlador que efetua o desvio de obstáculos sem colisões, objetivo deste projeto.

A seguir apresentamos uma tela de simulação com o controlador com apenas uma regra, a de seguir em frente independente de obstáculos:

Os pontos vermelhos com um traço branco indicam uma colisão. Já as linhas coloridas representam o caminho executado pelo robo após cada colisão ( elas aparecem se o "Path display" estiver habilitado). Como podemos notar, sem tratar a regra de "WallAhead" o controlador apenas segue me linha reta, colidindo contra os obstáculos. O próprio Khepera rotaciona 180 graus quando sofre uma colisão, por isso o simulador também gera este comportamento automáticamente, fazendo com que o robo fique colidindo de uma lado a outro.

Agora levamos em conta uma regra não balanceada de "WallAhead" ou seja, com um valor arbitrário de distancia para a ativação desta regra, vejamos o comportamento:

Agora já obtivemos um comportamento distinto, com mudança na direção da trajetória (devido a atuação da regra "ROTATE CLOCKWISE"), mas ainda temos diversas colisões contra as paredes.

Trabalhamos agora para ajustar os parametros de distância e valores de velocidade para atuação sobre as rodas do robô Khepera, chegamos aos valores de distância de 100 para os sensores frontais do Khepera e de velocidade de 30 na roda esquerda e 0 na roda direita do robo para a rotação, vejamos o comportamento obtido:

O resultado obetido é justamento o esperado, de evitar as colisões com os obstáculos girando em direção horária e seguindo em linha reta sem obstáculos a frente. Podemos notar que mesmo com um ambiente bem mais complexo, com vários obstáculos espalhados pelo ambiente o robô é capaz de desviar e seguir sua trajetória retilinia. Testamos um caso clássico para ver o comportamento do robô, o caso do "beco".

Normalmente há um objetivo, como uma luz, atras do beco, que leva o robo a ficar preso dentro do mesmo. Por limitações tecnicas do simulador, os dados da luz ainda nao estao disponiveis para o controlador, por isso nao pudemos simular exatamente essa situação mas notamos claramente pela trajetória feita pelo robo, que mesmo com regra bastante simples como as de "WALL AHEAD" e "ROTATE CLOCKWISE" o robo já foi capaz de evitar a colisão com os obstáculos do beco e ainda foi além, produzindo um comportamento de "Wall follower" que o levou a alcançar a parte posterior do beco onde estara um possivel objetivo.

Esse simples experimento deixa claro o poder das arquiteturas cognitivas que estudamos nesta disciplinas, aplicadas aos mais diversos problemas entre os quais destacamos neste projeto e nas aulas a navegação de criaturas de forma autonoma em ambientes desconhecidos ou em busca de objetivos com os leaflets.

Como a implementação de toda a estrutura de comunicação e controle do projeto demanda tempo, algumas partes como o controle de conexão e até mesmo o formato da troca de mensagem foi simplificada ao máximo para tornar viável a execução desta tarefa. Esses pontos e a criação de mais regras para aprimorar o comportamento do controladore são fatores que poderiam se melhorados em versões futuras deste projeto ou por alunos de turmas futuras que gostariam de avançar com este desenvolvimento. 

Binários e Código Fonte:

Para executar o simulador basta extrair os arquivo a seguir e rodar o arquivo Simulador_Gustavo.jar. (Simulador.zip) ou então rodar através do eclipse ou netbeans partindo do código fonte.

Para executar o controlador do Clarion, pode-se executar através do Mono/Xamarin com o código fonte ou através dos binários gerados pelo mesmo, que podem ser encontrados a seguir. (Controlador_Clarion.zip)

O código fonte do projeto do simulador está aqui: FONTE_SIMULADOR (p/ eclipse).

O código fonte do projeto do controlador via arquitetura clarion está aquiu: FONTE_CONTROLADOR

Guia de Uso:

As telas a seguir apresentam um passo a passo básico para o uso do simulador JAVA com o controlador C#.

1. Rode o simulador JAVA através do JAR ou Eclipse/Netbeans.:

2. Selecione o botão  "Set" para posicionar o robo em algum ponto do mundo, dentro do cercado de obstáculos, clicando com o botão esquerdo do mouse no ponto desejado. Clique em "Set" novamente para soltar o botão.

3. Clique em "Run" para selecionar o controlador a ser utilizado nesta simulação, no popup selecione o "ClarionController".

4. Neste ponto o ClarionController já estará rodando e pronto para aceitar conexões através do socket. Devemos então rodar o controlador C# do projeto ClarionSocket, seja pelo arquivo binário ou através do Mono/Xamarin. 

5. Pronto! Assim que o controlador estiver rodando a conexão será estabeleciada com o Java e o robô passará a atuar no ambiente de simulação. Mensagens de log serão exibidas no console mostrando os dados recebidos do JAVA e enviados de volta. Para interromper a simulação basta fechar o aplicativo console e o simulador. Caso queira reiniciar toda a simulação, é só repetir estes passos.