Universidade do Minho

Conselho de Cursos de Engenharia Licenciatura em Engenharia Informtica

3Ano

Disciplina de Laboratrios de Informtica IV

Ano Lectivo de 2007/2008

Explorao da plataforma de programao leJOS para robs Lego MindStorms: Uma Abordagem Robtica Evolucionria

47109 Tiago Costa Oliveira 47119 Nlson Manuel Almeida Gonalves 47131 Joo Manuel Fernandes da Silva Ribeiro

Julho, 2008
i

Data de Recepo Responsvel Avaliao Observaes

Explorao da plataforma de programao leJOS para robs Lego MindStorms: Uma Abordagem Robtica Evolucionria

47109 Tiago Costa Oliveira 47119 Nlson Manuel Almeida Gonalves 47131 Joo Manuel Fernandes da Silva Ribeiro

Julho, 2008

ii

Resumo
O objectivo deste trabalho foi a explorao da plataforma leJOS que permite a programao dos robs LEGO MindStorms em JAVA (mais exactamente, num pequeno subconjunto de JAVA), assim como o uso da mesma numa abordagem robtica evolucionria, contudo acabamos tambm por testar a linguagem NXT-G e fizemos uma pequena comparao entre ambas, comparao essa onde conclumos que ambas as linguagens tm tanto pontos fortes como pontos fracos..

Quanto abordagem robtica evolucionria, usamos um modelo baseado em programao por comportamentos, no qual o rob deveria percorrer um circuito e no fim do percurso calcular o seu desempenho atravs de uma funo de fitness que tem em conta o tempo e a distncia gastos a percorrer esse mesmo circuito.

Concluindo conseguimos implementar, embora de forma algo rudimentar, um processo evolucionrio de aprendizagem para satisfazer o objectivo pretendido.

rea de Aplicao:

Plataformas de Programao NXT-G e leJOS. Robtica Evolucionria.

Palavras-Chave:

Lego MindStorm, NXT-G, leJOS, JAVA, robtica evolucionria,

gentipo, programao baseada em comportamentos, cromossomas.

iii

ndice
ndice 1. Introduo 1.1. Contextualizao 1.2. Apresentao do Caso de Estudo 1.3. Motivao e Objectivos 2. Implementao da Soluo 3. Concluses e Trabalho Futuro Anexos I. Programa Foward em Cdigo NXT-G II. Programa Foward em Cdigo JAVA III. Programa Rotate em Cdigo NXT-G IV. Programa Rotate em Cdigo JAVA V. Programa RandomMove em Cdigo NXT-G VI. Programa RandomMove em Cdigo JAVA VII. Programa KeepDistance em Cdigo NXT-G VIII. Programa KeepDistance em Cdigo JAVA IX. Programa LineFollow em Cdigo NXT-G X. Programa LineFollow em Cdigo JAVA XI. Classe FowardBehavior em Cdigo JAVA XII. Classe FindBestDirBehavior em Cdigo JAVA XIII. Classe EndDriveBehavior em Cdigo JAVA XIV. Classe Arbitrator3 em Cdigo JAVA XV. Classe RobotDrive em Cdigo JAVA XVI. Controlador do Rob a Partir do PC iv 1 1 3 5 6 8 11 12 13 14 15 16 17 18 19 21 22 24 25 27 28 30 33

iv

1. Introduo
1.1. Contextualizao
Como base para a elaborao deste trabalho usamos as plataformas de programao leJOS e NXT-G, ambas orientadas programao dos robs LEGO Mindstorms.

Lego MindStorms o resultado de uma parceria de mais de uma dcada entre o Media LAB do M.I.T e a LEGO e consiste num conjunto de peas lego tradicionais, sensores de toque, intensidade luminosa, som, distancia entre outros e um bloco programvel onde se encontra o processador.

O nome MindStorms foi inspirado no ttulo do livroMindStorms: Children, Computers, andPowerfullIdeas escrito porSeymourPapert, que foi um dos fundadores do M.I.T.

A primeira verso lego MindStorms foi lanada em 1998 e era conhecida por Robot InventionSystem(RIS), a verso actual chama-se MindStorms NXT (sucessora do

MindStormsRCX) e foi lanada em 2006.

Os robs LEGO MindStorms podem ser usados tanto para fins ldicos como para fins educacionais como por exemplo introduo robtica, automao, fsica, programao, etc.

leJOS um de vrios firmwares alternativos desenvolvidos pela comunidade entusiasta dos robs LEGO MindStorms para tirar proveito das capacidades oferecidas pelos mesmos e teve como principais contribuidores BrianBagnall, JurgenStuber, Paul Andrews e Jos Solrzano. O leJOS surgiu como uma ramificao do TinyVM, e consiste num firmware que permite correr uma maquina virtual de JAVA nos blocos RCX e NXT, ou seja, vai permitir o uso da linguagem JAVA no desenvolvimento de programas para robs. O leJOS pe ao dispor do utilizador vrias 1

bibliotecas que permitem o controlo de todos os sensores e motores do rob, assim como a programao baseada em comportamentos, entre outras funes de alto nvel.

NXT-G a linguagem visual de programao que vem por predefinio com os robs LEGO e muito simples e intuitiva para uso das funes bsicas do rob como o controlo dos motores ou leitura dos valores sensores, tornando-se por isso adequada para quem est a ter contacto pela primeira vez com os robs MindStorms e quer ver quais as suas potencialidades. fcil de usar devido ao seu interface grfico com menus que so bastante esclarecedores quanto s vrias opes disponveis, no entanto toda esta facilidade no impede a existncia de aspectos mais avanadas como o uso de variveis, implementao de ciclos com as respectivas condies de paragem, o uso de valores lgicos, a possibilidade do encadeamento de blocos de cdigo mais simples para obter blocos mais complexos, etc. portanto uma linguagem bastante completa que permite desenvolver tanto programas bsicos, como programas mais complexos.

Finda que est a contextualizao relativamente s plataformas usadas neste trabalho podemos passar a uma breve explicao acerca da Robtica Evolucionria, o que trata e em que consiste.

A possibilidade da evoluo de robs inteligentes atravs de processos evolucionrios surgiu pela primeira vez em 1984 pelo neurofisiologista Valentino Braitenberg quando este falou da possibilidade da criao de robs inteligentes a partir de processos evolucionrios no livro Vehicles: Experiments in Synthetic Psychology.

O conceito de robtica evolucionria apareceu em 1993 por CliffHarvey e Husbands na Universidade de Sussex. Em 1992/1993, duas equipas uma composta por Floreano e Mondada, a outra constituda por um grupo de investigadores da universidade de Sussex anunciaram as primeiras experincias de evoluo artificial com robs. O sucesso desta pesquisa gerou uma enorme srie de actividades pelo mundo fora na tentativa de explorar todo potencial deste novo conceito.

A ideia bsica por trs da robtica evolucionria a de aplicar o conceito de evoluo natural de Darwin aos robs, conceito esse no qual existe uma reproduo selectiva na qual apenas participam os seres mais aptos. Neste conceito de robtica evolucionria os robs so vistos como organismos artificiais e autnomos que desenvolvem as duas aptides apenas atravs 2

da interaco com o meio que os rodeia, sem qualquer tipo interveno humana. Da mesma maneira que nos seres vivos a informao gentica est codificada nos cromossomas, nos robs essa informao est codificada tambm sob a forma de cromossomas, no caso dos robs, designamos por cromossomas o conjunto de parmetros que controlam o comportamento do rob. Depois de termos uma populao de robs com diferentes cromossomas, a cada rob (fsico ou simulado) lhe permitido agir livremente, mas as suas aces so monitorizadas automaticamente por um mecanismo de controlo especfico que avalia a sua performance tendo em conta os critrios definidos pelo responsvel da experincia. Aos robs que obterem melhores performances -lhes permitido reproduzirem-se (sexuada/assexuadamente) atravs da gerao de copias dos seus gentipos com a adio de modificaes introduzidas por mutaes, combinaes ou duplicaes dos valores seus parmetros(ou operadores genticos). Este processo depois repetido durante vrias geraes at aparecer um indivduo que satisfaa os critrios de performance previamente considerados como aceitveis.

1.2. Apresentao do Caso de Estudo

Explorao da plataforma de programao leJOS para robs Lego MindStorms: uma abordagem Robtica Revolucionria.

No mbito de projectos de investigao em curso existem disponveis robs Lego MindStorms NXT. Pretende-se neste projecto explorar a plataforma Lejos que permite programar estes robs utilizando a linguagem Java.

O objectivo final a construo de uma aplicao, onde o rob seja capaz de evoluir o seu comportamento numa dada tarefa ao longo do tempo, apenas fornecendo feedback pelo seu desempenho e no programando explicitamente a sua resoluo.

Pretende-se neste trabalho a anlise da plataforma leJOS assim como implementao de conceitos de robtica evolucionria usando esta mesma plataforma como base.

A plataforma leJOS surge como ferramenta de trabalho no mbito deste projecto, tendo dois objectivos em vista, sendo o primeiro chegar concluso se vale a pena usar a plataforma leJOS em detrimento da linguagem NXT-G que a linguagem que vem por predefinio, o 3

segundo dos objectivos servir de suporte utilizao de conceitos tanto de robtica evolucionria como de programao baseada em comportamentos. Para a resoluo do primeiro objectivo, foi necessria a criao de alguns programas de diversos nveis de complexidade, uns mais simples, outros mais complexos, os programas foram desenvolvidos em cada uma das plataformas para depois podermos proceder comparao da complexidade obtida na criao dos mesmos. A concluso foi ento que para projectos de pequena

dimenso e baixo nvel de complexidade a linguagem NXT-G mais simples de usar que a linguagem JAVA, embora sejam ambas fceis de utilizar, contudo no caso de um projecto mais complexo acaba por ser mais fcil programar usando Java, isto porque a linguagem visual desenvolvida pela LEGO se torna demasiado complexa, em suma podemos concluir que a linguagem NXT-G a mais adequada resoluo de problemas simples, enquanto que JAVA mais indicada para a resoluo de problemas mais complexos. (O cdigo dos programas criados tendo em vista a comparao entre as plataformas pode ser visto nos anexos.)

A abordagem robtica evolucionria est presente neste trabalho na medida em que tanto conceitos de robtica evolucionria como conceitos de programao baseada em

comportamentos foram utilizados na programao do rob. Apesar da programao baseada em comportamentos no ser exactamente o mesmo que robtica evolucionria, ambas tm pontos em comum, tais como a importncia desempenhada pelo ambiente no qual decorrem as experincias. J o principal ponto de divergncia entre ambas que enquanto que na programao baseada em comportamentos a resoluo do problema obtida atravs de um processo de tentativa e erro no qual o operador modifica os comportamentos actuais do rob enquanto v a repercusso destas alteraes no comportamento global do mesmo, na programao baseada em robtica evolucionria o processo de tentativa e erro feito automaticamente atravs de um algoritmo de avaliao de resultados obtidos que funciona automaticamente, esse algoritmo faz uso de uma funo que mede o desempenho do rob tendo em conta os resultados pretendidos, funo essa a que iremos chamar funo de desempenho mas que tambm pode ser chamada de fitnessfunction. Outra das diferenas entre ambos os processos que enquanto que na aproximao robtica baseada no uso de comportamentos, a diviso de um comportamento do rob em comportamentos mais simples desempenhada de forma intuitiva pelo operador, na robtica evolucionria esta diviso no executada pelo operador, sim resultado de um processo de auto organizao.

A programao baseada em comportamentos baseia-se num pressuposto no qual os robs so munidos de um conjunto de comportamentos bsicos. reaco resultante da interaco desses comportamentos bsicos com o ambiente da experincia d-se o nome de comportamento global, o que ns fizemos foi ento usar esta caracterstica, ou seja, a existncia de comportamentos bsicos, e depois aplicamos um algoritmo de avaliao de 4

resultados (como o que existe em robtica evolucionria), em vez de fazermos a avaliao de resultados obtidos manualmente. por isto que no nosso trabalho se verifica o uso tanto de conceitos de robtica evolucionria como de conceitos de programao baseada em comportamentos.

1.3. Motivao e Objectivos

Sabemos que hoje em dia os robs e a inteligncia artificial so temas muito discutidos e o seu desenvolvimento e utilizao est a ganhar terreno rumo ao futuro e sendo a robtica evolucionria uma tcnica para automatizar a criao de robs autnomos, achamos que era bastante interessante descobrirmos um pouco mais acerca deste tema.

Quando se houve falar em Legos, somos levados ao nosso tempo de crianas em que juntvamos blocos para construir o que nos passava pela imaginao. Explorar o modelo mais avanado de rob programvel desta marca internacional, juntamente com a possibilidade de trabalhar aplicaes e programas relativos nossa rea de estudo tais como programao lejos baseada em Java uma oportunidade nica.

Explorar e descobrir muitos conceitos da robtica revolucionria e inteligncia artificial so tambm desafios que nos movem na realizao deste projecto.

Como base para a elaborao deste trabalho iremos explorar as plataformas de programao leJOS e NXT-G, ambas orientadas programao dos robs LEGO Mindstorms, utilizando exemplos e tratando problemas e tarefas iguais para ambos os tipos de programao.

2. Implementao da Soluo
Na implementao deste projecto foram usadas as ferramentas Lego MindStorms NXT, o IDE Eplipse com um plugin especfico para leJOS e o IDE NetBeans para criao de um ambiente em SWING para a aplicao.

Tal como j foi dito previamente, um dos objectivos do trabalho foi comparar as plataformas leJOS e LEGO MindStorms NXT-G. Para tal foram concebidos cinco programas na linguagem grfica da Lego, usando a ferramenta Lego MindStorms NXT e outros cinco desenvolvidos em java para correrem na mquina virtual disponibilizada pelo firmware leJOS, programas esses que so por ordem crescente de complexidade: Forward que programa que apenas consiste em fazer o rob andar em frente at encontrar um obstculo, Rotate que um programa que consiste em fazer o rob rodar sobre o seu prprio eixo at captar um rudo acima de um determinado nvel, Random_Move que consiste em fazer com que o rob tenha movimentos aleatrios at se deparar com um obstculo, Keep_Distance que faz com que o rob mantenha uma certa distncia (neste caso 35cm) de um objecto qualquer, isto , caso o objecto ande na direco oposta ao robot, este avana de modo a encurtar a distancia at 35cm, caso o objecto se mova na direco do rob este recua at atingir a distancia de 35cm do objecto, por ltimo temos o programa mais complexo que se chama Line_Follow e consiste em fazer com que o rob siga uma determinada linha preta no cho. Depois de termos implementado todos estes programas, atravs da anlise do cdigo (presente na seco anexos do relatrio) -nos possvel verificar que medida que aumenta a complexidade dos programas, a interpretao do cdigo dos programas em Java no se torna to complicada como a interpretao do cdigo dos mesmos programas em NXT-G, ou seja, JAVA a linguagem mais indicada para a programao destes robs, uma vez que para programas simples, fcil de usar (embora no tanto como a NXT-G), e para programas mais complexos no se torna muito confusa tal como a sua rival, a linguagem grfica desenvolvida pela LEGO.

A segunda parte do projecto foi implementada usando alguns conceitos de robtica evolucionria e a programao do rob foi feita segundo um modelo baseado em comportamentos. O modelo baseado em comportamentos que ns criamos para este caso em especfico, baseia-se em 3 comportamentos bsicos sendo eles: 6

Forwardbehavior (Anexo XI) que o comportamento permite andar em frente; EndDriveBehavior (Anexo XIII) que o comportamento que permite identificar o final de percurso e calcular o desempenho obtido pelo rob, tendo em conta o tempo demorado e a distncia percorrida; FindBestDirBehavior (Anexo XII) que o comportamento que permite identificar qual a melhor direco a tomar.

Estes trs comportamentos so depois codificados atravs do uso de quatrovariveis Drive Speed que controla a velocidade do rob em linha recta, RotatitionSpeed que controla a velocidade de rotao do robot, RotationAngle que controla o ngulo de rotao do rob em graus e Stop Margin que codifica a distncia de paragem perante um obstculo. O envio destas quatro variveis efectuado via bluetooth atravs de um PC com um programa tambm por ns desenvolvido (ver anexo XVI). Por uma questo de simplicidade o algoritmo evolucionrio (implementado do lado do PC) procede optimizao de cada um destes parmetros de cada vez at alcanarem o seu valor ptimo.

Depois de tomadas todas estas decises quanto maneira como iramos implementar os conceitos de robtica evolucionria, partimos para a produo de cdigo em JAVA (ver anexo XI).

3. Concluses e Trabalho Futuro

Neste relatrio encontra-se a maior parte da pesquisa efectuada por ns para uma melhor elaborao deste projecto de grupo, pesquisa essa que cobre vrios assuntos, desde a origem dos robs LEGO MindStorms passando pela historia de como surgiu o leJOS, at finalmente fazermos uma breve introduo Robtica Evolucionria e a programao baseada em comportamentos.

Relativamente ao que nos foi pedido, pensamos ter alcanado de forma satisfatria os objectivos a que nos propusemos de incio, contudo outro tipo de abordagem poderia ter sido utilizada, nomeadamente um tipo de evoluo mais sofisticado o que possvel alcanar sem alterar o software desenvolvido para o rob dado que este apenas recebe parmetros e devolve um valor relativo ao desempenho, ficando a evoluo dos parmetros a cargo de um qualquer software que possa efectuar uma ligao bluetooth ao rob.

Bibliografia
Bagnall, Brian Building Robots with Java Brains Variant Press, Canada, 2007

Floreano, Dario Nolfi, Stefano Evolutionary Robotics MIT Press, EUA, 2000

Referncias WWW
[01] http://mindstorms.lego.com Pgina do fabricante do rob MindStorm da Lego. Aqui podemos encontrar informao referente ao rob assim como projectos j realizados.

[02]

http://en.wikipedia.org/wiki/Lego_Mindstorms Pgina da conhecida Wikipdia com conceitos interessantes sobre os robs da Lego, MindStorms.

[03]

http://lejos.sourceforge.net/ Pgina principal do firmware leJOS que nos permite introduzir a programao JAVA para controlar o robot.

[04]

http://en.wikipedia.org/wiki/Evolutionary_robotics Pgina da Wikipdia que aborda o tema da Robtica Evolucionria.

[05]

http://lis.epfl.ch/index.html?content=resources/documentation/EvolutionaryRobo

tics/index.php Website sobre robtica revolucionria.

[06]

http://www.bartneck.de/2008/03/04/java-lego-nxt-eclipse-tutorial/ Pgina com Tutoriais de programao NXT-G.

[07]

http://www.ortop.org/NXT_Tutorial/ Pgina com Tutoriais de programao NXT-G.

[08]

http://lejos.sourceforge.net/tutorial/index.html Pgina com Tutoriais de programao lejos.

10

Anexos

11

I. Programa Foward em Cdigo NXT-G

Figura 1 - Ilustrao do Programa Foward em Cdigo NXT-G

12

II. Programa Foward em Cdigo JAVA

import lejos.nxt.Motor; import lejos.nxt.SensorPort; import lejos.nxt.Sound; import lejos.nxt.UltrasonicSensor;

public class Forward {

public static void main(String[] args) throws Exception { UltrasonicSensor us = new UltrasonicSensor(SensorPort.S3);

for(int i = 0; i < 3; i++){ Sound.beep(); Thread.sleep(700); }

Motor.A.setPower(75); Motor.C.setPower(75);

while(us.getDistance() > 50){ Motor.A.forward(); Motor.C.forward(); }

Motor.A.stop(); Motor.C.stop(); }

13

III. Programa Rotate em Cdigo NXT-G

Figura 2 - Ilustrao do Programa Foward em Cdigo NXT-G

14

IV. Programa Rotate em Cdigo JAVA

import lejos.nxt.Motor; import lejos.nxt.SensorPort; import lejos.nxt.Sound; import lejos.nxt.SoundSensor;

public class Rotate {

public static void main(String[] args) throws Exception { SoundSensor ss = new SoundSensor(SensorPort.S4);

for(int i = 0; i < 3; i++){ Sound.beep(); Thread.sleep(700); }

Motor.A.setPower(75); Motor.C.setPower(75);

while(ss.readValue() < 50){ Motor.A.forward(); Motor.C.backward(); }

Motor.A.stop(); Motor.C.stop(); }

15

V. Programa RandomMove em Cdigo NXT-G

Figura 3 - Ilustrao do Programa Foward em Cdigo NXT-G

16

VI. Programa RandomMove em Cdigo JAVA

import lejos.nxt.Motor; import lejos.nxt.SensorPort; import lejos.nxt.Sound; import lejos.nxt.UltrasonicSensor;

public class RandomMove {

public static void main(String[] args) throws Exception { UltrasonicSensor us = new UltrasonicSensor(SensorPort.S3);

for(int i = 0; i < 3; i++){ Sound.beep(); Thread.sleep(700); }

Motor.A.setSpeed(0); Motor.C.setSpeed(0);

Motor.A.forward(); Motor.C.forward();

while(us.getDistance() > 50){ Motor.A.setSpeed(200 + (int) (Math.random()*400)); Motor.C.setSpeed(200 + (int) (Math.random()*400));

Thread.sleep(500); }

Motor.A.flt(); Motor.C.flt(); } 17

VII. Programa KeepDistance em Cdigo NXT-G

Figura 4 - Ilustrao do Programa Foward em Cdigo NXT-G

18

VIII. Programa KeepDistance em Cdigo JAVA

import lejos.nxt.Button; import lejos.nxt.LCD; import lejos.nxt.Motor; import lejos.nxt.SensorPort; import lejos.nxt.Sound; import lejos.nxt.UltrasonicSensor;

public class keepDistance {

public static void main(String[] args) throws Exception { UltrasonicSensor us = new UltrasonicSensor(SensorPort.S3); int distance;

for(int i = 0; i < 3; i++){ Sound.beep(); Thread.sleep(700); }

Motor.A.setSpeed(500); Motor.C.setSpeed(500);

while(Button.readButtons() == 0){

us.ping(); Thread.sleep(20); distance = us.getDistance();

LCD.clear(); LCD.drawInt(Motor.A.getActualSpeed(), 0, 0); LCD.drawInt(distance, 0, 1); LCD.refresh(); (continua na pgina seguinte) 19

if(40 < distance && distance < 80){ while(35 < distance && distance < 85){ Motor.A.forward(); Motor.C.forward();

LCD.clear(); LCD.drawInt(Motor.A.getActualSpeed(), 0, 0); LCD.drawInt(distance, 0, 1);

us.ping(); Thread.sleep(20); distance = us.getDistance(); LCD.refresh(); }

Motor.A.stop(); Motor.C.stop(); }

us.ping(); Thread.sleep(20); distance = us.getDistance();

if(distance < 30){ while(distance < 35){

Motor.A.backward(); Motor.C.backward();

LCD.clear(); LCD.drawInt(Motor.A.getActualSpeed(), 0, 0); LCD.drawInt(distance, 0, 1); LCD.refresh();

us.ping(); Thread.sleep(20); distance = us.getDistance(); }

Motor.A.stop(); Motor.C.stop(); } } } } 20

IX. Programa LineFollow em Cdigo NXT-G

Figura 5 - Ilustrao do Programa Foward em Cdigo NXT-G

21

X. Programa LineFollow em Cdigo JAVA

import lejos.nxt.Button; import lejos.nxt.LightSensor; import lejos.nxt.Motor; import lejos.nxt.SensorPort; import lejos.nxt.Sound;

public class LineFollow {

public static void main(String[] args) throws Exception { LightSensor ls = new LightSensor(SensorPort.S1);

for(int i = 0; i < 3; i++){ Sound.beep(); Thread.sleep(700); }

while(Button.readButtons() == 0){

Motor.A.setPower(50); Motor.C.setPower(50); while(ls.readValue() < 35){ Motor.A.forward(); Motor.C.forward(); }

Motor.A.stop(); Motor.C.stop();

if(ls.readValue() > 35){ Motor.A.setPower(20); Motor.C.setPower(20); 22 Motor.A.resetTachoCount(); Motor.C.resetTachoCount()

Thread.sleep(200);

while(Motor.C.getTachoCount() < 90 && ls.readValue() > 35){ Motor.A.backward(); Motor.C.forward(); } Motor.A.stop(); Motor.C.stop(); }

if(ls.readValue() > 35){ Motor.A.setPower(20); Motor.C.setPower(20);

Motor.A.resetTachoCount(); Motor.C.resetTachoCount();

Thread.sleep(200); while(Motor.A.getTachoCount() < 180 && ls.readValue() > 35){ Motor.A.forward(); Motor.C.backward(); } Motor.A.stop(); Motor.C.stop(); }

if(ls.readValue() > 35){ Motor.A.setPower(20); Motor.C.setPower(20);

Motor.A.resetTachoCount(); Motor.C.resetTachoCount();

Thread.sleep(200); while(Motor.C.getTachoCount() < 90 && ls.readValue() > 35){ Motor.A.backward(); Motor.C.forward(); } Motor.A.stop(); Motor.C.stop(); } } } } 23

XI. Classe FowardBehavior em Cdigo JAVA

package li4v4;

import lejos.navigation.Pilot; import lejos.subsumption.Behavior;

public class ForwardBehavior implements Behavior { private Pilot pilot; int driveSpeed;

public ForwardBehavior(Pilot pilot, int driveSpeed){ this.pilot = pilot; this.driveSpeed = driveSpeed; }

public boolean takeControl() { return this.pilot.getSpeed() > 0; }

public void suppress() { this.pilot.stop(); }

public void action() { this.pilot.setSpeed(this.driveSpeed); this.pilot.forward(); }

24

XII. Classe FindBestDirBehavior em Cdigo JAVA

package li4v4;

import lejos.navigation.Pilot; import lejos.nxt.UltrasonicSensor; import lejos.subsumption.Behavior;

public class FindBestDirBehavior implements Behavior { private Pilot pilot; private UltrasonicSensor ultrasonicSensor; private int stopMargin; private int rotationSpeed; private int rotationAngle;

public

FindBestDirBehavior(Pilot

pilot,

UltrasonicSensor

ultrasonicSensor,

int

stopMargin, int rotationSpeed, int rotationAngle){ this.pilot = pilot; this.ultrasonicSensor = ultrasonicSensor; this.stopMargin = stopMargin; this.rotationSpeed = rotationSpeed; this.rotationAngle = rotationAngle; }

25

private int getDistance(){ this.ultrasonicSensor.ping(); try{ Thread.sleep(20); }catch(Exception e){ /*nothing to do*/ } return this.ultrasonicSensor.getDistance(); } public boolean takeControl() { return this.getDistance() < this.stopMargin && this.pilot.getSpeed() > 0; } public void suppress() { this.pilot.stop(); }

public void action() { int bestAngle = -Math.round(this.rotationAngle/2); int bestDistance = 0; int distance; int initRotationCount; this.pilot.setSpeed(this.rotationSpeed); this.pilot.rotate(-Math.round(this.rotationAngle/2)); initRotationCount = this.pilot.getAngle(); this.pilot.rotate(this.rotationAngle, true); //return immediately //wait until rotation is complete

while(this.pilot.isMoving()){ //rotation monitoring distance = this.getDistance();

if(distance > bestDistance && distance < 255){ bestAngle = initRotationCount - this.pilot.getAngle(); bestDistance = distance; } } this.pilot.rotate(-this.rotationAngle - bestAngle); }

} 26

XIII. Classe EndDriveBehavior em Cdigo JAVA

package li4v4;

import lejos.navigation.Pilot; import lejos.nxt.LightSensor; import lejos.subsumption.Behavior;

public class EndDriveBehavior implements Behavior { Pilot pilot; LightSensor lightSensor; float startTime;

public EndDriveBehavior(Pilot pilot, LightSensor lightSensor, float startTime){ this.pilot = pilot; this.lightSensor = lightSensor; this.startTime = startTime; }

public boolean takeControl() { return (lightSensor.readValue() < 28 && this.pilot.getSpeed() > 0) || (System.currentTimeMillis() - startTime > 120000); }

public void suppress() { /*nothing to do*/ }

public void action() { this.pilot.setSpeed(0);

} }

27

XIV. Classe Arbitrator3 em Cdigo JAVA

package li4v4;

import lejos.subsumption.Behavior;

/** * @see Behavior * @author <a href="mailto:tiago.co@gmail.com">Tiago Oliveira</a> * @version 1 01-06-2008 */

public class Arbitrator3 { private final int NONE = -1; private Behavior[] behaviorList; private boolean returnWhenInactive;

/** * @param behaviorList an array of Behavior objects. * @param returnWhenInactive if <B>true</B>, the <B>start()</B> method return when no Behavior is active. */ public Arbitrator3(Behavior[] behaviorList, boolean returnWhenInactive){ this.behaviorList = behaviorList; this.returnWhenInactive = returnWhenInactive; }

28

/** * Same as Arbitrator3(behaviorList, true). * @param behaviorList An array of Behavior objects. */ public Arbitrator3(Behavior[] behaviorList){ this(behaviorList, true); }

public void start(){ int currentBehavior = this.NONE; int maxPriority = this.behaviorList.length - 1; int highestActive;

do{ highestActive = this.NONE;

/*FIND HIGHEST PRIORITY ACTIVE BEHAVIOR*/ for(int i = maxPriority; i >= 0; i--){ if(behaviorList[i].takeControl()){ highestActive = i; break; } }

if(currentBehavior != highestActive && currentBehavior != this.NONE){ /*SUPRESS CURRENT BEHAVIOR*/ behaviorList[currentBehavior].suppress(); }

if(highestActive != this.NONE){ /*EXECUTE HIGHEST PRIORITY ACTIVE BEHAVIOR*/ behaviorList[highestActive].action(); }

/*UPDATE CURRENT BEHAVIOR*/ currentBehavior = highestActive;

} while(currentBehavior != this.NONE || !returnWhenInactive); } }

29

/*bluetooth connection*/ BTConnection btc; /*data input stream for bluetooth*/ DataInputStream is; /*data output stream for bluetooth*/ DataOutputStream os;

/*drive control*/ Pilot RIGHT_MOTOR); /*distance reading*/ UltrasonicSensor ultrasonicSensor = new UltrasonicSensor(SensorPort.S3); /*end-line detection*/ LightSensor lightSensor = new LightSensor(SensorPort.S1); pilot = new Pilot(WHEEL_DIAMETER, TRACK_WIDTH, LEFT_MOTOR,

Behavior forwardBehavior; Behavior shortDistanceBehavior; Behavior endDriveBehavior; Behavior[] behaviorList = new Behavior[3]; Arbitrator3 arbitrator; try{ Thread.sleep(20); }catch(Exception e){ /*nothing to do*/ } LCD.clear(); LCD.drawString("waiting", 0, 0); LCD.drawString("BT connection..", 0, 1); LCD.refresh(); /*wait for bluetooth connection*/ btc = Bluetooth.waitForConnection(); LCD.clear(); is = btc.openDataInputStream(); os = btc.openDataOutputStream();

while(!btError && ! endEvolution){ LCD.clear(); LCD.drawString("waiting values..", 0, 0); LCD.refresh(); if(is.available() >= 16){

31

try{ driveSpeed = is.readInt(); rotationSpeed = is.readInt(); rotationAngle = is.readInt(); stopMargin = is.readInt(); LCD.clear(); }catch(Exception e){ btError = true; } if(!btError){ for(int i = 0; i < 3; i++){ Sound.beep(); Thread.sleep(700); } startTime = (float) System.currentTimeMillis(); forwardBehavior = new ForwardBehavior(pilot, driveSpeed); shortDistanceBehavior ultrasonicSensor, stopMargin, rotationSpeed, rotationAngle); endDriveBehavior = new EndDriveBehavior(pilot, lightSensor, startTime); behaviorList[0] = forwardBehavior; behaviorList[1] = shortDistanceBehavior; behaviorList[2] = endDriveBehavior; arbitrator = new Arbitrator3(behaviorList); pilot.resetTachoCount(); arbitrator.start(); /*wait arbitrator to return*/ float distance = pilot.getTravelDistance(); float startTime)/1000; float fitness = 1000/(distance + driveTime); os.writeFloat(fitness); os.flush(); } } else if(is.available() == 1){ Sound.buzz(); endEvolution = true; } } btc.close(); } 32 driveTime = ((float) System.currentTimeMillis() = new FindBestDirBehavior(pilot,

XVI. Controlador do Rob a Partir do PC

33

34