Actividad

Hacer un mapa conceptual individualmente del siguiente artículo:
http://www.iit.upcomillas.es/pfc/resumenes/4df6204c562f5.pdf

Grabar videos del laberinto y seguidor de línea.

Seguidor de línea

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

public class SigueLineasP {

public static void main(String[] args) throws Exception
{
LightSensor sluz = new LightSensor(SensorPort.S1);
int error, max, min, med;

min = sluz.readNormalizedValue();
LCD.drawString("Valor minimo:", 2, 3);
LCD.drawInt(min, 4, 6, 5);
Thread.sleep(2000);

Motor.A.rotate(-90,true);
Motor.B.rotate(90);
max = sluz.readNormalizedValue();
LCD.clear();
LCD.drawString("Valor maximo:", 2, 3);
LCD.drawInt(max, 4, 6, 5);
Thread.sleep(2000);

Motor.A.rotate(45,true);
Motor.B.rotate(-45);
med = (max + min)/ 2;
LCD.clear();
LCD.drawString("Valor medio:", 2, 3);
LCD.drawInt(med, 4, 6, 5);
Thread.sleep(2000);

Motor.A.forward();
Motor.B.forward();
LCD.clear();
LCD.drawString("Pulse ESCAPE", 2, 3);
LCD.drawString("para parar", 3, 5);
while (true) {
error = med - sluz.readNormalizedValue();
Motor.A.setSpeed(300 - error);
Motor.B.setSpeed(300 + error);
if (Button.ESCAPE.isPressed()){
break;
}
}
// TODO Auto-generated method stub
}

}

Laberinto

import lejos.nxt.*;
import java.io.*;

public class Labyrinth1 {
 
 //CONSTANTS
 private static int forwardStep = 720;
 private static int turnStep = 410;
 private static int fdist = 15;
 private static int slack = 20;
 private static int turnSpeed = 200;
 private static int straightSpeed = 400;
 
 //VARIABLES
 private static Motor rightMotor = Motor.B;
 private static Motor leftMotor = Motor.C;
 private static TouchSensor leftSensor = new TouchSensor(SensorPort.S2);
 private static TouchSensor rightSensor = new TouchSensor(SensorPort.S1);
 private static PrintStream console = new PrintStream(new LCDOutputStream());
 private static UltrasonicSensor sens = new UltrasonicSensor(SensorPort.S4);
 
 public static void main (String[] aArg) {

  //right hand rule
  while(true){
   try{
    while(moveOneSquare() == false)
     //do nothing
     ;
    
    rightMotor.setSpeed(turnSpeed);
    leftMotor.setSpeed(turnSpeed);
    
    console.println("Looking Right");
    //prepara a girar
    rightSlack();
    turnRight();
    //pone en neutral
    leftSlack();
    if (sens.getDistance()<fdist){
     console.println("Looking Front");
     //prepara a girar
     leftSlack();
     turnLeft();
     if(sens.getDistance()<fdist){
      console.println("Looking Left");
      turnLeft();
      if(sens.getDistance()<fdist){
       console.println("Going Back");
       turnLeft();
      }
     }
    }
    //pone en neutral
    rightSlack();
    
    if (leftSensor.isPressed() || rightSensor.isPressed())
     panic();
    
    //Stop wobbling
    Thread.sleep(200);
   }
   catch(Exception ex) {
    console.println("Something happened.\nI dont care.");
   }
  }
 }
 
 private static boolean moveOneSquare() throws Exception{
  boolean left, right;
  rightMotor.setSpeed(straightSpeed);
  leftMotor.setSpeed(straightSpeed);
  rightMotor.resetTachoCount();
  leftMotor.resetTachoCount();
  
  leftMotor.rotate(forwardStep,true);
  rightMotor.rotate(forwardStep, true);
  
  while(leftMotor.isRotating() && rightMotor.isRotating()){
   left = leftSensor.isPressed();
   right = rightSensor.isPressed();
   if ( left || right ){
    leftMotor.stop();
    rightMotor.stop();
    leftMotor.rotate(-leftMotor.getTachoCount(),true);
    rightMotor.rotate(-rightMotor.getTachoCount(), false);
    if (left && right){
     panic();
    }
    //left
    else if(left){
     rightMotor.rotate(-turnStep/5);
    }
    //right
    else {
     leftMotor.rotate(-turnStep/5);
    }  
    //try again!
    return false;
   }
  }
  //success!!
  return true;
 }
 
 //tensar la cuerda (== los engranages)
 //para que un giro a la derecha empieza de inmediato
 private static void rightSlack() throws Exception{
  rightMotor.rotate(-slack,true);
  leftMotor.rotate(slack,false);
  Thread.sleep(200);
 }
 //tensar la cuerda (== los engranages)
 //para que un giro a la izquierda empieza de inmediato
 private static void leftSlack() throws Exception {
  leftMotor.rotate(-slack,true);
  rightMotor.rotate(slack,false);
  Thread.sleep(200);
 }
 private static void turnRight() throws Exception {
  rightMotor.rotate(-(turnStep-30),true);
  leftMotor.rotate(turnStep-30,false);
  Thread.sleep(200);
 }
 private static void turnLeft() throws Exception {
  leftMotor.rotate(-turnStep,true);
  rightMotor.rotate(turnStep,false);
  Thread.sleep(200);
 }
 private static void panic() throws Exception {
  console.println("!!! HELP !!!");
  console.println("Put me straight and center");
  console.println("and press Enter.");
  Sound.beepSequenceUp();
  Button.ENTER.waitForPressAndRelease();
 }
}

Otra fuente: http://agentesotono2010.blogspot.mx/2010/11/mindstorms-nxt-lejos-salir-de-un.html

Api TachoPilot de Lejos

http://www.roboticaenlaescuela.es/blog/wp-content/uploads/2011/02/ejemplosBaseCloneWars.pdf

http://www.lejos.org/p_technologies/nxt/nxj/api/lejos/navigation/Pilot.html

El paquete lejos.navigation contiene  interfaces y clases para la navegación
abstracta.
La clase Pilot permite controlar un robot de tracción diferencial sin tener que lidiar con el control individual del motor.

Ejemplos:
pilot.backward();
pilot.travel(20);
float dist =
pilot.getTravelDistance();
pilot.resetTachoCount();

Sensores y motores

http://socrates.bmcc.cuny.edu/mkok/Sensors.html#Ultrasound

http://blog.electricbricks.com/2010/03/tutorial-java-lejos-lego-mindstorms-nxt-8/

http://inghobbit.blogspot.mx/2011/05/ejemplo-programa-con-lejos-para-el-lego.html

Comandos Lejos

https://wiki.dcc.uchile.cl/TallerMindstorms/doku.php?id=notas_de_lejos

http://docencia.etsit.urjc.es/moodle/file.php/11/Practicas/11_12/practicas.pdf

Proyecto Lego

https://www.youtube.com/watch?v=14PswDr0otE

Que el lego sea capaz de lo siguiente:

1. Seguir una línea
2. Evadir obstáculos
3. Adaptarse a cambios en el ambiente
4. Navegar y salir de un laberinto
5. Seguir (empujar) ciertos objetos
6. y a Futuro que pueda diferenciar y clasificar objetos.