Agentes Inteligentes 2011

jueves, 27 de octubre de 2011

Agentes Reflexivos - 3 RODEAR UN OBJETO

OBJETIVO
Programar el robot para que utilizando el sensor de toque pueda encontrar y rodear un
objeto siguiendo su contorno. El objeto puede tener cualquier forma (rectangular como una caja o cilíndrica como un bote, el objeto será suficientemente pesado como para que el robot no lo mueva, dentro de límites razonables. El objeto podrá estar en cualquier posición con respecto del robot dentro de un área de 15 m².


import lejos.nxt.*;
import lejos.nxt.comm.RConsole;
import lejos.robotics.navigation.*;
import lejos.robotics.subsumption.*;

public class GoAround{ 

 public static void main(String[] args){
  TachoPilot pilot = new TachoPilot(5.6f, 11.25f, Motor.B, Motor.C);
  TouchSensor touch = new TouchSensor(SensorPort.S3);
  UltrasonicSensor ultrasonic = new UltrasonicSensor(SensorPort.S1);

  Behavior goForward = new GoForward(pilot);
  Behavior hitObject = new HitObject(pilot, touch, ultrasonic);

  Behavior [] behaviorArray = {goForward, hitObject};
  Arbitrator arbitrator = new Arbitrator(behaviorArray);

  LCD.drawString("GoAround", 2, 2);
  Button.waitForPress();
  arbitrator.start();
 }

}
import lejos.nxt.LCD;
import lejos.robotics.subsumption.*;
import lejos.robotics.navigation.*;

public class GoForward implements Behavior{

 private Pilot pilot;

 public GoForward(Pilot pilot){
  this.pilot = pilot;
 }

 public boolean takeControl(){
  LCD.clear();
  LCD.drawString("GoForward", 2, 2);
  return true;
 }

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

 public void action(){
  pilot.forward();
 }

}

import lejos.nxt.*;
import lejos.robotics.subsumption.*;
import lejos.robotics.navigation.*;


public class HitObject implements Behavior, SensorPortListener{
 private TachoPilot pilot;
 private TouchSensor touch;
 private UltrasonicSensor ultrasonic;
 private boolean hit;

 private int backoff;
 private int rotationAngle;
 private int distance;
 private int lastDistance;
 private int distanceDifference;

 private int veryCloseLeft;
 private int slightlyCloseLeft;
 private int notCloseLeft;
 private int slightlyFarRight;
 private int veryFarRight;

 private int basePowerLeft;
 private int basePowerRight;

 private Motor rightMotor;
 private Motor leftMotor;

 public HitObject(TachoPilot pilot, TouchSensor touch, UltrasonicSensor ultrasonic){
  this.pilot = pilot;
  this.touch = touch;
  this.ultrasonic = ultrasonic;

  hit = false;
  SensorPort.S3.addSensorPortListener(this);

  backoff = 5;
  rotationAngle = -90;
  distance = 0;
  lastDistance = 0;

  veryCloseLeft = 20;
  slightlyCloseLeft = 25;
  notCloseLeft = 30;

  slightlyFarRight = 35;
  veryFarRight = 40;

  basePowerLeft = 100;
  basePowerRight = 99;

  rightMotor = (Motor)pilot.getRight();
  leftMotor = (Motor)pilot.getLeft();
 }

 public void stateChanged(SensorPort port, int oldValue, int newValue){
  if(touch.isPressed()){
   hit = true;
  }
 }

 public boolean takeControl(){
  if(hit){
   LCD.clear();
   LCD.drawString("HitObject", 2, 2);
   hit = false;
   return true;
  }
  else{
   return false;
  }
 }

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

 public void action(){
  pilot.stop();
  pilot.travel(-backoff);
  pilot.rotate(rotationAngle);

  while(true){
   lastDistance = distance;
   distance = ultrasonic.getDistance();
   distanceDifference = lastDistance - distance;

   if(distance <= notCloseLeft){
    if(distance <= veryCloseLeft){
     rightMotor.setPower(basePowerRight);
     rightMotor.backward();
     leftMotor.setPower(basePowerRight);
     leftMotor.forward();
    }
    else if(distance <= slightlyCloseLeft){
     rightMotor.setPower(0);
     rightMotor.stop();
     leftMotor.setPower(basePowerLeft);
     leftMotor.forward();
    }
    else if(distance <= notCloseLeft){
     leftMotor.setPower(basePowerLeft);
     leftMotor.forward();
     rightMotor.setPower(0);
     rightMotor.flt();
    }
   }
   else{
    if(distance >= slightlyFarRight){
     if(distanceDifference < 2){
      leftMotor.setPower(0);
      leftMotor.stop();
      rightMotor.setPower(basePowerRight);
      rightMotor.forward();
     }
    }
    else if(distance >= veryFarRight){
     leftMotor.setPower(basePowerLeft/2);
     leftMotor.forward();
     rightMotor.setPower(basePowerLeft);
     rightMotor.forward();
    }
   }

   try {
    Thread.sleep(30);
   }
   catch(InterruptedException e){

   }

  }

 }

}

Agentes Reflexivos - 5 HUIR DE LA LUZ (ROBOT ESPÍA O CUCARACHA ARTIFICIAL)

OBJETIVO
Programar el robot para que emule el comportamiento de un robot espía. Este robot utiliza sus sensores ultrasónicos para moverse en una habitación oscura. Si la luz se enciende quiere decir que alguien entra a la habitación y debe esconderse en un lugar oscuro (debajo de algún mueble en un rincón). OJO. Para fines de esta práctica, el robot debe correr a un rincón oscuro, no solamente protegerse de la luz.


import lejos.nxt.*;
import lejos.robotics.subsumption.*;
import lejos.robotics.navigation.*;

public class Hide {

 public static void main (String[] aArg) throws Exception {
  TachoPilot pilot = new TachoPilot(5.6f, 16.0f, Motor.B, Motor.C);
  LightSensor light = new LightSensor(SensorPort.S3);
  UltrasonicSensor distance =new UltrasonicSensor(SensorPort.S1); 
  
  pilot.setTurnSpeed(300);
  
  
  
  Behavior getBackToShadow = new GetBackToShadow(pilot, light);
  //Behavior goForward = new GoForward(pilot, light);
  Behavior findAWall = new FindAWall(pilot,distance);

  //Behavior [] behaviorArray = {getBackToLine, goForward, findAWall};
  Behavior [] behaviorArray = {getBackToShadow, findAWall};
  Arbitrator arbitrator = new Arbitrator(behaviorArray);
  LCD.drawString("Hide", 2, 2);
  Button.waitForPress();
  arbitrator.start();
  
 }
}

import lejos.nxt.*;
import lejos.robotics.subsumption.*;
import lejos.robotics.navigation.*;
 
public class GetBackToShadow implements Behavior, SensorPortListener{
 
 private Pilot pilot;
 private LightSensor light;
 private int sweep;
 private boolean suppress;
 private boolean inLight;

 public GetBackToShadow(Pilot pilot, LightSensor light){
  this.pilot = pilot;
  this.light = light;
  suppress = false;
  inLight = false;
  SensorPort.S3.addSensorPortListener(this);
 }

 public void stateChanged(SensorPort port, int oldValue, int newValue){
  if(light.readValue() > 20){
   inLight = true;
  }
 }

 public boolean takeControl(){
  if(inLight){
   LCD.clear();
   LCD.drawString("GetBackToShadow", 2, 2);
   inLight = false;
   return true;
  }
  else {
   return false;
  }
 }

 public void suppress(){
  do{
   pilot.stop();
  }while(light.readValue() < 20);
  suppress = true;
 }

 public void action(){
 
  while(!suppress){
   int prev=light.readValue();
   
   if(prev>20){
    pilot.travel(20);
    if(prev < light.readvalue())< div="">    {
     pilot.rotate(90);
    }
   }
   
   while(!suppress && pilot.isMoving()){
    Thread.yield();
   }
   
  }
  suppress = false;
 }
 
}
light.readvalue())

import lejos.nxt.*;
import lejos.robotics.subsumption.*;
import lejos.robotics.navigation.*;
 
public class FindAWall implements Behavior, SensorPortListener{
 
 private Pilot pilot;
 private UltrasonicSensor distance;
 private int sweep;
 private boolean suppress;
 private boolean findWall;

 public FindAWall(Pilot pilot, UltrasonicSensor distance){
  this.pilot = pilot;
  this.distance = distance;
  suppress = false;
  findWall = false;
  SensorPort.S3.addSensorPortListener(this);
 }

 public void stateChanged(SensorPort port, int oldValue, int newValue){
  if(distance.getDistance() < 20){
   findWall = true;
  }
 }

 public boolean takeControl(){
  if(findWall){
   LCD.clear();
   LCD.drawString("FindAWall", 2, 2);
   findWall = false;
   return true;
  }
  else {
   return false;
  }
 }

 public void suppress(){
  suppress = true;
 }

 public void action(){
  
  while(distance.getDistance()<20){
   pilot.rotate(90);
  }
   
  suppress=false;
 }
 
}

Agentes Reflexivos - 4 SALIR DE UN LABERINTO

OBJETIVO
Programar el robot para que utilizando el sensor ultrasónico pueda localizar obstáculos y girar para evitarlos. El robot también se debe programar para que utilizando estas habilidades (localizar obstáculos y girar) pueda salir de un laberinto de ángulos rectos.


import lejos.nxt.*;
import lejos.robotics.navigation.*;
import lejos.robotics.subsumption.*;

public class Labyrinth { 

 public static void main(String [] args){
  TachoPilot pilot = new TachoPilot(5.6f, 11.25f, Motor.B, Motor.C);
  UltrasonicSensor ultrasonic = new UltrasonicSensor(SensorPort.S1);

  Behavior getOut = new GetOut(pilot, ultrasonic);

  Behavior [] behaviorArray = {getOut};
  Arbitrator arbitrator = new Arbitrator(behaviorArray);

  LCD.drawString("Labyrinth", 2, 2);
  Button.waitForPress();
  arbitrator.start();
 }

}

import lejos.nxt.*;
import lejos.robotics.subsumption.*;
import lejos.robotics.navigation.*;

public class GetOut implements Behavior{
 private TachoPilot pilot;
 private UltrasonicSensor ultrasonic;

 private int distance;
 private int lastDistance;
 private int distanceDifference;

 private int veryCloseLeft;
 private int slightlyCloseLeft;
 private int notCloseLeft;
 private int slightlyFarRight;
 private int veryFarRight;

 private int basePowerLeft;
 private int basePowerRight;

 private Motor rightMotor;
 private Motor leftMotor;

 public GetOut(TachoPilot pilot, UltrasonicSensor ultrasonic){
  this.pilot = pilot;
  this.ultrasonic = ultrasonic;

  distance = 0;
  lastDistance = 0;

  veryCloseLeft = 7;
  slightlyCloseLeft = veryCloseLeft + 5;
  notCloseLeft = slightlyCloseLeft + 5;

  slightlyFarRight = notCloseLeft + 5;
  veryFarRight = slightlyFarRight + 5;

  basePowerLeft = 100;
  basePowerRight = 100;

  rightMotor = (Motor)pilot.getRight();
  leftMotor = (Motor)pilot.getLeft();
 }

 public boolean takeControl(){
  LCD.clear();
  LCD.drawString("Go", 2, 2);
  return true;
 }

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

 public void action(){
  pilot.forward();

  while(true){
   int regSpeed = 270;
   int changeSpeed = 333;
   int noSpeed = 0;
   rightMotor.setSpeed(regSpeed);
   leftMotor.setSpeed(regSpeed);
   lastDistance = distance;
   distance = ultrasonic.getDistance();
   distanceDifference = lastDistance - distance;

   if(distance <= notCloseLeft){
    if(distance <= veryCloseLeft){
     rightMotor.setPower(basePowerRight);
     rightMotor.backward();
     leftMotor.setPower(basePowerRight);
     leftMotor.forward();
    }
    else if(distance <= slightlyCloseLeft){
     rightMotor.setSpeed(noSpeed);
     rightMotor.setPower(0);
     rightMotor.forward();
     leftMotor.setSpeed(changeSpeed);
     leftMotor.setPower(basePowerLeft);
     leftMotor.forward();
    }
    else if(distance <= notCloseLeft){
     leftMotor.setPower(basePowerLeft);
     leftMotor.forward();
     rightMotor.setPower(0);
     rightMotor.flt();
    }
   }
   else{
    if(distance >= slightlyFarRight){
     if(distanceDifference < 2){
      leftMotor.setSpeed(noSpeed);
      leftMotor.setPower(0);
      leftMotor.forward();
      rightMotor.setSpeed(changeSpeed);
      rightMotor.setPower(basePowerRight);
      rightMotor.forward();
     }
    }
    else if(distance >= veryFarRight){
     leftMotor.setPower(basePowerLeft/2);
     leftMotor.forward();
     rightMotor.setPower(basePowerLeft);
     rightMotor.forward();
    }
   }

   try {
    Thread.sleep(30);
   }
   catch(InterruptedException e){

   }

  }

 }

}

Agentes Reflexivos - 2 UBICAR Y ENCONTRAR UNA FUENTE DE SONIDO

OBJETIVO
Programar el robot para que utilizando el sensor de sonido (micrófono) pueda ubicar y llegar hasta una fuente de sonido que si bien está fija, funciona de manera episódica. La fuente de sonido puede encontrarse en cualquier dirección con respecto de la dirección inicial del robot y dentro de un área de 15 m2


import lejos.nxt.Button;
import lejos.nxt.LCD;
import lejos.nxt.Motor;
import lejos.nxt.SensorPort;
import lejos.nxt.SoundSensor;
import lejos.robotics.navigation.Pilot;
import lejos.robotics.navigation.TachoPilot;



public class SoundFinder {

 public static SoundSensor sound;
 public static Pilot pilot;
 public static double averange;


 public static void main(String[] args)
 {
  pilot = new TachoPilot(5.6f, 11.5f, Motor.B, Motor.C);
  sound = new SoundSensor(SensorPort.S2,true);
  pilot.setTurnSpeed(180);

  Button.waitForPress();

  while(true)
  {
   int selectedPos=0;

   selectedPos=rotateAndFind();
   
   rotate(selectedPos);
   
   pilot.travel(20);
   
  }
  


 }

 public static int rotateAndFind()
 {
  double value=5;
  int pos=0;
  double temp=0;


  for(int i=0; i<8; i++)
  {

   temp=readSensorValue();
   print("esc "+temp);
   
   if(temp>value)
   {
    value=temp;
    pos=i;
   }
   pilot.rotate(45);
   while(pilot.isMoving());
   pilot.stop();
  }

  pilot.rotate(10); //fix de 180
  print("Val max:"+value);
  return pos;

 }


 public static void print(String text)
 {
  LCD.clear();
  LCD.drawString(text, 2, 2);

 }

 public static void rotate(int val)
 {
  print("Acomodando");
  pilot.rotate(45*val);
  pilot.rotate(55); //fix de rotación
 }

 public static double readSensorValue()
 {
  double value=0.0;
  
  sleep(500);
  value=sound.readValue();
  sleep(500);
  return value;

 }


 public static void sleep(int time)
 {
  try {
   Thread.sleep(time);
  } catch (InterruptedException e) {
  }
 }


}

Agentes Reflexivos - 1 SEGUIR UNA LÍNEA NEGRA

OBJETIVO
Programar el robot para que utilizando el sensor de luz pueda encontrar y seguir una trayectoria marcada con una línea negra pintada sobre una superficie plana. La trayectoria puede ser recta, con giros en varios ángulos, zig-zag, etc.


import lejos.nxt.*;
import lejos.robotics.navigation.*;
import lejos.robotics.subsumption.*;

public class FollowBlackLine {

 public static void main(String[] args){
  Pilot pilot = new TachoPilot(5.6f, 11.25f, Motor.B, Motor.C);
  LightSensor light = new LightSensor(SensorPort.S3);
  pilot.setTurnSpeed(180);

  Behavior getBackToLine = new GetBackToLine(pilot, light);
  Behavior goForward = new GoForward(pilot, light);
  Behavior [] behaviorArray = {getBackToLine, goForward};
  Arbitrator arbitrator = new Arbitrator(behaviorArray);

  LCD.drawString("Follow Black Line", 2, 2);
  Button.waitForPress();
  arbitrator.start();
 }

}

import lejos.nxt.*;
import lejos.robotics.subsumption.*;
import lejos.robotics.navigation.*;

public class GetBackToLine implements Behavior, SensorPortListener{

 private Pilot pilot;
 private LightSensor light;
 private int sweep;
 private boolean suppress;
 private boolean outOfBlackLine;

 public GetBackToLine(Pilot pilot, LightSensor light){
  this.pilot = pilot;
  this.light = light;
  suppress = false;
  outOfBlackLine = false;
  SensorPort.S3.addSensorPortListener(this);
 }

 public void stateChanged(SensorPort port, int oldValue, int newValue){
  if(light.readValue() > 35){
   outOfBlackLine = true;
  }
 }

 public boolean takeControl(){
  if(outOfBlackLine){
   LCD.clear();
   LCD.drawString("GetBackToLine", 2, 2);
   outOfBlackLine = false;
   return true;
  }
  else {
   return false;
  }
 }

 public void suppress(){
  suppress = true;
 }

 public void action(){
  sweep = 10;
  while(!suppress){
   pilot.rotate(sweep, true);
   while(!suppress && pilot.isMoving()){
    Thread.yield();
   }
   sweep*=-2;
  }
  pilot.stop();
  suppress = false;
 }

}


import lejos.nxt.*;
import lejos.robotics.subsumption.*;
import lejos.robotics.navigation.*;

public class GoForward implements Behavior, SensorPortListener{

 private Pilot pilot;
 private LightSensor light;
 private boolean foundBlackLine;

 public GoForward(Pilot pilot, LightSensor light){
  this.pilot = pilot;
  this.light = light;
  foundBlackLine = false;
  SensorPort.S3.addSensorPortListener(this);
 }

 public void stateChanged(SensorPort port, int oldValue, int newValue){
  if(light.readValue() <= 35){
   foundBlackLine = true;
  }
 }

 public boolean takeControl(){
  if(foundBlackLine){
   LCD.clear();
   LCD.drawString("GoForward", 2, 2);
   foundBlackLine = false;
   return true;
  }
  else{
   return false;
  }
 }

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

 public void action(){
  pilot.forward();
  while(light.readValue() <= 35){
   Thread.yield();
  }
 }

}

martes, 18 de octubre de 2011

Tarea: ¿Qué Agente para qué Problema?

AGENTES Y AMBIENTES
EJERCICIOS

¿QUÉ AGENTE PARA QUÉ PROBLEMA?
Para los siguientes problemas señala qué tipo de agente podría resolverlo mejor (reflexivo o deliberativo). Es importante justificar la respuesta y dar ejemplos de situaciones en los que uno u otro tipo de agente podría desempeñarse mejor.

- Salir de un laberinto
Reflexivo. Esto ya que con un simple algoritmo en el que el agente pueda seguir una trayectoria de seguir la pared derecha basta para poder resolver este problema.

- Explorar habitaciones y reconocer los objetos encontrados dentro de éstas.
Deliberativo (Reflexivo con memoria). Esto debido a que el agente debe de recordar cómo se encuentra el mundo. Un agente solo reflexivo no podría guardar el estado del mendo actual.

- Jugar ajedrez
Deliberativo (guiado por utilidad). Esto que el agente debe de estudiar su situación actual y tratar de tomar decisiones en base a eso, debe buscar una estrategia y poder continuarla por más de un turno.

- Jugar dominó (en parejas).
Deliberativo (guiado por objetivo). Esto ya que el agente debe analizar qué posibilidades tiene de lanzar una pieza dependiendo de las que ya se jugaron.

- Cuidar una persona mayor en su casa.
Deliberativo (guiado por utilidad). Esto ya que se debe de analizar no solo que el agente cumpla con su tarea, si no, también importa cómo fue que la realizó.

- Asistir a un ejecutivo en el manejo de su agenda.
Deliberativo (guiado por utilidad). Esto ya que el agente debe de estudiar por lo general un histórico para poder analizar la mayor cantidad de información y así poder dar un mejor resultado.

- Asistir a un ejecutivo en la preparación de sus viajes de negocios
Deliberativo (guiado por utilidad). Esto ya que debe de analizar una gran cantidad de información, procesarla para poder realizar una combinación que pueda dar un mejor resultado entre las opciones de viaje posibles.

La mayoría de estos problemas deben ser resueltos por un agente deliberativo, esto ya que requieren un razonamiento y tener conocimiento del mundo en el que se encuentra para poder desempeñar su tarea.

METODOLOGÍA PAGE
Una forma para responder la pregunta anterior es construir una definición PAGE de cada uno de los agentes. Esta definición consiste de 4 partes:
-Perceceptions: Qué cosas será capaz de percibir el agente.
-Actions: Qué acciones será capaz de llevar a cabo el agente.
-Goals (Objetivo): Cuál es el objetivo del agente.
-Environment (Ambiente): Qué características tiene el ambiente en el que el agente va a llevar a cabo su tarea y que pueden afectarlo.

3 MAS PROBLEMAS…
Para los siguientes problemas señala qué tipo de agente podría resolverlo mejor (reflexivo o
deliberativo). Es importante justificar la respuesta y dar ejemplos de situaciones en los que uno u
otro tipo de agente podría desempeñarse mejor.
- Controlar el tráfico de aviones en el aeropuerto.
- Monitorear el tráfico de automóviles en la ciudad de Guadalajara.
- Monitorear las condiciones del bosque de la primavera para evitar y/o responder
ante incendios forestales.
Haz una descripción PAGE de los agentes.

¿En qué son diferentes estos problemas con respecto de los del punto 2?
Estos problemas se pueden resolver con agentes reflexivos los cuales responder a alguna lectura de uno o varios sensores y actúa de acuerdo a ello.

¿Qué necesita un agente para poder resolverlos?
Necesita sensores y actuadores.

miércoles, 12 de octubre de 2011

Tipos de Agentes

Agente	Tipo de Agente	Percepciones	Acciones	Objetivos	Ambiente
					accesi ble	determi nista	episó dico	está tico	discre to
ajedrez	guiado por utilidad	posiciones de las piezas en el tablero	mover pieza, quitar pieza	eliminar al rey	si	si	no	si	si jugador contrario, piezas en el tablero
poker	guiado por objetivo	cartas, cámara	tomar carta, jugar carta, apostar, retirarse	aumentar ganancias, ganar partida	no	no	no	si	si jugadores, cartas, apuestas
manejar un taxi	reflexivo	cámara, velocímetro, gps, microfono	dirigir el volante, acelerar, frenar, escuchar al pasajero	ruta más corta, aumentar ganancias, viaje rápido y seguro	no	no	no	no	no calle, tráfico, peatones, clientes
sistema de análisis de imágenes	reflexivo con memoria	imagenes	comparar imagen, girar	asociar imagen	si	si	si	semi	no usuario, imagen