Ya faltan menos semanas para empezar el nuevo curso y algunas ideas se van puliendo, una de ellas el Path planning.

El Path planning, es una técnica en robótica móvil que permite elaborar un plan de navegación para que un robot móvil vaya de un punto X a un punto Y.

Un ejemplo de esta técnica se puede observar en el siguiente ejemplo:

En los video juegos existen multitud de ejemplos donde se emplea esta tecnica:

Con las tecnicas de Path planing sera posible desarrollar complejos proyectos donde los robots móviles interaccionaran con objetos para realizar misiones.

La técnica del Path planning se sustenta sobre el conocimiento de donde esta el robot en todo momento, por lo cual, es necesario previamente realizar tareas de Localización sobre un mapa conocido.

En el curso veremos como operar sobre un mundo recreado en un mapa virtual y como un robot puede localizarse y realizar una serie de operaciones con fiabilidad.

Xander Soldaat y Yo, estamos desarrollando un prototipo de robot para proyecto avanzados que esta compuesto por los siguientes sensores:

1. 1x SensorMUX
2. 4x Ultrasonic Sensor
3. 1x Compass Sensor
4. 1x NXTCam V3

El resultado es el siguiente:

El modelo de Xander, es ligeramente diferente:

Más información sobre el modelo de Xander:
http://picasaweb.google.com/mightor/LejosTurtleBot

Un elemento importante, en toda gestión de plantas de manera autónoma, es la gestión de la humedad. A continuación, se ven algunos consejos:

Si en un proyecto, es necesario bombear agua, es posible realizar esto a traves de sistemas similares a los que se presentan a continuación:

Unas ídeas del uso de este tipo de sistemas, se vera a continuación:

De cara al próximo año, una idea que tengo es la creación de jardines controlados autonomamente por los robots. Para ello necesitaría manejar varias cosas:

• Orientación de la luz
• Humedad
• PH

Por otro lado, seria interesante poder alimentar a la planta con agua y nutrientes.

Algunos proyectos que he visto previamente son:

http://people.csail.mit.edu/nikolaus/drg/

http://www.gorobotics.net/the-news/science/robot-tended-tomato-garden/

http://correll.cs.colorado.edu/www/Research/Entries/2009/8/1_The_Distributed_Robot_Garden.html

http://www.usc.edu/dept/garden/

Algunos artículos de cuidado de plantas:

http://plantas.facilisimo.com/reportajes/plantas-de-interior/cuidados-de-las-plantas-de-interior_184091.html

http://www.euroresidentes.com/jardineria/plantas/plantas-riego.htm

http://www.euroresidentes.com/jardineria/plantas_de_interior.htm

Buenas tardes,

Hoy concluía el programa de enriquecimiento educativo de la comunidad de Madrid de este año. Durante el evento de esta mañana, participe dando un discurso en la parte de profesorado, pero tengo que reconocer, que la primera parte del mismo no fue muy bien, el foco me daba de frente y se reflejaba en los papeles y apenas se  veía, pero pude reconducir la situación.

Al termine, del mismo me despedí de mis compañeros de programa y nada, deseando que llegue octubre para volver a empezar con el curso.

Nota:
Hace 2 semanas, hubo un evento en el centro donde se dan las clases y se expusieron los trabajos de todo el año.

Hasta Octubre.

Web del programa:

http://www.educa2.madrid.org/web/peac/

Gracias a un proyecto de unos investigadores de Portugal, es posible visualizar un entorno con tu robot LeJOS.

Más informacion sobre el proyecto aqui:

paginas.fe.up.pt/~ei04085/psite/LejosPaper.pdf

Gracias al dispositivo de Hitechnic, SensorMux, es posible conectar mas de 3 sensores de ultrasonidos.

http://www.cs.cmu.edu/~illah/rix62.html

http://www.eecs.umich.edu/~ebolson/courses/W09_598/ps4/

http://dyessick.com/Coastal/Fall2007/CS485/

http://pirate.shu.edu/~wachsmut/Teaching/CSAS3085/programming/index.html

http://code.google.com/p/robotics-playground

import java.awt.Rectangle;

import javax.microedition.lcdui.Graphics;

import lejos.nxt.*;
import lejos.nxt.addon.NXTCam;

/**
 * Class to display the rectangles that the camera picks up on the NXT screen
 * @author Mr.Rick
 *
 */
public class Cazador3
{

   private static int INTERVAL=100;

   private static NXTCam camera;
   private static UltrasonicSensor sonic;

   public static void main(String [] args){

    	 //Instanciar el sensorde camara
         camera = new NXTCam(SensorPort.S1);
         //Configuramos
         camera.sendCommand('A');
         camera.sendCommand('E');

        sonic = new UltrasonicSensor(SensorPort.S2);

         Rectangle rectangleObj = new Rectangle();

         while(!Button.ESCAPE.isPressed()){

             	rectangleObj = getMaximumRectangle(camera);
             	drawMaximumRectangle(rectangleObj);
             	takeActions(rectangleObj);

        		//try {Thread.sleep(INTERVAL);} catch (Exception e) {}                

         }
}

   private static void drawMaximumRectangle(Rectangle rectangleObj){
	   Graphics g = new Graphics();
       g.clear();
       g.drawRect(CameraUtils.xscale(rectangleObj.x),CameraUtils.yscale(rectangleObj.y),
                 CameraUtils.xscale(rectangleObj.width),CameraUtils.yscale(rectangleObj.height));
       g.refresh ();
   }

   private static void takeActions(Rectangle rectangleObj){

	 Robot5 robot = new Robot5(); 

  	 int nx=CameraUtils.xscale(rectangleObj.x);
     int q = 0;

     int distance = 0;

     if((nx>0) && (nx <=25)){
    	 q  =1;
    	 robot.turnLeft(100);
     }else if((nx> 25) && (nx <=75)){
    	 q =2;

    	 distance = sonic.getDistance();

    	 if((distance<=30) ){
        	 robot.stop();
    	 }else{
    		 robot.forward(500);
    	 }

     }else if((nx > 75) && (nx <=100)){
    	 q =3;
    	 robot.turnRight(100);
     }else{
    	 q = 99;
    	 robot.turnRight(100);

     }
     //fin bucle calculos
     //pintar resultados
     LCD.drawString("                ", 0,0);
     LCD.drawString("q "+ q, 0, 0);
     LCD.refresh();

   }

	private static Rectangle getMaximumRectangle(NXTCam camera){
		 int NXTCAM_MAXIMUN_OBJECTS =8;
	     int objectCount = 0;
		 int max_area = 0;
		 double x =0;
		 int area =0;
		 Rectangle rectangleObj = new Rectangle();

	     objectCount=camera.getNumberOfObjects();
	     if(objectCount>0 && objectCount<NXTCAM_MAXIMUN_OBJECTS){

	    	 //Calculo de objeto mas grande
	    	 for(int i =0; i<objectCount; i++){
	             Rectangle rect = camera.getRectangle(i);
	             //1. Calculo de area
	            area=rect.width*rect.height;

	             //2. Preguntamos si esa area es mayor que nuestro maximo
	            if (max_area <= area){
	          	  //2.1 si es mayor: actualizar
	          	  max_area = area;
	          	  rectangleObj = rect;
	            }

	         }
	     }
		 return rectangleObj;
	}
}