Proyecto NXT MindStorms

Red neuronal para LeJOS MindStorm NXT

2007-11-02T09:38:00.000-05:00

Este código es traducido de su original para el MindStorm RXC. Es un algoritmo de propagación hacia atras "Backpropagation Network". Nos tomamos el trabajo de
traducirlo para el nuevo modelo. Disfrutenlo.

El código y su explicación se encuentran en la siguiente dirección:
http://www.javaworld.com/javaworld/jw-05-2005/jw-0516-lego.html

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

public class AlgoritmoAprendizaje {
public static LegoMindstormBP bpn = new LegoMindstormBP();

public static void main(String args[]) throws InterruptedException
{

int i, white;
int inp[] = {0,0,0};
int out[] = {0,0};

Sound.beep();
LCD.drawString( "Train",10,10 );

// Train bpn 500 epochs, sit down and wait about 5 minutes!
for(i=0;i<500;i++) {
bpn.train(1);
LCD.drawInt( bpn.trainedEpochs,0,10);
}

SensorPort.S1.setTypeAndMode(SensorConstants.TYPE_SWITCH,
SensorConstants.MODE_BOOLEAN );

SensorPort.S2.setTypeAndMode(SensorConstants.TYPE_SWITCH,
SensorConstants.MODE_RAW );

SensorPort.S3.setTypeAndMode(SensorConstants.TYPE_LIGHT_ACTIVE,
SensorConstants.MODE_BOOLEAN );

Sound.twoBeeps();
SensorPort.S2.activate();
white = SensorPort.S2.readRawValue();

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

Sound.twoBeeps();

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

LCD.drawInt(SensorPort.S2.readRawValue(),0,20 );

if( SensorPort.S1.readBooleanValue() )
inp[0] = 1; // Sensor 1 on
else
inp[0] = 0; // Sensor 1 off

if( SensorPort.S2.readRawValue() > white + 50 )
inp[1] = 1; // Sensor 2 over black floor
else
inp[1] = 0; // Sensor 2 over white floor

if( SensorPort.S3.readBooleanValue() )
inp[2] = 1; // Sensor 3 on
else
inp[2] = 0; // Sensor 3 off

bpn.test( inp, out );

if( out[0] == 1 )
Motor.A.forward();
else
Motor.A.backward();

if( out[1] == 1 )
Motor.C.forward();
else
Motor.C.backward();

Thread.sleep( 500 );

} // while()

SensorPort.S2.passivate();
Motor.A.stop();
Motor.C.stop();
Sound.beep();

} // main()

} // class LMbpn

class LegoMindstormBP {

public static int data1[][] = {{0,0,0}, {1,1}};
public static int data2[][] = {{1,0,0}, {1,0}};
public static int data3[][] = {{0,0,1}, {0,1}};
public static int data4[][] = {{0,1,0}, {0,0}};

public static double input[] = {0,0,0,1};
public static double w1[][] = {{0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}};
public static double hidden[] = {0,0,1};
public static double w2[][] = {{0,0}, {0,0}, {0,0}};
public static double output[] = {0,0};
public static double delta2[] = {0,0};
public static double delta1[] = {0,0,0};

public static int trainedEpochs = 0;

LegoMindstormBP() {
byte i, j;
// Initialize weights randomly between 0.1 and 0.9
for(i=0; i< w1.length; i++)
for(j=0; j< w1[i].length; j++)
w1[i][j] = Math.random()*0.8+0.1;

for(i=0; i< w2.length; i++)
for(j=0; j< w2[i].length; j++)
w2[i][j] = Math.random()*0.8+0.1;
}

public static void train(int e) {
for(int i=0; i< e; i++) {
// Call method learn with training data
learn( data1[0], data1[1] );
learn( data2[0], data2[1] );
learn( data3[0], data3[1] );
learn( data4[0], data4[1] );
trainedEpochs++;
}
}

public static void learn( int inp[], int out[] ) {
int i, j;
double sum, out_j;

// Initialize input units
for(i=0; i< inp.length; i++)
input[i] = inp[i];

// Calculate hidden units
for(j=0; j< hidden.length-1; j++) {
sum = 0;
for(i=0; i< input.length; i++)
sum = sum + w1[i][j]*input[i];

hidden[j] = 1 / ( 1 + Math.exp(-sum));
}

// Calculate output units
for(j=0; j< output.length; j++) {
sum = 0;
for(i=0; i< hidden.length; i++)
sum = sum + w2[i][j]*hidden[i];

output[j] = 1 / (1 + Math.exp(-sum));
}

// Calculate delta2 errors
for(j=0; j< output.length; j++) {
if( out[j] == 0 )
out_j = 0.1;
else if( out[j] == 1 )
out_j = 0.9;
else
out_j = out[j];
delta2[j] = output[j]*(1-output[j])*(out_j-output[j]);
}

// Calculate delta1 errors
for(j=0; j< hidden.length; j++) {
sum = 0;
for(i=0; i< output.length; i++)
sum = sum + delta2[i]*w2[j][i];

delta1[j] = hidden[j]*(1-hidden[j])*sum;
}

// Adjust weights w2
for(i=0; i< hidden.length; i++)
for(j=0; j< output.length; j++)
w2[i][j] = w2[i][j] + 0.35*delta2[j]*hidden[i];

// Adjust weights w1
for(i=0; i< input.length; i++)
for(j=0; j< hidden.length; j++)
w1[i][j] = w1[i][j] + 0.35*delta1[j]*input[i];
}

public static void test(int inp[], int out[]) {
int i, j;
double sum;

// Initialize input units
for(i=0; i< inp.length; i++)
input[i] = inp[i];

// Calculate hidden units
for(j=0; j< hidden.length-1; j++) {
sum = 0;
for(i=0; i< input.length; i++)
sum = sum + w1[i][j]*input[i];

hidden[j] = 1 / ( 1 + Math.exp(-sum));
}

// Calculate output units
for(j=0; j< output.length; j++) {

sum = 0;
for(i=0; i< hidden.length; i++)
sum = sum + w2[i][j]*hidden[i];

output[j] = 1 / (1 + Math.exp(-sum));
}

// Assign output to param out[]
for(i=0; i< output.length; i++)
if( output[i] >= 0.5 )
out[i] = 1;
else
out[i] = 0;
}
}

Convierte a tu MindStorm NXT en un reproductor de sonido

2007-11-02T09:33:00.000-05:00

/*
*Este código reproduce los sonidos que el Lego MindStorm NXT escucha.
*Puede ser un código base para hacer cosas interesantes tales como emular
*el comportamiento de un loro para melodías...jejeje
*/
import lejos.nxt.Button;
import lejos.nxt.LCD;
import lejos.nxt.SensorPort;
import lejos.nxt.SensorPortListener;
import lejos.nxt.Sound;
import lejos.nxt.SoundSensor;

public class Canta implements SensorPortListener{

/**
* @param args
*/
String changed = "State changed";
String val = "Value:";
String oldVal = "old Value:";
String free = "Free Mem:";
SoundSensor sound = new SoundSensor(SensorPort.S1);

public static void main(String[] args) {
// TODO Auto-generated method stub

Canta canta= new Canta();
try {
canta.run();
Button.ESCAPE.waitForPressAndRelease();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
//System.out.println(e);
}

LCD.clear();
LCD.drawString("Finished", 3, 4);
LCD.refresh();

}

@Override
public void stateChanged(SensorPort source, int oldValue, int newValue) {
// TODO Auto-generated method stub
if (source == SensorPort.S2)
{
LCD.clear();
LCD.drawString(changed,0,0);
LCD.drawString(val, 0, 1);
LCD.drawInt(newValue,7,1);
LCD.drawInt(sound.readValue(), 12, 1);
LCD.drawString(oldVal, 0, 2);
LCD.drawInt(oldValue, 11, 2);
LCD.drawString(free, 0, 4);
LCD.drawInt((int)(Runtime.getRuntime().freeMemory()),10,4);
LCD.refresh();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {}
Sound.playTone(newValue, 1000);

}

}

private void run()

{
SensorPort.S2.addSensorPortListener(this);

}

}

Pon a caminar a tu Mindstorm NXT con LeJOS

2007-11-02T09:24:00.000-05:00

/*El siguiente programa es el script para poner a caminar a tu MindStorm NXT
*cuando le presionas el Touch Sensor camina para atras...
*/

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

public class Caminar {

/**
* @param args
*/

public static void main(String[] args) {
// TODO Auto-generated method stub
Motor.B.setSpeed(200);
Motor.C.setSpeed(200);

while(!Button.ESCAPE.isPressed()){
Motor.B.forward();
Motor.C.forward();
if(SensorPort.S1.readValue()==0){
Motor.B.backward();
Motor.C.backward();
}

}

LCD.clear();
LCD.drawString("Finished", 3, 4);
LCD.refresh();
}

}

NXT Saliendo del laberinto

2007-10-28T22:07:00.000-05:00

Bueno, este video va muy de la mano con lo que se ha pretendido con el curso: Lograr que un robot encuentre la salida a través de un laberinto, esta vez programado en un NXT, acá va el video

NXT que resuelve el cubo de rubik

2007-10-22T11:03:00.000-05:00

Bueno, encontramos una noticia que nos pareció muy interesante para compartir acá en el blog, un robot nxt programado para resolver el cubo de rubik!!!, esta es la noticia:

"Daniele benedettelli ha diseñado un sistema resolvedor del popular cubo de rubik basado en un sólo brick de Lego Mindstorms NXT, ¡con sólo tres servos!

Un servomotor actua de junta prismática que empuja el lado del cubo (el lado rojo en la foto); otro servomotor rota la plataforma giratoria del robot, y el tercero tiene una doble función para ayudar el brazo empujador a acomodar el brazo en el soporte y para sujetar el cubo mientras la base inferior rotatoria gira."

"El robot utiliza dos sensores de contacto como detectores de límite de los brazos y un sensor de luz para encontrar la posición inicial de la base rotatoria.

Mejor que enrollarse mas en mecánica, para entenderlo todo lo mejor es echar un vistazo a este video!"

"El software LRU v 3.0 soporta comunicación USB con el ladrillo NXT.
La webcam captura la imagen y tiene un algoritmo de reconocimiento de los colores."

Increible No!!!

Esta noticia fue extraida de la siguiente página:
http://www.teknear.com/story/robot-lego-mindstorms-nxt-soluciona-cubo-rubik

Página recomendada

2007-10-16T08:44:00.000-05:00

Bueno, estuvimos buscando algunos sitios en internet, y acá recomendamos el siguiente sitio en español, ideal para principiantes en donde se explican las características del nuevo Lego NXT, y las cuatro posibles construcciones que se pueden realizar: El tribot, el robot industrial, el escorpión, y el alpharex, el vinculo de la página es el siguiente:

http://ro-botica.com/mindstorms.asp

Demostración del Alpharex Bailando

2007-10-12T14:30:00.000-05:00

Construcción del carro NXT

2007-10-12T13:51:00.000-05:00

Instalación LeJOS: paso 6

2007-10-11T19:54:00.000-05:00

Comandos LeJOS

nxjflash - flashea el firmware
nxjc - compila un programa en Java para el LeJOS NXJ
nxj - linkea, sube y opcionalemente corre un programa en la unidad
nxjlink - linkea un programa
nxjupload - sube y opcionalemente corre un programa en la unidad
nxjbrowse - explorador de archivos NXJ
emu-lejosrun - emula un programa NXJ en Unix

Para mas informacion, ir a la guia ubicada en C:\lejos_nxj\README.html (en Ingles). Recomiendo que vean esta guia de LeJOS para mas informacion sobre LeJOS y MindStorms NXT.

http://attachments.wetpaintserv.us/5acYoL0QvMupMO27t2gk%2BA%3D%3D123453

Instalación LeJOS: paso 5

2007-10-11T19:01:00.000-05:00

Instalacion del Firmware en la unidad NXT.

Hasta donde se, la instalacion de este nuevo firmware no pone en ningun momento en peligro la unidad NXT. Si el firmware llegara a presentar algun fallo, la unidad tiene un boton de "reset" para volver a montar el firmware. Siempre se puede volver al firmware original de MindStorms con el software que provee Lego.

Es importante leer el manual del usuario para conocer como hacemos estos procedimientos de flasheo. De todas formas vale la pena aclarar, que no me hare responsable por ningun daño que pueda sufrir la unidad por usos indebidos del firmware, sabemos que por el momento, LeJOS es un proyecto Beta. Personalmente, aunque he tenido a veces problemas, he podido siempre restaurar del LeJOS al MindStorms original y viceversa.

Para flashar el LeJOS, conectamos la unidad NXT al puerto USB del computador, presionamos el boton "reset" de la unidad por mas de 4 segundos, la unidad hara una señal sonora y el sensor de luz en caso de estar conectado iluminara. En ventana de CMD escribimos el comando nxjflash.

Instalación LeJOS: paso 4

2007-10-11T18:47:00.000-05:00

Comprobando instalacion

Para comprobar que todo este bien, vamos a abrir una ventana de CMD, en Inicio, Ejecutar, y escribimos CMD.

Aqui vamos a probar el Java. Escribimos javac: Si todo esta bien, obtenemos una serie de comandos disponibles para usar esta aplicacion: el Java ha quedado bien configurado.

Para comprobar el LeJOS, escribimos nxjc. Nos debe igualmente mostrar comandos utilizables para la aplicacion y sabremos que esta bien instalado.

Instalación LeJOS: paso 3

2007-10-10T17:44:00.000-05:00

Problema Con la Version 0.4beta

En la ultima version de LeJOS (lejos NXJ 0.4beta), hay un problema con el archivo nxjc.bat, que se encuentra en C:\lejos_nxj\bin el cual hay que abrirlo con el wordpad y añadirle unas comillas en la linea que comienza con "javac".

El archivo debería quedar de la siguiente manera.

javac -source 1.3 -target 1.1 -bootclasspath "%NXJ_HOME%\lib\classes.jar;%CLASSPATH%" %*

Instalación LeJOS: paso 2

2007-10-10T13:34:00.000-05:00

Variables de Entorno

Esta puede ser una de las tareas mas complicadas para algunos: vamos a configurar unas variables de entorno en el Sistema para que funcionen bien los programas.

Primero, vamos al menú Inicio, Mi PC. Aqui damos click con el boton derecho del mouse y seleccionamos propiedades. Tenemos una ventana llamada Propiedades del Sistema, aqui, vamos a la pestaña Opciones Avanzadas.

Damos click al boton señalado en el grafico anterior y llegamos a la ventana para agregar variables del sistema. Damos click al boton Nueva para crear las variables:

Vamos a crear una variable llamada JAVA_HOME cuyo valor (En la mayoria de los casos, en la instalacion por defecto del Java) sera C:\Archivos de programa\Java\jdk1.6.0_03
Creamos la variable NXJ_HOME del mismo modo que creamos la anterior. Para este ejemplo, el valor seria C:\lejos_nxj ya que aqui descomprimimos el LeJOS.
Buscamos una variable ya existente en las mismas variables del sistema llamada Path. Aqui tenemos que ser muy cuidadosos, porque no queremos borrar el valor de esta variable, solo queremos agregar al final de el valor que aqui aparece lo siguiente: ;lejos_nxj/bin donde el punto y coma (;) es el separador del valor anterior. Este paso es el mas delicado de todos, tener extremo cuidado de no ir a borrar ningun valor del Path. Si no sabemos lo que estamos haciendo, podemos dañar el sistema.

Instalación LeJOS: paso 1

2007-10-10T12:01:00.000-05:00

Para la instalacion del lejos, necesitaremos los siguientes programas:

Ademas, debes tener el Java SE JDK, aqui trabajare con la ultima version (jdk-6u3-windows-i586-p.exe) que la puedes bajar desde la pagina oficial de Java http://java.sun.com. Se recomienda trabajar con la verson de Java 5 en adelante.

Descomprimimos el LeJOS (lejos_NXJ_win32_0_4_0beta.zip), recomendablemente en la raiz (C:) (Podemos descomprimir este archivo con WinZip, http://www.winzip.com). Tendriamos el programa en la carpeta C:\lejos_nxj

Debemos instalar el driver para el NXT block, el archivo que bajamos MINDSTORMS NXT Driver v1.02 (upload1F7B2420-A5ED-44FF-9460-E262657029DC.zip) lo descomprimimos e instalamos el driver (Esto es para no instalar toda la Suite del MindStorms original. Si ya lo ha hecho, no necesita instalar este driver)

LibUsb-Win32 (libusb-win32-filter-bin-0.1.12.1.exe) es un driver para poder conectar nuestro robot via USB. Debes instalar este driver antes de conectar la unidad NXT. Instala este programa siguiendo el proceso normal de instalacion.

ATENCION este instalador se encuentra tambien dentro de la carpeta que acabamos de descomprimir D:\ProyectoNXT\lejos_nxj\3rdparty\lib. Tambien se puede descargar desde el link que se encuentra arriba.

Ahora que tenemos el driver para poder conectar nuestro NXT.

Instalación de LeJOS

2007-10-04T00:35:00.000-05:00

Ya logramos instalar el nuevo firmwara de LeJOS en el robot y en nuestro PC, ahora podemos desarrollar aplicaciones para el robot en Java. Si ya tuvieron la oportunidad de mirar el API del NXT les cuento que no es complicado para los que tienen alguna experiencia con Java.

Publicare en el wiki los pasos a seguir para la instalacion de LeJOS, aunque ya hay varias versiones en la red, vale la pena publicar lo que funciono para nosotros.

Contruccón del Alpharex

2007-10-03T10:24:00.000-05:00

Ya he subido al wiki las fotos de la construcción del Alpharex (El modelo que ven en la barra de la derecha), esto con el objetivo de que lo aprecien, pero el tutorial completo y detallado lo pueden encontrar con el material digital que te incluye tu propio robot, les voy a dejar la dirección para que entren directamente.

http://intart.wetpaint.com/page/Fotos+Construcci%C3%B3n

Wiki EAFIT

2007-09-28T11:16:00.000-05:00

Vale la pena mencionar que en paralelo con este Blog, se esta desarrollando una pagina en el Wiki de la asignatura Ingenieria del Conocimiento. Puede ser util cuando se deseen publicar fotos y contenido un poco mas extenso. De cualquier forma se estara informando aqui cuando necesitemos ir a este Wiki.

http://intart.wetpaint.com/page/Lego+NXT

En la Universidad Eafit se creo un grupo en el laboratorio de mecatronica a cargo del profesor Hans Ley Savelsberg. Estaremos muy contentos de poder trabajar con ellos y aportar ideas al grupo. Pueden visitar el Wiki del grupo.

http://www1.eafit.edu.co/wiki/index.php/Lego_MindStorms

Mas Lenguajes...

2007-09-27T20:06:00.000-05:00

Tambien hay otros lenguajes muy poderosos que vale la pena mencionar. Estos usan el firmware original del Lego MindStorms a diferencia del LeJOS, que hay que reemplazar el firmware de la unidad NXT.

LabVIEW Graphical Programming http://www.ni.com/mindstorms
NBC (Next Byte Codes) http://bricxcc.sourceforge.net/nbc/
Microsoft Robotics studio http://msdn.microsoft.com/robotics/
Gostai URBI for LEGO MINDSTORMS NXT http://www.gostai.com/lego.html

Tambien puedes desarrollar tu propio firmware para el NXT. Hay un link en la pagina principal del NXT que se llama NXTREME, alli se puede cambiar toda la funcionalidad desde el nivel mas bajo del hardware. De eso y de los anteriores lenguajes trataremos en etapas mas maduras de este Blog. Por ahora vamos a centrarnos en el LeJOS.

Lenguaje de Programacion

2007-09-27T11:24:00.000-05:00

Para los que no conocen un el lenguaje de programación utilizado para darle vida a este robot, les cuento que es un software muy sencillo, basado en un poderoso lenguaje de programación gráfico llamado LabView de National Instruments. Es una interfaz sencilla, agradable de utilizar y sobretodo muy intuitiva. Recordemos que este es un juguete para niños.

Pueden visitar la pagina oficial de robot en: http://mindstorms.lego.com/

Este juguete puede ser programado de una forma un poco mas avanzada. Existen entonces unas personas que querían programar el robot utilizando el lenguaje Java. De ahí nació LeJOS. Es una pequeña maquina virtual de Java, incluye funciones de J2ME que es Java para dispositivos moviles y una API bien documentada con las funciones del NXT.

Pueden visitar la pagina de LeJOS en: http://lejos.sourceforge.net/

Proyecto NXT

2007-09-25T10:26:00.000-05:00

Quiero dar la bienvenida a este Blog del robot NXT de Lego. En realidad es la primera vez que me doy a la tarea de escribir en este tipo de espacio, pero tratare de que sea fácil y agradable para leer. Por favor si tienen cualquier duda o sugerencia, les agradezco dejen el comentario.