English

¿Quién no ha querido alguna vez decirle a su NXT qué debía hacer y conseguir que lo hiciera? Pues aquí tenéis un primer paso para conseguirlo. Hasta que lenguajes como ROILA sean plenamente funcionales no podremos conseguir que el robot nos entienda directamente, pero sí tenemos herramientas de reconocimiento de voz para el ordenador, y sabemos como comunicarnos remotamente con el NXT desde el ordenador, así que… con mucha paciencia y algunos trucos podremos conseguir que nuestro robot reconozca nuestras instrucciones y las obedezca.

Ya hay algunos programas que basan el reconocimiento de voz en la diferente intensidad con la que se dicen las sílabas de la palabra clave, y utilizan el sensor de sonido (NXTPrograms).
Incluso, hay varios programas que permiten control con voz, dos de los más relevantes son:

Parar: Stop

Para que el sistema de reconocimiento de voz pueda entendernos, los comandos deben estar preferiblemente en inglés, además nuestra pronunciación deberá ser razonablemente buena, o no funcionará.

Una vez el ordenador ha reconocido el comando de voz, lanza el script con el programa de LeJOS, al cual le debemos pasar los argumentos de entrada adecuados para que realice la acción correspondiente.

El programa de LeJOS está compilado para trabajar residente en el ordenador, el decir, no se descarga nada al NXT, sólo se le envía, por bluetooth, información sobre qué motores debe mover y cómo hacerlo, esto acelera la comunicación.

Pasos a seguir para implementar el sistema

1. Crear un comando de voz personalizado

Abrimos el editor de AppleScript (o nuestro editor de código favorito) y guardamos el script en: “/Users/MyUser/Library/Speech/Speakable Items” con formato Script el nombre será el comando de voz que utilizaremos para llamar al script, así que interesa que sea breve y sencillo. Por ejemplo: “Up”
Este script debe, al ser ejecutado, llamar al programa de LeJOS con el parametro adecuado, es algo así:

1 2 3

on run   do shell script "cd ~/lejos_nxj/bin; ./nxjpc Connecting Up" end run

En la linea 2 le pedimos a la shell (no se ejecuta en terminal, no hay feedback visible de la operación) que vaya a la carpeta lejos_nxt/bin -cd ~/lejos_nxj/bin- y luego -;- que ejecute el programa Connecting con el parametro adecuado – ./nxjpc Connecting Up-.

Haríamos lo mismo para todos los comandos que quisiéramos añadir.

NOTA: Si quisiéramos ejecutar el comando en el Terminal, tendríamos que escribir lo siguiente:

1 2 3 4 5 6

on run         tell application "Terminal"            activate      do script "cd ~/lejos_nxj/bin; ./nxjpc Connecting Up"         end tell end run

Esto ejecutaría el comando en el clásico Terminal, por lo que podríamos ver qué pasa.
Nótese la desaparición de shell en la línea 4.

2. Crear un programa para enviar la información al NXT

Nosotros hemos optado por hacerlo en LeJOS, ya que hemos estado trabajando con LeJOS en Mac durante varios artículos (Instalación LeJOS en MAC, Conexión Bluetooth en MAC, Instalación de Eclipse en MAC).

Os recomiendo echar un vistazo al artículo sobre Manejo Remoto del NXT desde PC, ya que vamos a trabajar sobre esa misma base.

Este es el código del programa:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

import lejos.nxt.*; import lejos.nxt.remote.NXTCommand; import lejos.pc.comm.*; public class Connecting {     public static void main(String [] args) throws Exception {     NXTConnector conn = new NXTConnector();     if (!conn.connectTo("Mac", NXTComm.LCP)) {       System.err.println("Conexión Fallida");       System.exit(1);     }     NXTCommand.getSingleton().setNXTComm(conn.getNXTComm());         if (args[0].equalsIgnoreCase("Up"))     {      Motor.A.rotate(720,true);      Motor.B.rotate(720);     }     else if (args[0].equalsIgnoreCase("Down"))     {     Motor.A.rotate(-360,true);     Motor.B.rotate(-360);      }     else if (args[0].equalsIgnoreCase("Right"))     {     Motor.A.rotate(-360,true);     Motor.B.rotate(360);         }     else if (args[0].equalsIgnoreCase("Left"))     {     Motor.A.rotate(360,true);     Motor.B.rotate(-360);      }     else if (args[0].equalsIgnoreCase("Stop"))     {     Motor.A.setSpeed(0);     Motor.B.setSpeed(0);     conn.close();     }   } }

Líneas 8-14: Nos conectamos con el dispositivo
Líneas 6-40: En función del argumento de entrada, realizamos un movimiento u otro.
Hemos utilizado una función de comparación de cadenas estándar de Java para comparar el argumento de entrada con nuestro valor de control (”Up”, “Down”, …)

1	args[0].equalsIgnoreCase("Up")

En este caso hemos optado por comprobar la igualdad de las cadenas ignorando la distinción mayúsculas/minúsculas.
NOTA: Cuando utilizamos el bluetooth para comunicarnos con el NXT desde el PC/MAC, por norma general, debemos utilizar

1	conn.close();

Para asegurarnos que la conexión se cierra correctamente entre ambos dispositivos.
Pero esto tiene un pequeño problema en un programa como este, y es que: si cerramos la conexión después de cada movimiento, perderemos tiempo de reacción al tener que iniciarla de nuevo.

Por eso nuestro programa sólo incluye cierre de conexión con la palabra clave Stop.

Para compilar correctamente este programa (recordemos que se ejecuta en el ordenador, no en el NXT), tendremos que hacer uso del comando:

1	nxjpcc Connecting.java

Para ejecutarlo

1	nxjpc Connecting ArgumentoDeEntrada

Esperamos que os haya gustado, y para cualquier duda, podéis utilizar el foro.

• Submit this to Script & Style
• Share this on Blinklist
• Share this on del.icio.us
• Digg this!
• Post this on Diigo
• Share this on Reddit
• Buzz up!
• Stumble upon something good? Share it on StumbleUpon
• Share this on Technorati
• Share this on Mixx
• Post this to MySpace
• Submit this to DesignFloat
• Share this on Facebook
• Tweet This!
• Email this to a friend?
• Suggest this article to ToMuse
• Subscribe to the comments for this post?
• Share this on Linkedin
• Seed this on Newsvine
• Share this on Devmarks
• Add this to Google Bookmarks
• Add this to Mister Wong
• Add this to Izeby
• Share this on Tipd
• Share this on PFBuzz
• Share this on FriendFeed
• Mark this on BlogMarks
• Submit this to Twittley
• Share this on Fwisp
• Moo this on DesignMoo!
• Share this on BobrDobr
• Add this to Yandex.Bookmarks
• Add this to Memory.ru
• Add this to 100 bookmarks
• Add this to MyPlace
• Submit this to Hacker News
• Send this page to Print Friendly
• Bump this on DesignBump
• Add this to Ning
• Post this to Identica
• Save this to Xerpi
• Share this on Wikio
• Tip this to TechMeme
• Sphinn this on Sphinn
• Post this to Posterous
• Grind this! on Global Grind
• Ping this on Ping.fm
• Submit this to NUjij
• Submit this to eKudos
• Submit this to Netvouz
• Submit this to Netvibes
• Share this on Fleck
• Share this on Blogosphere News

]]> http://blog.electricbricks.com/2010/07/nxt-mac-lejos-voice-controlled/feed/ 0 http://blog.electricbricks.com/2010/07/eclipse-lejos-installation-mac/ http://blog.electricbricks.com/2010/07/eclipse-lejos-installation-mac/#comments Tue, 20 Jul 2010 18:41:30 +0000 Dani http://blog.electricbricks.com/?p=8869

Después del tutorial de instalación de LeJOS en MAC vamos a ver cómo instalar y configurar el entorno de programación Eclipse para trabajar con LeJOS. Primero lo instalaremos y posteriormente haremos nuestro programa Hola Mundo desde Eclipse.

1. Instalar y configurar Eclipse

Lo primero que tenemos que hacer es ir a la página de descarga de Eclipse y bajarnos Eclipse IDE for Java EE Developers.

Como Eclipse no necesita instalación, basta con descomprimir el archivo y colocar la carpeta resultante donde queramos, por ejemplo, en la carpeta Aplicaciones de nuestro MAC.

Para abrir la aplicación simplemente hacemos click sobre el icono de Eclipse.

Lo siguiente que nos vamos a encontrar es una pantalla que nos pide el nombre de nuestro espacio de trabajo (Workspace)

Tras esto estaremos en la pantalla de bienvenida de Eclipse

Ahora tenemos que crear un nuevo proyecto File – New… – Project

Y seleccionamos como tipo de proyecto Java Project

Ahora damos un nombre a nuestro proyecto

Abrimos Propiedades

Y tendremos que editar:

English

Muchos usuarios han tenido problemas de conexión bluetooth entre sus ladrillos NTX y su MAC. Vamos a dar un pequeño repaso a la configuración que necesitamos para que todo funcione correctamente. Además, veremos cómo realizar la conexión desde NXT-G y desde LeJOS (instalación de LeJOS en MAC).

Emparejamiento

Lo primero que debemos hacer es emparejar el NXT con el MAC. Para que todo funcione correctamente, os recomendamos que sea el ordenador el que realice la búsqueda y posterior emparejamiento.

Primero vamos al menú “Preferencias de Bluetooth”

¡IMPORTANTE! Antes de continuar, os recomendamos que borréis todos los NXT que hayan sido emparejados previamente con el ordenador.

Nos aseguramos de que nuestro NXT tiene el bluetooth encendido y en modo visible.
Seleccionamos “Añadir nuevo dispositivo”, el símbolo + abajo a la izquierda.

Cuando el MAC detecte nuestro NXT, lo seleccionamos y le damos a continuar

Nos aparecerá la pantalla de emparejamiento, por defecto, la clave de emparejamiento bluetooth de nuestro MAC es 0000

Debemos estar atentos a nuestro NXT, pues nos pedirá que confirmemos la clave.
Aquí tenemos 2 opciones:

1. Cambiar la clave por defecto del NXT: 1234, por la de nuestro MAC: 0000.
2. Confirmar la clave 1234, y cuando el ordenador nos devuelva error, cambiamos la clave del MAC (eligiendo, lógicamente 1234)

Si todo ha ido correctamente, en unos segundos deberíamos tener una pantalla como esta

Ahora, para comprobar que el proceso ha finalizado de forma correcta, volvemos a “Preferencias de Bluetooth” y comprobamos la configuración de puertos del nuevo dispositivo

Tenemos que tener exactamente esta configuración

Si no es así, la cambiamos.

Con esto finaliza el proceso de emparejamiento, que no es más que hacer que los dispositivos se reconozcan entre si, ahora vamos a conectarnos al NXT.

Conectando al NXT por bluetooth con NXT-G

La conexión desde NXT-G es muy intuitiva, sólo debemos tener el cuenta que el NXT no debe estar conectado previamente con el MAC (sí emparejado, no confundir los dos términos).

Seleccionamos la opción Visualizar NXT en el menú de la parte inferior derecha

Cuando se nos abra la ventana, le damos a Buscar

Entonces nos saltará una ventana de sistema que nos preguntará qué dispositivo queremos añadir a la lista de conexiones de NXT-G

Buscamos el nuestro en la lista y le damos a Seleccionar. Aquí es donde la búsqueda difiere de Windows, si recordáis, Windows nos muestra una lista de todos los que encuentra disponibles, sin embargo MAC sólo nos muestra los que le indiquemos.

Una vez seleccionado, pasará a nuestra lista de NXT-G, donde le damos a Conectar (si está Disponible, claro).

En unos segundos, si todo ha ido bien, tendremos esta pantalla

Conectando al NXT por bluetooth con LeJOS

Si no tenéis LeJOS y queréis usarlo en vuestro MAC, podéis seguir el tutorial de instalación de LeJOS en MAC.

Por defecto, la versión 0.85 de LeJOS para MAC lleva incluida la librería BlueCove 2.1.0, que nos permitirá conectarnos por bluetooth a nuestro dispositivo sin problemas.

Abrimos la terminal y tecleamos

(nosotros lo tenemos instalado en Home)

Con esto estamos dentro de la carpeta de ejecutables de LeJOS.
Ahora, el comando

Esta utilidad te permite monitorizar las conexiones y la salida de consola del NXT.

Seleccionamos como tipo de conexión Bluetooth, introducimos el nombre del NXT (el nuestro se llama Mac) y le damos a Connect. El campo Address se puede dejar en blanco, realizará la búsqueda por nombre.

Puede que te pida la clave de emparejamiento (el NXT tiene por defecto 1234), introdúcela y dale a Emparejar (Pair).

Tras unos segundos, nos aparecerá esta pantalla indicando que todo ha ido bien.

Si esta utilidad no os convence, o no funciona correctamente, podéis probar con el comando

-b fuerza a la aplicación a realizar una búsqueda de dispositivos bluetooth (-u es lo mismo pero para USB).
Debería localizarlo correctamente, después, simplemente le damos a Connect

Esta otra aplicación nos permite, no sólo conectarnos al NXT, si no también administrar sus archivos, cargar y descargar programas o incluso ejecutarlos, cambiarle el nombre al ladrillo, etc…

Con esto terminamos el tutorial de conexión Bluetooth, si tenéis cualquier duda o problema, podéis acudir al foro.

English

Ya hemos visto cómo instalar LeJOS en Windows y en Linux, hoy vamos a ver un pequeño tutorial sobre cómo se instala LeJOS en nuestro Mac. Además, en este artículo, daremos un repaso a los comandos principales de LeJOS que nos permitirán trabajar con este lenguaje sin necesidad de una interfaz gráfica.

Para ello vamos a seguir una serie de pasos muy sencillos:

1. Instalar Java
2. Instalar el Driver USB de LEGO para MAC
3. Instalar y configurar LeJOS
4. Conectar el NXT y descargar firmware LeJOS
5. Usar LeJOS con línea de comandos

1. Instalar Java

En MAC java viene pre-instalado, por lo que simplemente deberemos asegurarnos de tenerla última versión (en el momento de escribir este tutorial es la 1.6), para ello vamos a y seleccionamos “Actualizaciones de Software”.

2. Instalar el driver USB de LEGO para MAC

Para que nuestro MAC reconozca el NXT en modo restauración de firmware, tendremos que instalar el parche desde la página de soporte de LEGO Mindstorms

Nombre del parche: Mac Leopard Fix

3. Instalar y configurar LeJOS

Vamos a la Página oficial de LeJOS y descargamos la versión para Mac/Linux.
Extraemos la carpeta donde queramos, en nuestro caso lo hemos hecho en el directorio Home

Ahora debemos configurar las variables de entorno para Java y LeJOS, para ello abrimos una consola (o Terminal) e introducimos el siguiente comando

Esto nos permitirá crear el fichero .profile, o editarlo si ya existe. Tecleamos nuestra clave de administrador y escribimos en él las siguiente líneas

La primera línea es la ruta donde está instalado JAVA.
La segunda es la ruta donde tenéis la carpeta lejos_nxj
La tercera sólo es necesaria para usar el plugin de Eclipse (que veremos en el próximo artículo)
Y la última añade las carpetas bin para LeJOS y JAVA

CTRL+X para salir (nombre de archivo .profile) y Yes para salvar los cambios. Al pulsar intro volveremos a la consola.

Ahora debemos dar los permisos apropiados al directorio bin. Para ello accedemos a lejos_nxj/bin

(suponiendo que lo tengamos en Home)
Y ejecutamos el comando

Para que los cambios que hemos hecho tengan efecto debemos reiniciar nuestro ordenador.

NOTA
Si tenéis instalado Snow Leopard en vuestro Mac y no os funciona LeJOS tras terminar la instalación, sustituid los archivos de la carpeta lejos_nxt/bin por estos bin_lejos_snow_leopard. Es un fichero zip, basta con descargarlo, extraerlo y sustituir la carpeta.
¡OJO! Tendréis que volver a cambiar los permisos de la carpeta.
Estos ficheros están modificados para forzar a Java a ejecutarse a 32 bits a fin de ser totalmente compatible con LeJOS.
Para usuarios de versiones anteriores de Mac OS este parche no es necesario.

4. Conectar el NXT y descargar firmware LeJOS

Una vez lo tenemos instalado y configurado, vamos a probarlo.

Primero vamos a ver si podemos conectarnos con nuestro NXT, para ello, con el cable USB conectado, tecleamos en la consola el siguiente comando

Y nos aparecerá una ventana como esta

Seleccionamos nuestro NXT y le damos a Connect. Una vez establecida la conexión, cerramos nxjBrowser y tecleamos en el terminal

Esto nos permitirá descargar el nuevo firmware en el NXT.

Seleccionamos “Start program” y le damos a Yes para borrar los archivos del NXT.
Cuando el proceso de descarga se haya completado, el firmware de nuestro NXT se ha sustituido por el firmware propio de LeJOS, por lo que ya podemos trabajar con él.

5. Usar LeJOS con línea de comandos

Vamos a crear nuestro primer programa, el clásico Hello World, pero vamos a hacerlo usando la consola.

Abrimos nuestro editor de textos preferido, en nuestro caso hemos usado rText y escribimos lo siguiente

En la línea 4 hemos usado el método estándar System.out.println de Java, ya que LeJOS puede trabajar con él sin problemas, enviando la salida a la pantalla LCD.

Guardamos el archivo como HelloWorld.java

- Para compilarlo tecleamos desde la consola

Tras esto nos aparecerá un archivo HelloWorld.class en la misma carpeta donde estuviera el archivo .java

- Para linkarlo debemos usar

English

El objetivo de este artículo es realizar un vehículo controlado remotamente por bluetooth mediante LeJOS. La novedad de este proyecto es que es el primero que realizamos cuya tracción no es diferencial (como los anteriores).

Mientras que los vehículos con tracción diferencial como el tribot son capaces de cambiar su dirección ajustando la velocidad de los motores, este vehículo cuenta con un motor que se encarga exclusivamente de la dirección ya que los otros dos se encargarán exclusivamente de dar potencia (para dar tracción emplearemos dos motores en lugar de uno solo).

Como mando usaremos el joystick que ya hemos empleado en otros artículos, que se comunicará con nuestro kart mediante bluetooth. Cada vez que haya una diferencia significativa en los tacómetros de los motores del joystick (lo que significará que hemos movido el joystick), este enviará una señal al kart para que gire la dirección, o acelere, según el eje del joystick que hayamos movido.

Comunicación Bluetooth en LeJOS:

En primer lugar os recomiendo que os leáis el artículo Manejo de Bluetooth en LeJOS en el que se explica como comunicar dos NXT mediante bluetooth para enviar cualquier tipo de información. En este caso lo que enviaremos serán datos del valor de los tacómetros de los motores del joystick, los cuales nos indican la cantidad de de grados que queremos girar, o cuanto aumentar la velocidad.

El envío de los datos entre los NXT se hace mediante un buffer, una especie de túnel en el que un NXT va metiendo datos por un lado y el otro los recoge por el otro lado. Es posible que la comunicación no desarrolle como queramos debido a diversos factores. Uno de los más comunes es que el NXT que envía información lo haga más rápido que el tiempo que tarda el NXT que la recibe en procesarla. Esto crea un problema serio, ya que el buffer se irá llenando de información, y llegará un momento que no pueda meter más y se empiecen a perder datos. Además como el receptor recibe más datos de los que tiene tiempo de procesar, se generará un retardo que irá en aumento, traduciéndose en un comportamiento no deseado.

Este es nuestro vehículo:

Control del Kart:

El control de la velocidad del Kart esta manejado por la clase navigator de LeJOS (que nos asegura que los dos motores A y C, que se encargan de la velocidad del Kart, se muevan a la misma velocidad). El control no es directo, sino que tiene velocidad aumentada gracias a un sistema de engranajes. La velocidad del kart se basa en el giro que experimenta el joystick en uno de sus ejes (el controlado por el motor A).

Detalle de los motores de tracción:

El control de la dirección es directo desde el motor B del NXT. Dado que existe una limitación mecánica del angulo máximo de giro, el programa debe tenerla en cuenta para evitar que el motor intente girar más de lo que mecánicamente es posible, bloqueándose. El ángulo girado pretende seguir al giro que experimenta el joystick en uno de sus ejes (el controlado por el motor B).

Detalle del sistema de dirección:

Programa:

La implementación consiste en dos programas, uno para el kart y otro para el joystick. Ambos programas se comunicarán mediante bluetooth por un buffer. El joystick será el encargado de enviarle cuantos grados ha girado en sus ejes, y el kart el encargado de recibir dicha información, procesarla, y transformarla en movimiento.

Los primeros experimentos que hicimos intentando controlar la dirección no daban el resultado que pretendíamos. Esto era debido a que estábamos enviando una gran cantidad de datos por el buffer, y el kart no era capaz de procesarlos a la velocidad suficiente, lo que creaba un retardo cada vez mayor entre el movimiento del joystick y la respuesta del kart. Por eso hemos hecho un método en el que el joystick solo envía información cada cierto tiempo, y si la posición del joystick a cambiado, por lo que no estará enviando datos todo el rato aunque el joystick esté quieto.

También se han resuelto otros problemas como el de la transmisión comentado anteriormente, y se han hecho procesamientos con los datos para que el control fuera más sencillo. Aún así los programas son aún mejorables, y los modificaremos para reducir problemas como el del retardo, y para finalmente poder participar en la competición de karts de la semana que viene con el único kart controlado remotamente hecho en exclusiva con NXT.

Aquí os dejo el código del mando:

Y el del kart:

Aquí tenéis un vídeo del funcionamiento

Son códigos de cierta complejidad, así que si tenéis alguna duda podéis preguntarnos en el foro.

English

Uno de los problemas que tienen cualquier sistema que tenga que desplazarse, y en particular un robot NXT móvil, es la deriva en la navegación. La deriva es el desvío de la trayectoria real respecto de la trayectoria prevista, y se debe a diversos factores. Cuanto menos deriva tenga un robot más preciso será su desplazamiento y menos se desviará de su destino objetivo al finalizar el movimiento. Este problema es muy común con los LEGO Mindstorms NXT debido a que no son robots con una forma única, sino que hay muchos montajes diferentes de robots móviles. La forma en que estén implementados los programas también influye en esta deriva.

Cosas que influyen en la deriva:

En el aspecto físico del robot hay muchas cosas que influyen en la deriva. Influye por ejemplo la diferencia de tamaño entre las ruedas, aunque está sea mínima porque una está mas hinchada que otra. Influye el peso del robot en gran medida, y por supuesto el cómo está distribuido este peso. Es importante que el mayor peso posible se encuentre sobre las ruedas tractoras, lo que impedirá que el robot se desvíe de su camino porque le pese demasiado la parte de delante o de atrás:

Influye la solidez del vehículo, que no modifique su forma mientras se va desplazando, su simetría. Otro aspecto importante es que no tenga rozamiento con nada, ya que el mínimo rozamiento podría crear una modificación de la trayectoria. La velocidad es bastante importante también, un vehículo que se desplace rápido es mucho más difícil de controlar que uno que lo haga lentamente.

La parte de implementación es también muy importante, por ejemplo si está usando dos motores para desplazarse, ambos deben ir con la misma potencia y velocidad. También es importante que a la hora de arrancar lo hagan simultáneamente, o el robot comenzará a moverse ya desviado de la trayectoria. Así mismo es importante que se detengan simultáneamente cuando el robot tenga que parar.

A pesar de todas estas precauciones es difícil mantener determinada trayectoria de forma continuada. Por ejemplo es imposible mantener a un robot realizando desplazamientos en forma de cuadrado de manera indefinida, y que siempre vuelva al mismo punto de partida, lo que pasará es que en cada vuelta el robot se desviará más y más hasta que ya nunca pase por su posición inicial.

Clase Pilot, la mayor precisión:

Una de las maneras de alcanzar una precisión muy alta a la hora de desplazar el robot es mediante la clase Pilot de LeJOS. Esta clase, que ya introduje en el artículo Manejo de motores avanzado: clase Pilot, introduce una nueva forma de manejar el robot. Lo primero que se hace es configurar un objeto de esa clase indicando que motores vamos a utilizar (dos motores, ya que esta clase esta solo diseñada para tribots), que distancia hay entre los puntos medios de las ruedas, y el diámetro de la rueda:

Aunque las ruedas de los NXT tiene un diámetro de 5.6 cm es importante que pongáis un poco menos, sobre todo si vuestro robot pesa mucho, ya que el peso hace que las ruedas se aplanen un poco. La distancia entre las ruedas debe ser bastante precisa, ya que es de vital importancia sobre todo a la hora de las rotaciones.

A los métodos ya comentados en el artículo sobre la clase Pilot es importante añadir:

void setMoveSpeed(float distancia): Establece la velocidad del robot a la distancia que pongamos por segundo. Por ejemplo si ponemos 5, se moverá a 5 cm por segundo (que seán cm, pulgadas o una medida distinta solo depende de que tipo de medida hayamos usado para configurar el Pilot).

void setTurnSpeed(float grados): Establece la velocidad del robot, pero en este caso es en grados por segundo. Si ponemos 360 las ruedas realizarán una rotación completa por segundo.

Es importante controlar la velocidad, ya que si vemos que nuestro robot no es capaz de moverse con precisión a cierta velocidad deberíamos reducirsela. Otro método útil es:

void steer(float velocidad_giro, float angulo, boolean devolverControl): El robot se mueve en una trayectoria curva a la velocidad de giro indicada hasta que complete el número de ángulos deseado. Si devolver control es True el robot seguirá ejecutando las siguientes líneas de código mientras gira. No hace falta indicarle un angulo, si omitimos este campo el robot girará indefinidamente, o hasta que lo detengamos con otra instrucción.

Programa de prueba:

Para probar la precisión de la clase Pilot he creado un programa que describe un gran rectángulo de 240 cm. Cuanto más cerca quede el robot de la posición inicial más preciso será el programa. Además contamos con un montaje simétrico, relativamente ligero, y con la mayoría del peso sobre las ruedas tractoras. La rueda trasera no es la mejor posible, pero hace bien su función. El programa es el siguiente:

Aquí tenéis el vídeo demostrativo del programa, en el podéis ver que la deriva es mínima (apenas un centímetro), habiendo recorrido 240 cm. y realizado tres rotaciones de 90º:

Ante cualquier duda podéis preguntar en el foro.

English

Ya hemos comentado en otros artículos la forma de instalar dos entornos de desarrollo para trabajar con LeJOS, el Eclipse y NetBeans. JCreator es otro entorno de desarrollo que incorpora un amplia abanico de funcionalidades. Matthias Paul Scholz, uno de los desarrolladores del proyecto LeJOS NXJ, la plataforma Java para el NXT, ha creado un pequeño tutorial sobre cómo poner a punto JCreator para poder emplearlo con LeJOS NXJ.

JCreator es otro entorno de programación para Java que tiene tanto una versión comercial como otra gratuita y que puede conseguirse en la sección de descargas. Matthias Paul Scholz ha creado un tutorial que explica el proceso completo de instalación, e incluye los siguientes apartados:

• Instalación de Java.
• Instalación de LeJOS NXJ.
• Instalación de JCreator.
• Cómo configurar JCreator para su uso con LeJOS NXJ.
• Creación de un proyecto, así como de una pequeña aplicación LeJOS NXJ.
• Descarga de un programa LeJOS al ladrillo NXT, así como del proceso de escritura del firmware.

Podeis descargar el tutorial (en inglés) de Setting up JCreator LE for programming the NXT.

Información adicional:

• Instalación de Eclipse en Windows en el artículo sobre la instalación de LeJOS en Windows.
• Idem sobre Instalación de LeJOS en Linux.
• NetBeans.

English

Tal y como vimos en el artículo de RobotC Vehículos de Braitenberg en RobotC los vehículos de Braitenberg fueron concebidos por el investigador Italo-Autriaco Valentino Braitenberg para ilustrar de manera evolutiva las habilidades de agentes simples. En el artículo de hoy implementaré un par de comportamientos de vehículos de Braitenberg en LeJOS

Repaso a los ejemplos de vehículos de Braitenberg:

Repetiré aquí los ejemplos más claros y sencillos de vehículos de Braitenberg :

Un primer agente tiene un sensor detector de luz que estimula directamente a su única rueda, implementado las siguientes reglas:

• Más luz produce un movimiento más rápido.
• Menos luz produce un movimiento más lento.
• La oscuridad produce que se quede quieto.

Este comportamiento puede ser interpretado como una criatura que teme a la luz y que se mueve rápido para salir de ella. Su objetivo es encontrar un hueco oscuro en el que ocultarse.

Un segundo agente algo más complicado tiene dos sensores de luz (izquierdo y derecho), cada uno estimulando a la rueda de su mismo lado. Obedece las siguientes reglas:

• Más luz en la derecha → la rueda derecha gira más rapido → gira hacia la izquierda, fuera de la luz.
• Más luz en la izquierda → la rueda izquierda gira más rapido → gira hacia la derecha, fuera de la luz.

Este es más eficiente como un comportamiento para escapar de la fuente de luz, ya que la criatura puede moverse en diferentes direcciones, y tiene a orientarse hacia la dirección desde la que procede menos luz.

En otra variación las conexiones son negativas o innovadoras:

• Más luz en la derecha → la rueda derecha gira más lento → gira hacia la derecha, hacia la luz.
• Más luz en la izquierda → la rueda izquierda gira más lento → gira hacia la izquierda, hacia la luz.

En este caso el agente huye de la oscuridad, moviéndose hacia la luz.

Configuración de motor y sensores de luz:

Aunque hasta ahora hemos estado usando los motores en LeJOS de la manera genérica (accediendo al atributo A, B, o C de la clase Motor), es posible definir los motores con el nombre que elijamos, los cual nos facilitará las cosas a la hora de manejarlos. Para ello usaremos el método constructor de la clase de objetos Motor. Esto se hace de la siguiente manera:

Motor nombre_motor = new Motor(MotorPort.puerto): Creamos un objeto de la clase Motor, cuyo su nombre será el indicado, y que estará anclado al puerto que hayamos elegido(A, B o C).

Respecto a los sensores de luz es importante decir que cuando se declaran (tal y como vimos en el artículo 6 de la serie LeJOS) están en modo activo (con el LED encendido. En estos programas no nos interesa que tengan el LED encendido, ya que nos interfiere a la hora de captar la luz ambiente. Para activarlo o desactivarlo existe el siguiente método de la clase LightSensor:

void setFloodlight(boolean encender): Enciende el LED en caso de que encender sea true, y lo apaga en caso de que encender sea false.

Con estos dos apuntes ya podemos programar nuestro vehículo de Braitenberg.

Vehículo de Braitenberg en LeJOS:

Como ya habréis supuesto los vehículos de Braitenberg no son problemas muy complejos de resolver con LeJOS. En este caso vamos a implementar el segundo comportamiento:

• Más luz en la derecha → la rueda derecha gira más rapido → gira hacia la izquierda, fuera de la luz.
• Más luz en la izquierda → la rueda izquierda gira más rapido → gira hacia la derecha, fuera de la luz.

Por tanto será un robot estilo cucaracha, que huye de la luz y se refugia en la oscuridad. Necesitaremos construir el robot con dos sensores de luz y dos motores. Es importante que los sensores de luz miren más o menos hacia los lados y no hacia adelante, o no podremos medir bien la cantidad de luz que proviene de cada lado. Con un ángulo de 45º es suficiente, como el robot que hemos construido nosotros:

A la hora de configurar los sensores de luz es importante que los pongáis en modo pasivo como os indiqué en el apartado anterior del artículo, para que la luz del LED no nos entorpezca en nuestro cometido. Ponedle nombres intuitivos a los motores y a los sensores, como motorDerecho, sensorIzquierdo… Así se os hará mucho más fácil programarlos, y ver qué es lo que falla en caso de problemas. El código del programa sería así:

Una pequeña explicación de algunas líneas:

8 - Aquí definimos un valor umbral de oscuridad, para el que creamos que nuestro robot-cucaracha está en un sitio suficientemente oscuro como para sentirse seguro y pararse. Este valor lo usaremos posteriormente en las líneas28 y 33.

18 y 19 - Recordad apagar los LED.

29 y 34 - Pondremos que la velocidad de los motores sea directamente proporcional a la cantidad de luz que recibimos, tal y como dice Braitenberg. En este caso será igual al cuadrado del valor leído menos un número que elijamos nosotros para moderar la velocidad, por ejemplo 200 o 300.

Y aquí tenéis este vídeo que nos ha quedado bastante chulo:

Ante cualquier duda podéis visitar el foro.

Netbeans es una plataforma que permite la creación de interfaces gráficas, y que es completamente compatible con LeJOS. Existe de hecho un plugin (complemento) de LeJOS para NetBeans, y además las carpetas de ejemplos de LeJOS viene ya preparadas para su compilación y ejecución en NetBeans. Gracias a NetBeans se pueden hacer aplicaciones como un mando radio-control para manejar nuestro robot desde el ordenador.

¿Qué es NetBeans?:

La plataforma NetBeans permite que las aplicaciones sean desarrolladas a partir de un conjunto de componentes de software llamados módulos. Un módulo es un archivo Java que contiene clases de java escritas para interactuar con las APIs (interfaces de programación de aplicaciones) de NetBeans y un archivo especial (manifest file) que lo identifica como módulo. Las aplicaciones construidas a partir de módulos pueden ser extendidas agregándole nuevos módulos. Debido a que los módulos pueden ser desarrollados independientemente, las aplicaciones basadas en la plataforma NetBeans pueden ser extendidas fácilmente por otros desarrolladores de software.

Compatibilizar NetBeans con LeJOS:

Lo primero que necesitamos es descargar e instalar NetBeans, para ello iremos a la página de descargas de NetBeans y nos descargaremos el paquete de Java, que contiene ya todo lo necesario para desarrollar nuestras aplicaciones:

Página de descargas de NetBeans

Una vez descargado e instalado empezaremos por abrir y probar los programas de ejemplo que vienen ya en la carpeta de ejemplo de LeJOS preparados para su uso en NetBeans. Para ello elegimos Archivo, Abrir Proyecto… :

y buscamos las carpetas samples y pcsamples que estarán en la carpeta de ejemplos de LeJOS (por defecto será …\Mis Documentos\\leJOSNXJProjects . Una vez abiertos deberia quedar algo así:

Ahora vamos a probar uno normal y otro de PC. Si os dais cuenta dentro de cada carpeta de proyecto hay un archivo llamado build.xml. Si clickeaís con el botón derecho en él y le dais a Ejecutar destino veréis que os muestra todas las opciones de de compilación, linkado, subida … tal y como podéis ver en la imagen anterior.

Vamos a probar un programa de samples, el BlueStats por ejemplo. Es importante que tengáis el robot conectado por USB, para saber como podéis revisar mis artículos anteriores sobre Bluetooth. Hacéis click derecho en el build.xml y le dais a a Ejecutar destino, uploadandrun. El programa entonces se compilará, linkará, subirá y ejecutará en el NXT. Este programa lo que hace es mostrarte las estadísticas de la conexión Bluetooth con el NXT.

Ahora probaremos otro de los de pcsamples, el que se llama TachoCount. Los programas de pcsamples funcionan de forma diferente, primero necesitas hacer click derecho en el build.xml de la carpeta global de pcsamples, y le dais a Ejecutar destino, build. Una vez hecho esto os metéis en la carpeta individual del programa (TachoCount en este caso) y le dais click derecho, Ejecutar archivo:

Para este programa necesitaréis un motor en el puerto A y otro en el puerto C. Lo que hace dicho programa es mostrar el valor del tacómetro de A y C, rotar luego cada motor, y finalmente volver a mostrar el valor de los tacómetros.

Instalación del Plugin de LeJOS:

Aunque mi recomendación es que creéis vuestros programas dentro de carpetas de programas de ejemplos, ya que tenéis asegurado que se puedan compilar y ejecutar bien, es posible crear nuestros propios programas por separado, y para ello necesitamos el plugin de LeJOS para NetBeans. Para instalar dicho plugin tenéis que hacer lo siguiente: meteros en Herramientas, Complementos y en la ventana que os sale darle a Descargado, Añadir Plugin… y buscáis el archivo NXJPlugin/build/nxjplugin.nbm que esta en la carpeta de ejemplos de LeJOS:

Le dais a instalar, y decís que si a todo. Una vez instalado podremos crear Proyectos de LeJOS de la siguiente manera: le dais a Archivo, Proyecto Nuevo, Ejemplos, NXJProject:

Es importante que creéis el proyecto en la carpeta de ejemplos de LeJOS. Una vez finalizada la creación tendremos un proyecto plantilla con el programa HelloWorld.java y el archivo build.xml con las opciones de compilación y ejecución. Es importante que añadáis la ruta de las librerías de LeJOS. Para ello haced click derecho en vuestro proyecto, Propiedades…, Ruta de clases de fuentes Java, Añadir JAR/Carpeta… y seleccionas classes.jar de vuestra carpeta de instalación de LeJOS (por defecto estará en C:\Archivos de programa\leJOS NXJ\lib:

También deberéis variar las rutas escritas dentro del archivo build.xml para que coincidan con las de vuestra instalación.

Una vez hecho todo esto podréis modificar esta plantilla como os plazca para crear vuestro propio programa. Daos cuenta que no se pueden hacer programas para pc de LeJOS mediante este método, solo los de NXT.

¿Cómo crear un programa para LeJOS con interfaz gráfica?: Un pequeño control remoto

Para crear un programa con interfaz gráfica usaremos una carpeta ya preparada de las de ejemplos para PC, como por ejemplo la de TachoCount. En ella crearemos lo que se denomina un Form, para lo que haremos click derecho en la carpeta TachoCount, Nuevo.., Formularios de Intefaz gráfica de Swing, Formulario JDialog:

Una vez tengamos el form le pondremos varios botones: Uno para conectar, otro para desconectar, otro para mover el motor A, otro para el C, y otros dos para pararlos. Para añadir botones solo los tenéis que arrastrar de la paleta:

Y podéis renombrarlos en Propiedades después de seleccionarlo, que se encuentra debajo de la paleta:

Una vez añadidos los botones vamos a modificar el código. Para ello darle a Fuente:

Y lo primero que pondremos son la importación librerías que necesitamos (podéis copiar las de TachoCount). Abajo del todo nos crearemos también la variable privada conn que usaremos como conexión:

Una vez hecho esto volver a darle a Diseño. Para poner que hace cada botón al clickear en el damos click derecho en el botón, Eventos, Action, actionPerformed…; esto creará un método y nos llevará a Fuente para que lo programemos. A continuación os pondré el código para cada botón:

Conectar:

14 – Recordad poner el nombre de vuestro NXT (NXTTorna es el nombre del que estoy usando yo).

Desconectar:

Motor A:

Motor C:

Parar A:

Parar C:

Para compilar recordad hacer click derecho en el build.xml de la carpeta global de pcsamples, y darle a Ejecutar destino, build. Una vez hecho esto os metéis en la carpeta individual del programa y le dais click derecho, Ejecutar archivo al Form. Os debería salir una ventana de este estilo:

Con la que podéis controlar a vuestro robot.

Sé que el artículo de hoy es extenso y complicado, así que os pido que si tenéis alguna duda por favor escribáis en el foro.

English

En el artículo anterior vimos que es posible comunicar PC y NXT gracias a las librerías de LeJOS. Hoy vamos a mostrar cómo conectar y manejar varios NXT simultáneamente, y la diferencia respecto a manejar varios NXT desde otro NXT, como su mucha menor latencia.

Comunicación con el PC:

Como puse en el artículo anterior, para comunicar cualquier dispositivo Bluetooth con el ordenador necesitamos un adaptador Bluetooth para el ordenador, que puede estar integrado en la placa base, o se puede adquirir por separado. Para ver cómo echadle un vistazo a dicho artículo.

Las ventajas de conectar varios NXT a un PC en lugar de a otro NXT maestro son claras: no tenemos problemas de latencias tan altas como las comunicaciones NXT-NXT, tenemos un número prácticamente ilimitado de conexiones en lugar de las tres máximas que acepta un NXT, y además la potencia de cálculo de un ordenador no es comparable con la de un NXT. Podríamos incluso crear un interfaz gráfico para manejar un NXT radio-control desde el PC.

Lo mejor del tipo de comunicaciones que vamos a usar es que no necesitamos subir ningún programa al NXT, todo lo hacemos desde el PC, lo cual nos facilita muchas cosas, desde las comunicaciones hasta la velocidad para realizar cálculos complejos.

En el artículo anterior ya mostré qué métodos se utilizan para realizar la conexión, por tanto si queremos conectarnos con varios NXT sólo tendremos que repetir el proceso de conexión varias veces, asegurándonos de que todos los NXT se han conectado correctamente con el PC. Es importante dejar un retardo después de realizar varias conexiones, de forma que nos aseguraremos que todos están listos para recibir ordenes.

Una vez estén todas las conexiones listas podemos dar ordenes a uno u otro NXT indistintamente. Recordad que para elegir a cuál vais a dar una instrucción es necesario usar antes el método:

poniendo en nombre_conexión el nombre que le hayamos dado a la conexión que queramos utilizar (Ej.: conn1, conn3, …). Usad este método cada vez que queráis cambiar el objetivo de vuestras ordenes. Por ejemplo, si quiero mover el motor A con dos NXT, cuyas conexiones son conn1 y conn2 sería:

Es MUY importante que al final del programa cerréis las conexiones con el método close() o el PC no os conectará con los NXT la segunda vez que queráis usar el programa (tendrías que apagar y encender los NXT en su lugar).

Programa de ejemplo:

En el programa de ejemplo vamos a hacer que el ordenador ordene a dos NXT moverse simultáneamente describiendo un cuadrado. Es importante que la forma de los robots sea la misma para que quede bien, ya que si la distancia entre las ruedas es mayor, o uno pesa más que otro ya no se moverían igual.

No estamos utilizando la librería Navigation de LeJOS, por lo que el cálculo del cuadrado lo hemos hecho aproximado, rotando los motores un número determinado de grados. Lo importante es que este programa consigue mover simultáneamente los dos robots desde el PC, cosa que sería imposible desde otro NXT debido a las latencias. El código sería el siguiente:

Este tampoco es un programa muy complejo, si tenéis alguna duda sobre el manejo de motores en LeJOS os recomiendo el este artículo. Aquí os dejo un vídeo demostración del funcionamiento de este programa, que como podéis ver hace que los NXT se comporten de manera casí simultánea:

Por último, insistir en que si tenéis alguna duda posteadla en el foro. Un saludo y hasta otro artículo.

Hasta ahora hemos visto cómo comunicar varios NXT entre sí y enviar información de uno a otro, pero también es posible comunicarnos con un NXT mediante el PC, dándole instrucciones ya sea mediante mediante comandos, o creando un UI (Interfaz de Usuario) con botones y consola propia. Es cierto que estas comunicaciones son más complejas que las que se realizan habitualmente entre los propios NXT, pero también son muchas las posibilidades que nos proporcionan.

¿Cómo comunicarnos con el PC?:

Para comunicar cualquier dispositivo Bluetooth con el ordenador necesitamos un adaptador bluetooth para el ordenador, que puede estar integrado en la placa base, o se puede adquirir por separado (normalmente del tipo mochila USB). Si ya tenéis uno seguramente lo habréis usado alguna vez para descargar programas al NXT en vez de usar el USB.

Una vez tengamos un adaptador USB es importante agregar el dispositivo Bluetooth a la lista de “Mis sitios Bluetooth”. Para ello encender el NXT, hacer doble click en el simbolo de Bluetooth de la barra de herramientas de Windows y en el menú que se despliega darle a “Agregar dispositivo Bluetooth”. Una vez lo haya encontrado lo seleccionamos, metemos la clave del NXT (por defecto 1234) y nos conectamos. Llegado a este paso ya estaremos listos para la comunicación entre el PC y el NXT.

Comunicación entre PC y NXT en LeJOS:
Los protocolos de comunicación en LeJOS entre PC y NXT se encuentran en una libreria llamada pccomm.jar, que será la que en este caso tendremos que añadir a nuestro proyecto en lugar de classes.jar (Mirar artículo de instalación de LeJOS para saber cómo). Luego tendremos que importar las siguiente librería dentro de nuestro programa:

Ahora podremos iniciar la comunicación. Para ello lo primero es crear un objeto de la clase NXTConnector:

De esta forma ya nos podemos conectar con el NXT: para ello utilizaremos el protocolo de comunicaciones de LEGO LCP (LEGO MINDSTORMS NXT Communications Protocol). El método sería el siguiente:

boolean connectTo(”nombre_NXT”, NXTComm.LCP): Conecta el PC con el NXT usando el protocolo de comunicaciones de LEGO MINDSTORMS NXT. Devuelve false en caso de que la conexión falle.

Una vez conectado necesitaremos ser capaces de usar métodos como si de un programa normal se tratase, y que el ordenador los envíe y el NXT los entienda. Para ello usaremos siguiente método:

Este método es muy importante, porque traduce todos los comandos que se encuentran a continuación en el programa al LCP, para que puedan ser ejecutados en el dispositivo remoto, en este caso un NXT. Es decir, estas líneas de código que se están ejecutando en el PC están enviando los comandos que se encuentran en las siguientes líneas de programa, a continuación de ésta, al NXT para su ejecución en él. Una vez hecho esto ya podremos usar métodos como si de un programa de NXT se tratara como, por ejemplo, Motor.A.forward(). El último paso necesario es el de cerrar la conexión existente entre el PC y el NXT. Para ello haremos uso del método close().

Compilar programas para PC de LeJOS:

Los programas en LeJOS que se van a ejecutar en el PC se compilan de forma especial (no con javac como la mayoría de programas en java). Si os acordáis de el artículo de instalación de LeJOS explique cómo crear configuraciones propias de compilación y ejecución. De hecho en ese tutorial se enseña cómo crear las dos que después hemos usado para todos los programas.

Para compilar y ejecutar programas para PC en LeJOS necesitaremos crear otras dos nuevas configuraciones. Estás configuraciones son tal y como se muestran en las siguientes imágenes:

Por tanto las usaremos para compilar y ejecutar nuestro programa de PC en LeJOS.

Programa de ejemplo:

En el programa de ejemplo vamos ha hacer que el ordenador muestre por pantalla el valor del tacómetro (recordad el manejo del tacómetro en el artículo sobre el sensor de ultrasonido), ordene al NXT que gire el motor A y B, y una vez finalizado muestre los nuevos valores de los tacómetros. Este programa es bastante sencillo y se ve el funcionamiento básico del protocolo de comunicaciones, así como escribir información por la consola del PC (de eclipse en este caso). El código del programa es el siguiente:

Ahora explicaré brevemente algunas líneas:

10 - Si la conexión resulta fallida (! es el símbolo de negación en Java):

11 - Muestra el mensaje de error Conexión Fallida por consola, y

12 - Detiene la ejecución del programa (el hecho de salir con “1″ significa que ha habido error en el prográma, es un estándar universal en programación.

14 - Se trata de la línea más importante, que hemos explicado anteriormente, y es la que envía el código posterior a esta línea para su ejecución remota en el NXT al que nos hemos conectado previamente.

18, 19, 23 y 24 - Esta es la manera universal de mostrar información por consola (pantalla) en Java. Entre comillas para las cadenas de texto, y usando el símbolo + para concatenar elementos.

Como veis no es un programa muy complejo, el resultado por consola debería quedar algo así:

Por último insistir en que si tenéis alguna duda posteadla en el foro. Un saludo y hasta otro artículo.

En esta segunda parte del artículo voy a explicar la forma de conectar varios NXT por Bluetooth (más de dos), su utilidad, y sus limitaciones. Veremos principalmente el problema de la latencia (el tiempo que tarda en establecer conexión con otro NXT).

Manejo de Varias Conexiones:

En el artículo anterior vimos que es posible conectar varios NXT mediante el Bluetooth, sin embargo existe una limitación implícita: un ladrillo NXT sólo puede tener una conexión de maestro y tres de esclavo. El maestro es el encargado de enviar información a los esclavos, y los esclavos se encargarán de actuar según las ordenes que hayan recibido. Todo esto lo podéis ver con claridad en nuestro artículo sobre robots repetidores en NXT-G. El problema principal es que para comenzar una nueva conexión debe cerrarse la anterior, y el NXT tarda varios segundos (entre 1s y 2s) en realizar las conexiones, lo que impide ciertas aplicaciones como de control simultáneo de varios NXT desde un NXT maestro. Las conexiones Bluetooth entre ordenadores son muchísimo más rápidas.

Programa de pruebas:

Gracias a este programa podemos ver la latencia (tiempo que tardan las conexiones que el Bluetooth en realizarse entre los NXT). Tenemos tres programas (uno para cada ladrillo NXT): el primer programa esperará a que pulsemos el botón ENTER, y una vez pulsado se conectará al segundo NXT, enviándole la información de que hemos pulsado el botón. El segundo esperará a recibir esta información, actuará moviendo el motor y haciendo un sonido, y enviará la información al tercero. Finalmente el tercero recibirá esta información y actuará en consecuencia. El código del primer NXT es:

14 - El nombre del NXT al que se va a conectar tiene que ser el correcto. En nuestro hemos empleado estos nombres puesto que son como se llaman los NXT que estoy utilizando en el experimento.

El del segundo es:

El del tercero sería: