electricBricks» programación Archives – electricbricks – Educación basada en LEGO

Controlar un NXT con comandos de Voz. MAC + LeJOS

Dani — Wed, 21 Jul 2010 22:02:45 +0000

¿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:

LegoNXTRemote para Mac

NXTVoiceCommander para Windows, que utiliza el software de reconocimiento de voz tazti para Windows XP/Vista

Nosotros queremos enseñaros a programar vuestro propio control de voz en MAC, utilizando LeJOS.

Para conseguirlo hemos utilizado el sistema de reconocimiento de voz que viene de serie en MAC OS X. Este programa nos permite, no sólo utilizar comandos predefinidos del sistema, si no crear nuestros propios comandos de voz. Estos comandos, programados en AppleScript, son capaces de ejecutar código en nuestro ordenador, vamos a utilizar esta capacidad para darle las instrucciones en el ordenador.

Aquí tenéis un vídeo para que veáis que funciona.

Subiremos uno con mejor calidad tan pronto como sea posible…

Ahora vamos a lo importante… ¿Cómo funciona?

Reconocimiento de Comandos de Voz + AppleScript + LeJOS = movimiento del robot

Utilizamos comandos de voz personalizados que nos permiten ejecutar código, en este caso vamos a ejecutar un programa de LeJOS capaz de conectarse vía bluetooth al NXT, enviando instrucciones a los motores.

Nuestro robot admite 5 comandos de voz:

Adelante: Up

Atrás: Down

Derecha: Right

Izquierda: Left

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.

¿NXT como catálogo de productos?

Dani — Wed, 21 Jul 2010 15:09:20 +0000

Eso es exactamente lo que hace este original programa de nuestro forero CSM. Basado en el programa de la calculadora NXT-G y con mucha paciencia, ha introducido 33 referencias distintas del stock de electricBricks en su catálogo virtual, ¡y con precios actualizados!. Al introducir el código del artículo, tendremos, no sólo el precio, si no también una imagen del producto.

Toda la programación se ha realizado en NXT-G, utilizando la versión comercial 2.0, más concretamente la herramienta de edición de imágenes que esta nueva versión lleva integrada.

El esquema del programa es el siguiente:

1. Presentación del catálogo
2. Nos pide los 4 dígitos del artículo (uno a uno) y opera los cuatro dígitos independientes para obtener uno de la siguiente manera Número final= ((Cifra 1*10 + Cifra 2)*10 + Cifra 3) *10 +Cifra 4, de esta manera, el sistema nos va mostrando los números que hemos ido introduciendo en la parte superior, según los elegimos, ordenados de izquierda (el primero) a derecha (el último).
3. Comprobación de si el artículo está (o no) en el catálogo, para esto hace uso de la estructura case que se trabajó en la calculadora.
4. Por ultimo, tras mostrarnos el artículo, o el mensaje de error correspondiente en caso de que el artículo no exista en la Base de Datos (estructura case). Nos preguntará si queremos mirar otro artículo.

Como podemos apreciar, el funcionamiento es muy sencillo, y la programación encapsulada en Mis Bloques hace que todo sea mucho más claro y también más fácil de modificar.

Vamos a ver en detalle los bloques

Bloque Presentación

Bloque Variables

Bloque IntroNum

Bloque list

Bloque otro

Por último un vídeo del funcionamiento

Instalación de Eclipse para LeJOS en Mac

Dani — Tue, 20 Jul 2010 18:41:30 +0000

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:

Java Build Path

En la pestaña Libraries, seleccionamos la opción “Add External JARs”

Debemos añadir el archivo classes.jar que se encuentra en el directorio lejos_nxj/lib

NOTA: Con LeJOS 0.85 y Java versión 1.6 (la más actual en el momento de escribir este artículo) NO hace falta modificar nada en el apartado Java Compiler del menú Propiedades

Si tenéis una versión anterior, se recomienda esta configuración:

Ahora ya tenemos los archivos necesarios configurados, así como el compilador, vamos a hacer los ajustes finales para utilizar LeJOS en Eclipse.

Vamos a Run – External Tools – External tools Configurations…

Y creamos una nueva configuración con el botón “New Launch Configuration”

Aquí vamos a crear dos configuraciones distintas, es importante fijarse bien, y poner las confiruraciones tal y como están en las imágenes, o no funcionará correctamente:

lejos_Compile

lejos_Download

Una vez creadas, aplicamos los cambios y cerramos la ventana.

Por último, vamos a crear unos accesos directos para tener estas herramientas a mano cuando nos hagan falta, para ello vamos a Run – External Tools – Organize Favorites

2. Nuestro primer programa: “Hola Mundo”

Para poder hacer el programa, primero tendremos que añadir la clase correspondiente, para eso vamos a File – New – Class

Es importante que en el campo Source Folder indiquemos NombreProyecto/src, además damos a nuestra clase el nombre correspondiente HolaMundo. Debemos marcar también la opción public static void main(String[] args).

Una vez creada la clase, tendremos un archivo HolaMundo.java dentro del desplegable NombreProyecto/src, lo abrimos y escribimos este código

1
2
3
4
5
6
7
8
9
10
11
12
13

import lejos.nxt.*;
public class HolaMundo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
LCD.drawString("Hola Mundo!", 2, 2);
LCD.refresh();
while(true);
}
}

Líneas 9 y 10: aquí hemos usado en método propio de LeJOS para mostrar datos en la pantalla.

Guardamos el archivo y le damos a nuestra recién creada configuración lejos_Compile para asegurarnos de que todo es correcto, y luego a lejos_Download para comprobar el resultado en nuestro NXT.

Para que lejos_Download funcione, podéis enchufar el cable USB o seguir el tutorial de conexión bluetooth para MAC y dejar que se descargue directamente por bluetooth. Ambos métodos funcionan.

Os dejo una captura de lo que muestra la consola de Eclipse al descargar por Bluetooth

Si tenéis cualquier duda o problema, podéis preguntar en el foro.

ROILA – RObot Interaction LAnguage

Dani — Mon, 19 Jul 2010 17:01:30 +0000

Recientemente hemos recibido noticias de un nuevo lenguaje de programación hablada para robots, entre los que se encuentra el NXT, se trata de ROILA. Este nuevo lenguaje está siendo desarrollado por la Universidad Tecnológica de Eindhoven, dispone de la colaboración de LEGO MINDSTORMS, y trata de llevar el reconocimiento automatizado de voz a los robots. Se trata de una idea de lo más interesante, y aunque se encuentra aún en desarrollo, la seguiremos muy de cerca para ver hasta dónde se puede llegar.

El uso del LEGO MINDSTORMS NXT como plataforma permite la creación de innumerables y variados robots, y el ROILA será una nueva forma de controlarlos y de abrir un nuevo abanico de posibilidades de comunicación.

La plataforma de reconocimiento de voz que están empleando es el Sphinx-4. Se trata de una decisión muy acertada, puesto que los creadores de ROILA programan el NXT en LeJOS, y el Sphinx-4 ha sido programado completamente en Java. Para los que hayáis programado haciendo uso del Eclipse, en este tutorial se explica cómo integrar Sphinx-4 en el Eclipse.

Este ambicioso proyecto también tiene prevista la posibilidad de que nuestros NXT puedan también hablar, para lo que harán uso de la plataforma open source conocida como Festival.

Información adicional:

Página oficial de Roila.
Sphinx-4, el reconocedor de voz escrito en Java.
Festival, sistema para la creación de voz artificial.

Conectar NXT por Bluetooth a MAC

Dani — Sat, 17 Jul 2010 08:35:39 +0000

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

1	cd lejos_nxj/bin

(nosotros lo tenemos instalado en Home)

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

1	./nxjconsoleviewer

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

1	./nxjbrowse -b

-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.

Instalación de LeJOS en MAC OS X

Dani — Wed, 14 Jul 2010 12:02:49 +0000

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

1	sudo pico .profile

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

1
2
3
4

export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home
export NXJ_HOME=/Users/Phoenix/lejos_nxj
export DYLD_LIBRARY_PATH=$NXJ_HOME/bin
export PATH=$PATH:$JAVA_HOME/bin:$NXJ_HOME/bin

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

1	cd lejos_nxj/bin

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

chmod +x*

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

1	nxjbrowse -u

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

nxjflashg

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

1
2
3
4
5
6
7
8

import lejos.nxt.*;

public class HelloWorld {
public static void main (String[] args) {
System.out.println("Hola Mundo");
Button.waitForPress();
}
}

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

1	nxjc HelloWorld.java

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

- Para linkarlo debemos usar

1	njxlink -v HelloWorld -o HelloWorld.nxj

La etiqueta -v, no es imprescindible, pero nos permite ver el proceso de linkado en verbose mode, es decir, con todos los pasos que sigue la instrucción, esto puede resultar muy útil para comprobar posible errores (debugging).

Tras la etiqueta -o indicamos el nombre del archivo binario que se creará.

- Para descargar en el NXT un archivo ya linkado usamos

1	nxjupload HelloWorld.nxj

Las etiquetas que nos permiten modificar este comando son:

En primer lugar, justo tras el comando, -b /-u para forzar la descarga por Bluetooth o USB respectivamente. Si no se especifica nada, el comando lo intenta por USB primero y si no está conectado lo intenta directamente por Bluetooth

A continuación -d address donde address es la dirección Bluetooth del NXT al que queremos conectarnos. Si no se especifica nada, se realiza una búsqueda previa a la descarga.

Luego -n name donde name es el nombre del dispositivo al que queremos conectarnos. Si no se pone nada, intentará conectarse a todos los NXT que encuentre, descargando el archivo en el primero con el que se conecte con éxito.

- Si por el contrario, una vez compilado queremos linkarlo, descargarlo y ejecutarlo en el NXT (la opción más común) tendremos que usar el comando

1	nxj -r HelloWorld

En próximos artículos veremos:

Conexión bluetooth NXT-MAC. Incluyendo conexión desde LeJOS.

Instalación y configuración de Eclipse para LeJOS en MAC.

Cualquier duda, podéis preguntar en el foro.

LEGO NXT AirScooter

Dani — Tue, 13 Jul 2010 16:52:24 +0000

Hay muchos vehículos que hacen uso de las hélices para desplazarse, como aviones o helicópteros, pero pocos resultan tan llamativos y polivalentes como un hovercraft (aero deslizador en español). Estos vehículos suelen ser capaces de desplazarse a velocidades relativamente altas tanto en tierra como por el agua.

Generalmente lo que todos asociamos con un aero deslizador es algo parecido a esto

O a esto

Que nos dejan vídeos tan impresionantes como este:

LEGO también sacó una versión de hovercraft de bomberos, el set 7944, que vio la luz en 2007.

Partiendo de esta genial idea de mover un vehículo con la fuerza de unas hélices, nos hemos lanzado a construir nuestro propio aero deslizador. Este modelo, construido por nuestro forero CSM, está basado en el modelo de Air Scooter de leggor, que podemos ver a continuación

En el modelo de CSM, el air scooter está totalmente realizado con technic y NXT, tiene sólo dos palas y el giro se realiza desde la parte trasera.

Frontal

Trasera

Lateral

Aquí un vídeo para que lo veáis en marcha

Manejo del TETRIX con LabVIEW (II)

electricbricks — Sun, 04 Jul 2010 22:01:26 +0000

En este artículo ampliaremos el artículo anterior, introduciendo las funciones específicas para los servomotores, y un pequeño programa de ejemplo. Los servomotores permiten un control mucho más preciso que los motores DC. Cuentan con una potencia inferior, lo que no los hace aptos para el desplazamiento, por lo que se usan normalmentepara manipuladores o manejadores. En el programa de prueba también veremos motores DC.

Manejo de Servomotores:

Para usar los servomotores tenéis que configurarlos antes, como se explica en Manejo del TETRIX con LabVIEW. Una vez configurado ya podréis manejarlos. Las funciones para su manejo las podéis encontrar haciendo click derecho en el Block Diagram, y buscando en NXT Robotics → TETRIX:

Existen dos funciones:

TETRIX Move Servos:

Esta función tiene varios parámetros de entrada. En primer lugar está Servo State, o estado del servo, la cual puede tomar tres valores:

0 – Desactivado: Los servos están desactivados y no mantienen la posición actual.

1 – Activo con timeout: Mueve los servos a la posición que especifiques, y mantiene dicha posición hasta que el timeout se acabe, lo que desactivará los servos. El timeout es de 10 segundos.

2 – Activo sin timeout: Mueve los servos a la posición que especifiques, y mantiene dicha posición indefinidamente. Esta opción gastará mucha batería, por lo que hay que ser precavidos a la hora de usarla.

El segundo parámetro es el servo que deseamos usar, tenéis que usar los que hayáis configurado (en Motor Configurations en el menú de funciones de TETRIX, mirad elartículo anterior). El tercer parámetro es cuánto queremos que gire el servo, y el cuarto a qué velocidad (comprendida entre 0 y 15, siendo 0 la máxima velocidad de rotación y 15 la mínima).

TETRIX Check Servos:

Esta función es muy simple. Por una parte recibe como parámetros de entrada el flujo del programa y un servomotor, y como salida devuelve el flujo del programa, y un booleano cuyo valor será true en caso de que el servo esté en la posición especificada por la función Move Servos anterior, y false en caso contrario.

Programa de prueba:

En este programa vamos a crear un robot que haga uso tanto de motores DC como de servos. Vamos a crear un robot capaz de disparar proyectiles. Este robot va a tener un motor de NXT montado sobre el brazo del servomotor, encargado de accionar un mecanismo que dispara unos pequeños proyectiles (necesita girar unos 30 grados en inversa aprox.). El robot se irá moviendo en línea recta gracias a los motores DC, y tendrá un sensor de ultrasonidos. Cuando detecte un objeto a menos de 50 cm. se detendrá, levantará el brazo controlado por el servo, y disparará haciendo uso del motor de NXT.

Los dos motores DC estarán conectados al controlador 1 de motores de TETRIX, siendo el motor 1 el derecho, y 2 el izquierdo. Este controlador estará conectado al puerto de sensores 1 del NXT. A su vez tendremos al servo conectado al canal 1 del controlador de servos. El sensor de ultrasonidos lo conectaremos al puerto 4 de sensores, el motor con disparador al puerto C de motores del NXT.

En el programa crearemos un bucle que se encarge de mover los motores y vaya controlando que no haya ningún obstáculo a una distancia inferior a 50 cm. Por tanto la condición de salida del bucle será detectar un objeto a menos de 50 cm. Según salimos del bucle ponemos la potencia de los motores DC a 0, elevamos el brazo del robot con el servo, y finalmente disparamos. El Block Diagram del programa es el siguiente:

Y aquí tenéis un vídeo demostrativo del programa:

Este programa es lineal, no tiene funciones que se ejecuten en paralelo a otras. LabVIEW ofrece un mejor manejo del TETRIX que otros entornos compatibles como RobotC, por lo que es factible hacer programas más complejos, o que requieran de un manejo más preciso de motores. Si tenéis alguna duda respecto a este tema podéis consultarnos en el foro.

Web Publishing con LabVIEW (III)

Alvaro — Wed, 30 Jun 2010 11:57:49 +0000

Este artículo continua con la serie de artículos sobre web publishing con LabVIEW. Vamos a ir un paso más haya que en los anteriores artículos (ver Web Publishing con LabVIEW (I) y (II)), usando una cámara dispuesta sobre un motor, de forma que al controlar ese motor la cámara se mueva, mostrándonos por el Front Panel lo que ve. Este motor estará colocado sobre un vehículo móvil, de forma que también podamos desplazarnos adelante o atrás.

Cambiar control del Front Panel:

A la hora de hacer Web Publishing podemos hacer que el control sobre el Front Panel lo tenga o el servidor, o el cliente que se conecta a el, pero no ambos a la vez. Si queremos que sea el cliente, osea quien quiere usar el robot desde la web, quien maneje el robot, tenemos que darle el control a él. Hay varias maneras de intercambiar el control. La primera es a la hora de crear la página web, donde podemos decir que pida el control automáticamente al servidor:

Esto hará que el servidor pase el control automáticamente a los clientes que se conecten a la web para que estos puedan manejar el Front Panel. Es posible devolver el control al servidor desde un cliente, de esta manera será el servidor quién controle el Front Panel:

También se puede recuperar el control desde el mismo servidor, e incluso bloquear para que los clientes no puedan llegar a controlarlos. Es por tanto el servidor el que tendrá el máximo control sobre los permisos de uso del Front Panel:

En nuestro caso particular nos va a interesar que sea el cliente quién tenga dicho control.

Programa de prueba:

Como he comentado anteriormente, para este programa vamos a tener un robot móvil con un motor montado sobre el que mueve una cámara. Deseamos poder manejar los motores del robot desde el Front Panel a través de una página web, de forma que veamos lo que ve la cámara del robot:

En primer lugar necesitamos un programa que sea capaz de capturar bastantes imágenes por segundo, para poder mostrarlas a través de LabVIEW. En este caso hemos usado el Active WebCam, que es capaz de tomar capturas a una velocidad de 30 fps.

Una vez tengamos las imágenes podemos abrirlas en LabVIEW (ver artículos sobre visión artificial con LabVIEW), y procesar lo que haga falta. Los controles que vamos a poner servirán para mover la cámara a derecha o izquierda, y mover el robot adelante o atrás. El motor B se encargará de la cámara, y los motores A y C del desplazamiento del motor. El Block Diagram de este programa tiene el siguiente aspecto:

Y el Front Panel será así:

Es importante que pongáis un pequeño retardo entre cada iteración del bucle, para que de tiempo a cargar bien la imagen y mostrarla por pantalla. A continuación podéis ver un vídeo demostrativo, donde podéis ver el funcionamiento de este programa.

Queda bastante impresionante, el hecho de poder manejar un robot desde Internet. Espero que os haya resultado interesante el artículo. Por supuesto si tenéis alguna duda podéis visitar el foro.

Web Publishing con LabVIEW (II)

Alvaro — Mon, 28 Jun 2010 10:27:42 +0000

En este artículo vamos a seguir con la explicación de Web Publishing en LabVIEW. En este caso vamos a ahondar en el como hacer que el Front Panel sea funcional desde el navegador. Necesitaremos, entre otras cosas un plugin llamado LabVIEW Run-Time Engine que nos servirá para poder ver y manejar el Front Panel embebido.

¿Cómo crear un panel de control embebido?

Para crear el panel de control embebido, tenemos que acceder al menú de Web Publishing (Tools → Web Publishing Tools…) y elegir Embedded en lugar de Snapshot. Esto nos creará un Front Panel en nuestra página web que puede ser manejado. Para el resto de pasos debéis seguir las instrucciones que ya puse en el artículo anterior.

El problema principal es que a la hora de visitar nuestra página web no vamos a ver el Front Panel. Esto es debido a que es un objeto de tipo desconocido para nuestro navegador, por lo que necesitamos un plugin que nos permita ver y manejar dicho Front Panel. El plugin en si se llama LabVIEW Run-Time Engine y hay dos maneras de descargarlo:

- Con Internet Explorer podemos instalarlo directamente clickeando en el objeto que no podemos ver y dándole a instalar plugin.

- Con Mozilla Firefox o Google Chrome necesitamos descargarlo e instalarlo manualmente. El plugin puede ser descargado de la siguiente página:

Plugin de LabVIEW para Web Browsers

En primer lugar tenéis que elegir el sistema operativo, y una vez seleccionado, buscar la descarga que corresponda a vuestro sistema (por ejemplo XP, Vista, de 32-bits, de 64-bits…). Su instalación es sencilla, una vez descargado dais doble click en el .exe y seguís las instrucciones (es importante que cerréis todos los programas antes). Una vez instalado el plugin se necesita reiniciar el equipo. Una vez reiniciado abrimos nuestro navegador web y ya podremos ver vuestro Front Panel:

Es aconsejable que uséis un VI que tenga controles e indicadores, ya que así podremos ver como funciona. Un VI para controlar los motores de un NXT sería una gran idea, ya que así podríamos ver como funciona el manejar un robot desde otro ordenador.

Programa de prueba:

En este ejemplo vamos a hacer un Front Panel que maneje los motores de un Robot con unos controles. Dos motores (A y C) se encargarán de mover al robot, mientras que el motor B estará situado encima del robot servirá para colocar cualquier objeto encima (en próximos artículos pondré un ejemplo con camara encima). El Front Panel tendría el siguiente aspecto:

Y el Block Diagram sería así:

La idea es manejar este motor con el Front Panel desde la web, y ver como se mueve el robot, y si hay o no mucha latencia. Se siguen todos los pasos comentados en el artículo anterior. Una vez tengamos la página web guardada y el servidor funcionando abrimos el navegador y nos metemos en nuestra Web.

Espero que os haya gustado. Seguiré sacando artículos sobre Web Publishing con videos demostrativos y todo, así que no dejéis de mirar el blog. Y ya sabéis que si tenéis dudas al respecto podéis preguntar en nuestro foro, en la sección correspondiente a LabVIEW.

Web Publishing con LabVIEW (I)

Alvaro — Thu, 24 Jun 2010 10:57:44 +0000

Una de las herramientas más útiles de LabVIEW es el Web Publishing. Gracias a esta utilidad podemos subir nuestras creaciones a Internet, para mostrar por ejemplo resultados de un experimento que estemos haciendo, y cualquier persona desde otra parte del mundo lo pueda ver a través de Internet. Se pueden mostrar también imágenes que este captando una cámara, así como poder manejar controles del Front Panel.

Web Publishing o edición web es una forma de editar información en forma de páginas web, muy usada en la actualidad.

¿Como hacer Web Publishing?

En primer lugar necesitamos un VI, nos sirve cualquiera mientras esté orientado a PC y no a NXT. Una vez tengamos decidido que VI vamos a utilizara, lo abrimos y nos metemos en Tools → Web Publishing Tools:

Se abrirá la siguiente ventana, donde elegimos el VI, y el modo de vista. En este caso eligiremos Snapshot, que muestra una imagen estática del Front Panel, ya que solo estamos probando como funciona el Web Publishing:

Le damos a Next, y en la siguiente ventana elegimos el título de la página web, así como texto por encima y por debajo del Front Panel:

Le damos a Next otra vez, y en la nueva ventana elegimos el nombre del archivo .html, donde queremos guardarlo, y la URL donde se va a publicar nuestra página:

Finalmente le dais a Save to Disk. Os saldrá una última ventana que os dirá que vuestra página se ha publicado en la dirección indicada, y que os podéis conectar a ella poniendo la dirección en un navegador:

(En este caso en la primera parte de la dirección pone electricbricks1, pero en realidad es 192.168.1.7, y es la dirección que necesitaréis para acceder desde cualquier ordenador de vuestra red).

Ya tenéis publicada vuestra página Web, pero es posible no podáis acceder a ella desde Internet. Este caso se da porque no estáis conectados directamente a través de Internet mediante un modem, sino que tenéis un router intermedio. Sin embargo seréis capaces de ver la página desde cualquier PC de vuestra Red.

En artículos posteriores explicaré como hacer Port Forwarding en el Router para que se pueda acceder a vuestra página web desde cualquier otro ordenador en Internet. Espero que os haya resultado útil la información, para cualquier duda podéis visitar el foro.

Manejo de tareas en LeJOS: clase Arbitrator

Alvaro — Wed, 23 Jun 2010 09:59:09 +0000

En el los artículos Control de tareas en RobotC y Control de prioridades de tareas en RobotC vimos como manejar tareas en RobotC. En este artículo vamos a ver el manejo de tareas en LeJOS. La mejor forma de manejar las tareas y sus prioridades en LeJOS es mediante la clase Arbitrator. Este método consiste en crear unas tareas denominadas comportamientos, no muy complejas, que en su conjunto crearán el programa que deseemos implementar.

Modelo de programacion basado en comportamientos:

Los programas que hemos escrito en nuestro robot presentan la apariencia habitual de un modelo de programacion estructurado. El flujo de ejecucion comienza en un punto y se van sucediendo instrucciones que modican los actuadores de nuestro robot. En artículos anteriores hemos aprendido a crear nuevos threads y permitir que haya varios flujos de ejecucion en paralelo. A medida que la dificultad de la tarea a realizar aumenta, el codigo se vuelve cada vez mas complejo y difícil de escalar.

Un modelo de programacion basado en comportamientos permite simplicar el diseño de nuestros programas. Ahora nuestro codigo estara compuesto de varios comportamientos. Los comportamientos son tasks (tareas) relativamente simples e independientes, es decir, no necesitan de otros comportamientos para su ejecucion: Avanzar, esquivar obstaculo, coger pelota, rotar 360 grados, encender leds, etc. Una vez definidos los comportamientos tendremos que establecer una política de activación de los mismos. Por ejemplo podríamos tener un automata de estados finitos que activara uno o varios comportamientos según las necesidades del robot.

Otra alternativa es utilizar un arbitro que se encargue de elegir el comportamiento mas adecuado para cada momento en funcion de algun criterio. LeJOS dispone de un paquete llamado lejos.subsumption que permite programar nuestra aplicacion bajo este paradigma. Cada uno de nuestros comportamientos debera escribirse en una clase Java e implementar el interfaz Behavior. Este interfaz obliga a implementar tres métodos:

public boolean takeControl(): Metodo que indicará si este comportamiento deberá activarse en este momento o no. Por ejemplo, si nuestro comportamiento se encarga de esquivar un obstaculo, su funcion takeControl() deberá devolver true cuando haya un obstaculo cerca del robot.

public void action(): Método que se ejecutará cuando se active el comportamiento.Por tanto deberá contener todas las instrucciones que desempeñaran la labor para la que ha sido creado el comportamiento.

public void suppress(): Metodo que se ejecutara cuando se desactive el comportamiento. Si es necesario devolver el robot a un determinado estado, aquí sera el sitio para hacerlo. Un comportamiento será desactivado cuando otro comportamiento tome el control en su lugar.

Clase Arbitrator y prioridades de los comportamientos:

Una vez creados nuestros comportamientos deberemos crear un objeto de tipo Arbitrator, que se encargará de activar y desactivar los comportamientos. El constructor de Arbitrator acepta como parametro un array de comportamientos (en el programa de ejemplo podéis como hacerlo). Todos estos comportamientos serán los candidatos a activarse durante la ejecución del programa.

Cuando se ejecute el método start() de nuestro objeto de tipo Arbitrator se pondrá en marcha el arbitro que activa la ejecucion de los comportamientos. La poltica que se utiliza es una poltica de prioridades (tasks con prioridades). Tienen mayor prioridad aquellos comportamientos cuyo índice del array sea mayor. El arbitro recorrera el array de comportamientos desde el final hasta el comportamiento que ocupe la posicion 0 y ejecutará el metodo takeControl() de cada comportamiento. Si alguno de esos metodos devuelve true, se ejecutará una iteracion de ese comportamiento llamando a su metodo action().

Este arbitro se encargará contnuamente de evaluar que comportamiento es el que hay que ejecutar. En caso de que otro comportamiento distinto al actual tenga que ser ejecutado, se llamará el método supress() del comportamiento actual y despues el método action() del nuevo comportamiento.

Programa de ejemplo:

Como programa de ejemplo hemos puesto un clásico, el Bump&Go. Es un ejemplo sencillo, así que podréis comprender mejor como funciona la clase Arbitrator. En este caso tenemos dos comportamientos: Avanza y Esquiva. Uno se encargará de ir en línea recta, y el otro de esquivar cuando detecte un obstáculo. Por último el Arbitro se encargará de gestionarlo todo.

Cada comportamiento va en una clase distinta, y el Arbitro también, por lo que tendremos tres archivos (con una clase cada uno). Uno será el de la clase Avanza:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

public class Avanza implements Behavior {

public boolean takeControl() {
return true;
}

public void suppress() {
Motor.A.stop();
Motor.C.stop();
}

public void action() {
Motor.A.forward();
Motor.C.forward();
}
}

Otro el de la clase Esquiva:

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

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

public class Esquiva implements Behavior {

public TouchSensor touch = new TouchSensor(SensorPort.S1);

public boolean takeControl() {
return touch.isPressed();
}

public void suppress() {
Motor.A.stop();
Motor.C.stop();
}

public void action() {
Motor.A.backward();
Motor.C.backward();
try{
Thread.sleep(500);
}catch(Exception e) {}

Motor.A.stop();
try{
Thread.sleep(500);
}catch(Exception e) {}
Motor.C.stop();
}
}

Y finalmente el de la clase Bump&Go, que es el arbitro:

1
2
3
4
5
6
7
8
9
10
11
12

import lejos.robotics.subsumption.*;

public class BumpAndGo {

public static void main(String [] args) {
Behavior b1 = new Avanza();
Behavior b2 = new Esquiva();
Behavior [] bArray = {b1, b2};
Arbitrator arby = new Arbitrator(bArray);
arby.start();
}
}

Esta es una manera muy cómoda de gestionar tareas, amén de que facilita mucho la programación de programas complejos dividiéndolos en tareas. Si tenéis alguna duda, os recomiendo que os paséis por el foro y preguntéis.

Sigue líneas con visión, usando cámara iPhone

Dani — Mon, 21 Jun 2010 12:10:20 +0000

Tras una buena cantidad de artículos sobre visión artificial llega por fin el esperado sigue líneas con visión. Las dificultades que implica el manejo de imágenes en tiempo real son muchas, sobre todo el retardo entre que la cámara capta la imagen y nosotros la procesamos y enviamos los datos por bluetooth. Estamos utilizando la cámara de un iPhone 3G conectada mediante wifi al ordenador, enviado imágenes gracias al programa Pocket Cam. Capturamos imágenes periódicamente gracias al programa Yawcam, y las procesamos con LabVIEW, que finalmente enviará las ordenes necesarias al NXT mediante Bluetooth.

Funcionalidades que hemos usado:

Si no estáis familiarizados con el LabVIEW os recomiendo que os leáis los artículos de la serie de LabVIEW, sobretodo LabVIEW para usuarios del NXT (I), (II) y (III), así como Manejo de imagenes y shift register en LabVIEW.

El uso de los shift register es fundamental para este programa, pues lo necesitamos para ser capaces de detectar lineas. Así mismo lo son el uso de bucles, sentencias case, manejo de imágenes, etc… Necesitaremos hacer uso de múltiples variables de distintos tipos para ir guardando valores que necesitaremos posteriormente.

Proceso de captura de imágenes:

El proceso de captura de las imágenes tiene varios pasos. En primer lugar necesitamos capturar imágenes con el Iphone. Mediante el programa Pocket Cam podemos capturar imágenes cada segundo por la cámara del Iphone, y enviarlas por wifi al ordenador. A su vez tenemos otro programa actuando en el PC denominado YawCam, que se encarga de recoger estas imágenes enviadas por el Iphone por wifi, y guardarlas en el disco duro (es capaz de hacerlo a varias imágenes por segundo, aunque debido a la limitación del Pocket Cam del Iphone de una imagen por segundo estamos limitados a esa velocidad máxima).

Una vez en disco ya podemos procesarla con LabVIEW, para esto tenemos toda la funcionalidad que explique en Manejo de imagenes y shift register en LabVIEW.

Procesado de la imagen:

Una vez tenemos la imagen ya podemos procesarla. Lo primero es abrirla y usar la función unbound de clusters para poder acceder al array donde se encuentran los datos de la imagen. Recorreremos una de las líneas de la imagen, preferiblemente una intermedia, en busca de la línea negra. Tendremos que escoger un valor RGB umbral para decidir que es negro (línea) y que es blanco. Con que todos los valores estén por debajo de 60 es suficiente. Recordar que no hay que iluminar la línea negra desde arriba o creará reflejo. Buscaremos en la linea píxeles negros que estén por debajo del umbral. Para que no detectemos un píxel aislado como parte de la línea es importante que busquemos secuencias de varios píxeles negros. Si por ejemplo detectamos 6 píxeles negros seguidos sabremos que estamos ya sobre la línea.

Una vez que estamos sobre dicha línea seguimos buscando píxeles hasta que detectemos el otro borde. Tenemos que guardar tanto el número del primer píxel como el del último píxel de la línea para calcular el punto medio. Sabiendo ya este punto medio, tenemos que ver su distancia con el centro de la imagen, cuanto más lejos estemos del centro, más nos estamos desviando de la línea. Que la diferencia entre el punto medio calculado y el centro de la imagen sea positivo o negativo indica hacia que lado nos estamos desviando (derecha o izquierda), y tendremos que actuar en consecuencia, poniendo en funcionamiento unos u otros motores.

Este proceso se mete dentro de un bucle infinito, al que podremos poner algún botón de control para pararlo. Mientras el bucle siga en marcha seguiremos recorriendo la imagen y actuando en consecuencia.

Programa:

El programa es bastante largo, en el hemos usado toda la funcionalidad descrita en anteriores artículos, como bucles, sentencias case. shift registers, uso de variables… El programa sigue básicamente el proceso descrito anteriormente. Aquí podéis ver el Block Diagram:

Y el Front Panel:

Debido al gran retardo entre que la imagen se captura en el Iphone, y el robot actúa en consecuencia el robot no es perfecto, y se necesita mover bastante lento para no salirse de la línea. Lo importante es que es capaz de seguirla. Aquí tenéis un vídeo del experimento:

Espero que os haya gustado, ha sido difícil de implementar, pero ha merecido la pena. Para cualquier pregunta no dudéis en visitar el foro.

Kart NXT controlado remotamente con LeJOS

Alvaro — Fri, 18 Jun 2010 14:35:24 +0000

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:

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

import lejos.nxt.Button;
import lejos.nxt.LCD;
import lejos.nxt.Motor;
import lejos.nxt.comm.BTConnection;
import lejos.nxt.comm.Bluetooth;
import java.io.*;
import javax.bluetooth.*;

public class Mando {

/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
String nombre = "NXT1";
LCD.drawString("Conectando...", 2, 1);
LCD.refresh();
int ant_gir = 0;
int ant = 0;

RemoteDevice bt = Bluetooth.getKnownDevice(nombre);

if (bt == null){
LCD.clear();
LCD.drawString("No existe ese dispositivo", 0, 1);
Thread.sleep(2000);
System.exit(1);
}

BTConnection btc = Bluetooth.connect(bt);

if (btc == null){
LCD.clear();
LCD.drawString("Conexión fallida", 1, 1);
Thread.sleep(2000);
System.exit(1);
}

LCD.clear();
LCD.drawString("Conectado", 2, 1);
Thread.sleep(2000);

DataOutputStream dos = btc.openDataOutputStream();
LCD.clear();
LCD.drawString("Mando en funcionamiento", 2, 1);
while(!Button.ESCAPE.isPressed()){
Thread.sleep(150);
//Giro
int i = Motor.B.getTachoCount();

if ((i > (ant_gir + 5)) || (i < (ant_gir - 5))){
dos.writeInt(i);
dos.flush();
}
ant_gir = i;

//Aceleración
int j = Motor.C.getTachoCount();

if ((j > (ant + 4)) || (j < (ant - 4))){
dos.writeInt(j + 1000);
dos.flush();
}
ant = i;
}

LCD.clear();
LCD.drawString("Cerrando conexion", 0, 1);
dos.close();
btc.close();

LCD.clear();
LCD.drawString("Finalizado", 0, 1);
Thread.sleep(2000);
}
}

Y el del kart:

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

import lejos.nxt.Motor;
import lejos.robotics.navigation.Pilot;
import lejos.robotics.navigation.TachoPilot;
import lejos.nxt.Button;
import lejos.nxt.LCD;
import lejos.nxt.comm.BTConnection;
import lejos.nxt.comm.Bluetooth;
import java.io.*;
import java.lang.Math;

public class Kart {

/**
* @param args
*/
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
Pilot navigator = new TachoPilot(5.4f, 17.8f, Motor.A, Motor.C, true);

LCD.clear();
LCD.drawString("Esperando...", 2, 1);
LCD.refresh();

BTConnection btc = Bluetooth.waitForConnection();

LCD.clear();
LCD.drawString("Conectado", 2, 1);
Motor.B.setPower(100);
DataInputStream dis = btc.openDataInputStream();

while(!Button.ESCAPE.isPressed()){
int i = dis.readInt();
if (i > 1000){
//Acelerar
navigator.backward();
navigator.setMoveSpeed((i - 1000)/2);
}else if (i > 800){
navigator.forward();
navigator.setMoveSpeed(Math.abs(i - 1000)/2);
}else{
//Girar
boolean signo;
if (i >= 0)
signo = true;
else
signo = false;
i = i/10;
i = i*i;
if (i < 40){
if (signo)
Motor.B.rotateTo(-i);
else
Motor.B.rotateTo(i);
}else{
if (signo)
Motor.B.rotateTo(-40);
else
Motor.B.rotateTo(40);
}
}
}
Thread.sleep(2000);
LCD.clear();
LCD.drawString("Cerrando conexion", 0, 1);
dis.close();
btc.close();
Thread.sleep(2000);
}
}

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.

Control de prioridades de tareas en RobotC

Alvaro — Thu, 17 Jun 2010 11:19:31 +0000

En el artículo anterior de RobotC vimos cómo manejar varias tareas, gestionando el uso de recursos compartidos como los motores. En este artículo ampliaré la información sobre el manejo de tareas, viendo cómo poner mayor o menor prioridad a una tarea, y el efecto que tiene sobre la ejecución del programa. También veremos en qué consiste la planificación de tareas Round Robin y al final pondré un par de programas de prueba con vídeos incluidos.

¿Que significa prioridad?:

A la hora de iniciar una tarea en RobotC podemos asignarle una prioridad. Esta prioridad tiene un valor numérico que va del 0 al 255. Cuando una tarea se está ejecutando en la CPU el resto de tareas están esperando a que la deje libre. La tarea que tendrá el control de la CPU después de que la tarea que la estaba utilizando la deje libre será la que mayor prioridad tenga. Esto significa que las tareas que tengan mayor prioridad se ejecutarán antes que las demás que estén esperando.

RobotC usa planificación Round Robin para asignar tiempo de CPU a cada tarea.

Planificación Round-robin:

Round robin es un método para seleccionar todos los elementos en un grupo de manera equitativa y en un orden racional, normalmente comenzando por el primer elemento de la lista hasta llegar al último y empezando de nuevo desde el primer elemento. El planeamiento Round Robin es tan simple como fácil de implementar, y está libre de inanición (significa que ningún proceso esperará durante demasiado tiempo a que le den tiempo de CPU).

Round Robin asigna a cada proceso una porción de tiempo equitativa y ordenada, por lo que ningún proceso tendrá mayor tiempo de ejecución que los demás. Normalmente Round Robin trata a todos los procesos con la misma prioridad, aunque en caso de RobotC podemos aplicar prioridades, que solo afectarán en el orden en que entren a CPU las tareas que estén esperando, pero nunca en el tiempo de CPU que se les asigne.

Tareas con prioridad en Robotc:

En RobotC se le puede asignar una prioridad a una tarea al iniciarla. Esta prioridad debe estar entre el 0 y el 255. A mayor prioridad antes se ejecutará dicha tarea. Para asignar prioridad a una tarea al iniciarla se usa la función:

StartTaskWithPriority(nombre_tarea, prioridad): Inicia una tarea con la prioridad que hayamos escogido.

Hay que tener en cuenta que la prioridad no será algo perceptible, ya que la asignación de CPUs a tareas se hace muy rápido, pero sin embargo tiene utilidad a la hora de programar, ya que nos aseguramos que ciertas tareas se ejecuten antes que otras mientras ambas estén esperando.

Programa de prueba:

Un programa bastante sencillo para probar que en efecto todas las tareas reciben el mismo tiempo de CPU es el siguiente: se crean cuatro tareas, cada una de ellas se encarga de aumentar un contador y mostrar su número por pantalla. Si todas las tareas tuvieran el mismo tiempo de CPU los números deberían avanzar a la vez.

El código es el siguiente:

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
44
45
46
47
48
49
50

int cont1 = 0, cont2 = 0, cont3 = 0, cont4 = 0;

task tarea1()
{
while(true){
wait1Msec(300);
cont1++;
nxtDisplayCenteredTextLine(0, "Tarea 1: %d", cont1);
}
}

task tarea2()
{
while (true){
wait1Msec(300);
cont2++;
nxtDisplayCenteredTextLine(2, "Tarea 2: %d", cont2);
}
}

task tarea3()
{
while(true){
wait1Msec(300);
cont3++;
nxtDisplayCenteredTextLine(4, "Tarea 3: %d", cont3);
}
}

task tarea4()
{
while(true){
wait1Msec(300);
cont4++;
nxtDisplayCenteredTextLine(6, "Tarea 4: %d", cont4);
}
}

task main()
{
StartTaskWithPriority(tarea1, 250);
StartTaskWithPriority(tarea2, 150);
StartTaskWithPriority(tarea3, 100);
StartTaskWithPriority(tarea4, 25);
while(true)
{
wait1Msec(300);
}
return;
}

Y aquí os pongo un video de su funcionamiento:

También se puede hacer una pequeñas variación, cambiando los retardos dentro de cada tarea para que sean proporcionales. Si por ejemplo ponemos a una tarea el doble de retardo que otra, está cambiará el contador a la mitad de velocidad. Aquí está un código de ejemplo:

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
44
45
46
47
48
49
50

int cont1 = 0, cont2 = 0, cont3 = 0, cont4 = 0;

task tarea1()
{
while(true){
wait1Msec(1000);
cont1++;
nxtDisplayCenteredTextLine(0, "Tarea 1: %d", cont1);
}
}

task tarea2()
{
while (true){
wait1Msec(500);
cont2++;
nxtDisplayCenteredTextLine(2, "Tarea 2: %d", cont2);
}
}

task tarea3()
{
while(true){
wait1Msec(250);
cont3++;
nxtDisplayCenteredTextLine(4, "Tarea 3: %d", cont3);
}
}

task tarea4()
{
while(true){
wait1Msec(125);
cont4++;
nxtDisplayCenteredTextLine(6, "Tarea 4: %d", cont4);
}
}

task main()
{
StartTaskWithPriority(tarea1, 250);
StartTaskWithPriority(tarea2, 150);
StartTaskWithPriority(tarea3, 100);
StartTaskWithPriority(tarea4, 25);
while(true)
{
wait1Msec(300);
}
return;
}

Y el vídeo:

En este caso la diferente espera interna de cada tarea produce que los contadores crezcan de forma inversamente proporcional, de ahí que exista una diferencia de velocidades de 1 a 8 entre la tarea 1 y la 4, la misma relación inversa que sus retardos. En este caso la prioridad de cada una de las tareas no afecta para nada al resultado: sabemos que cada vez que se han ejecutado las 4 tareas siempre ha sido la tarea 1 la primera de ellas, a continuación la 2, la 3 y finalmente la 4, debido a la siguiente parte del código:

1
2
3
4

StartTaskWithPriority(tarea1, 250);
StartTaskWithPriority(tarea2, 150);
StartTaskWithPriority(tarea3, 100);
StartTaskWithPriority(tarea4, 25);

En esta pequeña aplicación no ha afectado para nada la prioridad de ejecución, pero puede que en otra aplicación sí sea necesario el uso de prioridades.

Espero que os haya resultado interesante. Ya sabéis, ante cualquier duda estamos en el foro.