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

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.

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

English

El pasado sábado 26 de Junio tuvo lugar la primera competición de karts de electricBricks, en una reproducción a escala del circuito de Mónaco. Como no podía ser de otra manera, este circuito requería de un semáforo a su altura, y lo hicimos.

Se trata de un semáforo controlado por un NXT con un sencillo programa en NXT-G. Intentamos hacerlo lo más fiel posible a los reales (las dos luces rojas se mantienen encendidas hasta que se enciende la verde), pero las limitaciones de consumo (hay 12 bombillas) nos obligaron a controlar el tiempo de encendido de las luces.

La forma de controlar la duración de encendido de las luces depende del tiempo durante el cual se emite el sonido (tenemos marcado “Esperar hasta finalización”).
El proceso es el siguiente:

NOTA: Dígito 2 sólo se pide si la operación lo requiere, por ejemplo x^2 no necesita dos dígitos.

Si la respuesta es afirmativa, volvemos al principio del bucle, reseteamos las variables y todo vuelve a empezar.

FACTORIAL

Para terminar, a las 8 operaciones que hemos puesto más arriba, hemos añadido una novena, la operación factorial, el factorial de un número entero positivo se define como el producto de todos los números naturales anteriores o iguales a él. Se escribe n! (NOTA: Por definición el factorial de 0 es 1: 0!=1)

Esta operación requiere, por tanto, un control previo del valor de Digito 1 que nos da el usuario, tendremos que comprobar:
- Si es 0, en cuyo caso devolvemos 1
- Si es <0, devolvemos 0 para indicar error (el factorial sólo está definido para valores positivos)
- Si es >0, calculamos el valor.

Para calcular el valor vamos a analizar la definición: 4!= 4*3*2*1 que es lo mismo que decir 4!= 1*2*3*4, ya que el orden de los factores no altera el producto.
Esto nos permite usar el contador interno del bucle para realizar las operaciones, multiplicando el resultado de la iteración previa por el contador +1 – el contador del bucle empieza en 0, al sumarle uno forzamos que la primera multiplicación sea Ant*1-

Este es el programa del factorial (está dentro de CalcOpera, es la operación 9)

Como podéis ver, hemos dado una vuelta de tuerca a las tradicionales calculadoras con sólo 4 operaciones, añadiendo otras muy comunes, que en algún caso son algo más difíciles de implementar, pero que esperamos hayan quedado claras.

Cualquier duda, como siempre, en el foro.

Hoy queremos presentar un pequeño experimento realizado por nuestros alumnos en uno de nuestros talleres de robótica. Se trata de un robot que utiliza dos ladrillos NXT que se comunican entre sí mediante bluetooth. Este experimento nos permitirá explorar aún más las posibilidades de interacción bluetooth entre ladrillos, fundamental para controles remotos (como ya hemos visto en varios artículos). Pero también para robots que tengan más de un NXT.

Para poder hacer esto tenemos que ser capaces de controlar cuándo y cómo actuamos con cada NXT. Para eso utilizamos un sistema de intercambio de flags entre ladrillos. Para que nos sea más fácil identificarlos, durante el artículos los llamaremos NXT-M (NXT- Master) y NXT-S (NXT-Slave).

Cada uno de los procesadores se encarga de unas tareas a realizar. El Master es el encargado de controlar la tracción del vehículo, mientras que al Slave se le conectan los motores de la pinza, por lo que debe controlar sus movimientos. Cada uno de ellos necesita su programa independiente.

El siguiente es el programa de NXT-M (controla la tracción del vehículo).

Este programa es muy fácil de seguir: nos movemos en línea recta hasta que detectamos un objeto, giramos para encararnos al objeto con las pinzas y enviamos a NXT-S el flag a True, indicándole que ya empieza su parte (1) seguimos avanzando hasta que recibimos el flag False desde NXT-S (2). Ahora nos mantendremos quietos hasta recibir flag True (3) y giraremos de nuevo para soltar el objeto, para lo cual mandaremos a NXT-S flag False (4).

Y este el del ladrillo esclavo (controla los movimientos de la pinza)

Este es aún más sencillo, ya que sólo controlaremos la pinza. Esperamos la señal de NXT-M – marcada como (1) en la explicación anterior- Enviamos flag False a NXT-M (2). Cerramos las pinzas y levantamos el objeto. Enviamos flag True (3) y esperamos la señal desde NXT-M (4). Finalmente liberamos el objeto.

Como se puede observar ambos ladrillos tienen esperas o realizan acciones hasta un cambio en el flag, dicho cambio es enviado por bluetooth desde el otro ladrillo.

Es muy importante tener en cuenta que, para que el ladrillo esclavo pueda comunicarse con el maestro, debe enviar los mensajes siempre a la conexión 0. Sin embargo, el ladrillo maestro deberá enviarlos a la conexión que tenga ocupada (1, 2 o 3).

Os ponemos un vídeo para que lo veáis en funcionamiento.

English

Siguiendo con la serie de artículos sobre los vehículos de Braitenberg, que ya vimos en los artículos Braitenberg en LeJOS y Braitenberg en RobotC, hemos querido ir un poco más allá haciendo un sistema de robots que, a modo de tren autónomo, buscan la luz de su compañero de delante para seguir el recorrido.

El primero de los robots, el que haría de locomotora siguiendo con el símil de los trenes, está controlado remotamente desde el joystick en NXT-G al mismo tiempo que enciende unas bombillas en la parte trasera para dar un punto de referencia al robot que debe seguirlo.

El montaje

Hay una diferencia importante entre este montaje y el que usamos en los artículos anteriores sobre Braitenberg, y es la posición de los sensores:

En este caso hemos optado por ponerlos perpendiculares al robot, en lugar de diagonales como en el caso del montaje anterior. Esto favorece la posibilidad de reconocer la luz que se encuentra frente al robot, ya que tenemos 4 estados (ver artículo sobre máquinas de estados):
1. No hay luz o está demasiado lejos (los sensores no reciben luz o es muy escasa) — Parado
2. La luz se mueve hacia la derecha (el sensor de la derecha recibe más luz) — Giro a la derecha
3. La luz se mueve hacia la izquierda (el sensor de la izquierda recibe más luz) — Giro a la izquierda
4. La luz está frente al robot (ambos sensores reciben por igual) — Movimiento hacia delante

La implementación de esta máquina de estados está el el programa que viene a continuación.

Tomamos inicialmente el valor de la luz ambiente (cuando no se han encendido aún las bombillas) luego comprobamos si la diferencia entre las nuevas medidas de luz son suficientemente grandes con respecto a luz ambiente como para considerar que esa es nuestra bombilla objetivo, y si ese es el caso nos moveremos de acuerdo con sus desplazamientos: girando cuando la bombilla gira o recto si el robot guía sigue recto.

El valor con el cual comparamos depende directamente de nuestras condiciones de luz y del montaje concreto de nuestro robot, en nuestros experimentos esa diferencia ha tomado valores entre 7 y 15.

Es muy importante reseñar la necesidad de unas condiciones correctas de luz para este experimento, ya que, aunque se ha realizado un estudio previo de la luz ambiente, necesitamos poder diferenciar correctamente la luz que proviene de nuestra bombilla de cualquier otra fuente de luz (una lámpara, la luz solar, etc… ). Por lo que se aconseja un entorno lo más oscuro posible.

En el siguiente vídeo se pueden apreciar los resultados del experimento

Cabe destacar que todos nuestros robots llevan exactamente el mismo montaje y programa, con la excepción del primero (que es controlado remotamente).
Además se ha introducido un pequeño cambio de última hora en el programa que veíamos más arriba, todos los robots seguidores esperan un sonido fuerte (por ejemplo una palmada) antes de comenzar la ejecución del bucle principal.

Sin embargo, tal y como se aprecia en el vídeo, cuando los giros son muy cerrados, o el vehículo que va delante se mueve demasiado rápido, podemos llegar a perder la referencia.

English

En alguna ocasión nos hemos preguntado por la posibilidad de crear un nuevo icono gráfico para aquella funcionalidad que nos gustaría ver implementada. En su momento explicamos cómo implementar funciones trigonométricas en NXT-G en dos artículos, dado que estas funciones no han sido implementadas. Existen una forma distinta de resolver el problema, y consiste en crear un icono nuevo de NXT-G que ejecute dicha función. Esto es posible mediante el uso de LabVIEW.

Para crear bloques que se puedan importar en el software de LEGO MINDSTORMS NXT necesitamos hacer uso del LabVIEW 7.1. Debido a que el software de LEGO MINDSTORMS NXT se basa en la versión 7.1 necesitamos hacer uso explícito de esta versión para crear nuevos bloques NXT-G. También es necesario utilizar el Kit de herramientas de LabVIEW para LEGO MINDSTORMS NXT junto con el LabVIEW 7.1. El objetivo de este artículo es aprender a crear e importar nuevos bloques para el software gráfico del MINDSTORMS NXT-G. Dado que este proceso es un poco tedioso, dividiremos el artículo en dos o más partes.

La creación de un bloque de MINDSTORMS NXT implica tanto la creación de una serie de varios archivos necesarios como su importación en el software de MINDSTORMS. Para llevar a cabo con éxito este proceso es necesario seguir una convención de nombres especificado puesto que el proceso de importación se basa en una estructura de directorios estrictamente definida.

Vamos a crear un nuevo bloque que genere el valor de las funciones trigonométricas para un determinado ángulo. A este nuevo bloque lo denominaremos trigonometría. Si lo llamaramos de otro modo deberíamos tenerlo en cuenta en las explicaciones que siguen.

LabVIEW dispone de una ayuda para la generación de nuevos bloques. La siguiente imagen nos muestra dónde podemos localizar esta herramienta.

Esto nos lanza la ventana de la figura. Como vemos tenemos la opción de elegir entre cuatro posibles plantillas. Como es nuestro primer bloque, seleccionamos el más simple, la opción inferior, el nombre que queremos darle al bloque (trigonometría), el directorio de destino, y le damos a create. En el directorio seleccionado se crearán varios ficheros. Los ficheros que se generan en este proceso dependen de la plantilla seleccionada. En nuestro caso, si vamos al directorio que hemos elegido nos encontraremos los siguientes ficheros:

Dependiendo del nivel de funcionalidad que queramos darle a nuestro nuevo bloque puede ser conveniente el crear otros ficheros adicionales. Esto quiere decir que existen unos ficheros que son estrictamente necesarios, y otros no. Veamos cuáles son todos ellos.

Archivos necesarios
Para importar un bloque al software NXT-G debemos crear los siguientes archivos:

• Aplicación vi
  El vi Aplicación es el archivo que el software de MINDSTORMS compila y, por tanto, el que descargamos en el NXT. El nombre que debemos dar a nuestro vi aplicación debe ser de la siguiente manera:
  trigonometria\trigonometria.vi
  Si abrimos este vi, nos encontramos que el contenido del panel frontal generado por el template es el siguiente:
  

  Y su correspondiente diagrama de bloques contiene el siguiente código:

  

  Los booleanos de Secuencia de Flujo que tanto nos recuerdan a los del NXT-G son específicos del compilador de NXT, y se emplean para la conexión de SubVIs que necesitan ejecutarse secuencialmente. Ni se compilan en el programa, por lo que son ignorados, ni tampoco incrementan el tamaño del programa. Tan solo sirven para crear una dependencia en el orden de ejecución entre SubVIs.

  Lo siguiente que vamos a realizar es modificar el contenido del vi para que genere las funciones trigonométricas.

  

Importación de nuevos bloques desde el NXT-G
Aunque no hemos acabado el proceso, veamos lo que hemos hecho hasta ahora, porque esto nos ayudará para entender el resto de operaciones más fácilmente. Salvemos este fichero y tratemos de importarlo desde el NXT-G. Para ello arrancamos el NXT-G y, desde una ventana de programa cualquiera.

Debemos seleccionar el directorio en el que hemos creado nuestros ficheros, así como la paleta en la que deseamos que nuestro nuevo icono se incorpore y le damos a importar. Hecho esto, ya podemos incorporarlo en nuestro programa. Para ello vamos a la paleta seleccionada, lo encontramos en (2) y lo arrastramos al programa, donde tiene el aspecto según (1). La forma con la que se nos aparece en estos contextos depende del contenido del resto de los ficheros que explicamos a continuación.

Si pinchamos sobre el bloque que acabamos de añadir al programa vemos que en la parte inferior izquierda del entorno se nos despliegan las opciones de configuración del programa. Para explicar el porqué de las opciones que aparecen aquí como “Example boolean”, “Example Numeric”, etc. debemos seguir con los ficheros necesarios que explicábamos antes…

• Configuración vi
  El vi de configuración es el que define lo que aparece en el panel de configuración en la parte inferior del software NXT-G. El vi de Configuración proporciona varias funciones, incluyendo la actualización de los valores por defecto en su Aplicación VI y lectura de datos del sensor. Debemos nombrarlo:
  trigonometria\Config trigonometria.vi

Abramos este fichero que se ha creado de forma automática al ejecutar el template. Nos encontramos que el panel frontal de Config trigonometria.vi no es otra cosa que exactamente la parte inferior del menú de configuración del icono que vemos en NXT-G. Su diagrama de bloques es un chorizo que asusta un poco, pero que tan sólo se encarga de capturar los datos con los que queremos configurar nuestro bloque: recordemos que lo que ahí aparece proviene de un template y nosotros lo vamos a modificar según nos convenga.

• Dibujar vi
  El vi de Dibujo es el encargado de mostrar la imagen que queremos que tenga nuestro bloque en el diagrama de bloques del NXT-G. Su nombre será:
  trigonometria\Draw trigonometria.vi
• Bloque Icono
  El bloque icono sirve para representar la imagen que queremos que tenga nuestro bloque en la paleta y en el diagrama de bloques. Esto lo podemos hacer con el editor gráfico que más nos guste, por lo que no haremos mayor hincapié. Lo nombraremos:
  trigonometria\trigonometria.png
• Bloque Nombre del fichero
  El nombre del bloque del archivo contiene el texto que aparece cuando nos situamos con el cursor sobre nuestro bloque en la paleta del NXT-G:
  trigonometria\trigonometria.txt
• Fichero Sensor
  Este fichero es necesario exclusivamente si queremos crear un bloque de sensores. El objetivo de este fichero es el de proporcionar la información necesaria para el correcto funcionamiento del bloque del sensor que implementamos Wait For, Loop, Switch o Calibration.
  trigonometria\Sensor.ini

La segunda parte del artículo la presentaremos en breve. Los comentarios y dudas en el foro de electricBricks, como siempre!!

En breve podremos disponer de la segunda edición de LEGO MINDSTORMS NXT-G Programming Guide. Esta edición cubre tanto al NXT-G 1.0 como al 2.0 e incluye ejercicios y sugerencias en cada capítulo orientados a los educadores que quieren emplear el NXT-G como un vehículo para la enseñanza de robótica o de los principios de programación.

LEGO MINDSTORMS NXT-G Programming Guide, 2nd Ed. está centrado en la programación mediante el lenguaje gráfico NXT-G. Se aplica el NXT-G a problemas reales como desplazarse y girar, localizar objetos basándose en su color, toma de decisiones, etc. Este libro es adecuado para los mayores de 10 años que se inician en el mundo de la programación, puesto que no sólo se cubre el lenguaje, sino también las matemáticas empleadas o la forma de calibrar y ajustar el robot para que los programas se ejecuten según esperamos.

• Proporciona técnicas de programación y sencillos ejemplos para cada bloque de programación.
• Incluye ejercicios que pueden ser empleados por educadores.
• Proporciona las instrucciones de montaje de un robot que se emplea para probar los ejemplos.

Este libro permite el aprendizaje de:

• Conocimientos básicos de programación.
• Programación gráfica del robot mediante NXT-G 1.0 y 2.0.
• El nuevo sensor de color que se incluye en el conjunto NXT 2.0.
• Control manual de un robot desde un dispositivo de control remoto.
• Principios básicos de matemáticas que mejorarán tus capacidades como programador.

English

La cerradura es un elemento mecánico, generalmente metálico que impide el acceso al contenido que protege si se carece del elemento que permite abrirlo, tradicionalmente una llave y en la actualidad cada vez más tarjetas magnéticas que deben pasar por una banda o transpondedores pasivos – elementos que son identificados por escáneres, robots u ordenadores. Es necesario que interactúe con un sensor que decodifique la información que contiene y la transmita al centro de datos. Tienen un alcance muy limitado-. Aunque también existen cerraduras que tienen un panel y requieren de una contraseña de acceso. Este es el caso de nuestro experimento de hoy.

Este es el modelo que hemos usado para probar nuestra cerradura

Tiene 4 sensores de contacto en la parte derecha y la cerradura, accionada por un motor en la izquierda.

En una primera versión trabajaremos suponiendo que, como desarrolladores, conocemos la clave que nos permite abrir el cerrojo y comprobaremos si el usuario la introduce correctamente.

Programa cerradura completo

Si os fijáis, a la izquierda del programa, junto al punto de inicio hemos anotado la clave que tiene codificada esa cerradura por defecto, a continuación comprobamos si el usuario pulsa los botones (sensores de presión) en el orden correcto, si es así escribimos la variable dígito correspondiente (dígito 1.. dígito 4) con un 1, si no con un 0.
Es decir, si nosotros esperamos como primer botón de la clave el sensor 2 (como es el caso de este programa) y el usuario presiona un botón distinto del 2, nuestro dígito 1 será 0.

Una vez el usuario ha introducido todos los dígitos de la clave (son 4) debemos compara la clave introducida con la buena. Si la clave en correcta, todas las variables dígito X (X= 1 ..4) deben estar a 1, y por lo tanto tras la transformación del bloque Suma Dígitos compararemos el resultado con el número 1111.

Detalle del bloque Pedir Cierre

Este bloque se encarga de comprobar si la cerradura ya está cerrada , en cuyo caso nos preguntará si queremos abrirla, o si está abierta, y nos preguntará entonces si queremos cerrarla.
para saber el estado de la cerradura utilizamos la variable flag, que cambia su valor dependiendo del estado de la cerradura al final de cada bucle.

Detalle del bloque Suma Dígitos

Este bloque se encarga de hacer el sumatorio que nos permitirá comprobar si la clave es correcta o no. Para ello convierte los 4 dígitos de la clave en un sólo número y devuelve el resultado para que pueda ser comparado con la respuesta correcta, tal y como se explica más arriba.

La transformación a un sólo número consiste en multiplicar el valor de cada dígito – 0 o 1 – por su posición.
digito1 – digito2 – digito3 – digito4 representan: unidades de millar – centenas – decenas – unidades respectivamente. Luego si tenemos la clave 1-0-0-1 haremos 1*1000+0*100+0*10+1*1 = 1001
¿Es 1001 el valor correcto? No, tal y como hemos comprobado arriba, el valor correcto es 1111.

Ahora partimos de la base de que la contraseña debe introducirla el usuario, no la conocemos cuando hacemos el programa, para lo que necesitaremos preguntarle los 4 dígitos de la contraseña antes de cerrar la caja por primera vez.

Si en la versión anterior nos bastaba con colocar los sensores en el mismo orden en el que estaba la clave, ahora no sabemos el orden a priori, pues la clave la introduce el usuario al comenzar la ejecución, con lo que tendremos que variar ligeramente el programa.

Lo primero es pedir la clave al usuario, para ello, basta con añadir este bloque al principio del programa anterior.

La primera parte del bloque son instrucciones en pantalla para que el usuario sepa qué debe hacer. Tras las instrucciones esperamos a que el usuario presione el botón Intro del NXT.

¡ATENCIÓN! El bloque no está completo ya que es muy muy largo, aunque al tratarse de un bloque muy repetitivo (tenemos que pedir 4 valores para la clave), es también fácil saber qué falta.
Si observáis el bloque expandido, veréis que en el bucle estamos escribiendo el valor de clave1 en función de qué sensor de contacto presione el usuario – guardaremos el valor 1 para puerto 1, 2 para puerto 2, etc – , simplemente tendríamos que repetir el mismo bucle para cada dígito de la clave, en nuestro caso hemos repetido ese bucle 4 veces. Debemos acordarnos de cambiar el valor de la variable correcta en cada bucle: clave1, clave2..

Una vez el usuario nos ha dado la clave basta un simple cambio para poder usarla en el programa anterior.

Como podéis comprobar, hemos usado la variable clave1 del bloque anterior como entrada de puerto para realizar la comprobación.

Aquí tenéis el vídeo de su funcionamiento.

Hemos añadido una funcionalidad adicional, y es que si el usuario no está de acuerdo con la clave que ha introducido, antes de cerrar puede rectificarla.

Esperamos que os guste, para cualquier duda, podéis visitar el foro.

English

Ya hicimos un artículo de introducción al giróscopo, ahora vamos a trabajar con su programación mediante NXT-G, robotC y LeJOS. La información que recibimos del sensor nos indica tanto la velocidad de giro como el sentido en el que se produce. Veamos cómo emplear dicha información con un ejemplo sencillo.

El primer problema que se nos plantea es el de la calibración. Necesitamos determinar el valor de offset y tener en cuenta el drift (o deriva) tal y como se explicaba en la teoría.

Para determinar el offset basta con mostrar en pantalla las medidas de giróscopo durante unos segundos cuando éste se encuentra en reposo, veremos que el giróscopo se mantiene estable en un punto cercano al 0 (en NXT-G) o a 600 en RobotC/LeJOS. Para evitar el error de una sola medición, podemos tomar una serie de medidas y promediar.

En NXT-G podemos indicarle el valor de offset bien directamente en el bloque, o bien mediante un cable de datos. El programa de calibrado es el siguiente.

Tomamos varias medidas de nuestro giróscopo (recordemos que debe estar en reposo), calculamos su promedio y guardamos su valor en la variable offset.

En RobotC

Para hacer uso del offset calculado, tendríamos que añadir esta línea de código al tomar la medición:

En LeJOS

El calibrado del offset se ha hecho mediante una media absoluta de diez mediciones del giroscópio; en caso de LeJOS es necesario sumarle 600 a este offset inicial. Para usar ese valor de offset calculado deberemos añadir esta línea de código:

Esta línea nos permitirá fijar el valor de offset para el giróscopo durante todo el programa, no será necesario descontarla de cada medición, como en RobotC.

Ejemplo: ¿Cuánto ha girado nuestro motor?

Nuestro programa de ejemplo nos tiene que mostrar lo que ha girado nuestro motor, pero medido por el giróscopo. Para ello, tras la calibración que hemos visto anteriormente, tendremos que tomar una serie de mediciones que nos permitirán mostrar en pantalla el ángulo en grados que ha girado el motor. Recordemos que el valor que nos devuelve el giróscopo está en grados/segundo, por lo que serán necesarias algunas operaciones para obtener los grados finales. En nuestro experimento programaremos el motor para que realice un giro determinado y presentaremos en el display tanto el valor del giro devuelto por el tacómetro como el valor de giro calculado por nuestro programa. Nuestro objetivo es que exista la menor disparidad entre ellos.

La toma de varias medidas a lo largo del movimiento del motor es importante, pues con el cálculo de la media tendremos mucha más precisión. Para el cálculo del ángulo recorrido, y dado que se trata del primer ejemplo de uso del giróscopo, aproximaremos realizando un muestreo de la velocidad angular equiespaciado en el tiempo mientras dura el experimento y supondremos que el ángulo recorrido es el producto de la velocidad angular media, calculada a partir de los datos anteriores, y multiplicada por el tiempo empleado.

En NXT-G

En RobotC

En LeJOS

Aquí tenéis el vídeo del programa en NXT-G, tened en cuenta que todos los programas muestran prácticamente lo mismo, por eso nos hemos limitado a poner un sólo vídeo.

A continuación una foto de la pantalla al finalizar el programa, ya que en el vídeo no se aprecia bien.

Problemas que hemos encontrado:

Para calcular el ángulo girado tenemos que tener en cuenta el tiempo que el motor ha estado girando además de la media de velocidad angular calculada anteriormente. En este caso sabemos que es de aproximadamente un segundo ya que tenemos esperas de 50 ms dentro de un búcle de 20 repeticiones. Esta espera es la que aparece en los ejemplos de código en las líneas 22 de RobotC y 32 de Java. En las pruebas realizadas obtenemos siempre que el ángulo mostrado por el giróscopo es superior al recorrido en realidad, y esto nos conduce a pensar que las esperas anteriores son, en la práctica, intervalos de mayor longitud puesto que debe incluirse el tiempo que el procesador emplea en su ejecución. Estos tiempos serán seguramente dependientes de factores como la tensión de alimentación (valor de carga de la batería) o temperatura. Hemos comprobado que suponiendo que el tiempo empleado en la ejecución de las líneas de código internas al bucle es de 3 ms los resultados obtenidos entre giróscopo y tacómetro coinciden (es decir, los tiempos de espera en el código son de 47 en lugar de 50 ms). Con objeto de eliminar las dependencias citadas anteriormente deberíamos medir el tiempo exacto empleado en la ejecución de cada bucle y así poder aplicar la corrección adecuada.

Otro problema es la deriva. Podemos observar que a pesar de haber calibrado el dispositivo, si lo dejamos en reposo mostrando en pantalla los grados de giro (con los programas que hemos visto anteriormente) descubriremos que no siempre se mantiene en el 0. Dedicaremos un artículo posterior para obtener mejores resultados con el giróscopo.

English

El algoritmo básico de un sigue lineas consiste en realizar un zig zag de dentro a fuera de la línea. La ventaja de esta solución es la simplicidad, pero se traduce en un mayor espacio recorrido y por ende en una velocidad menor. Sin embargo existen soluciones alternativas que permiten un movimiento que evita el cabeceo de la solución anterior.

En el algoritmo básico se aplica una potencia constante al motor, que es la que definimos gráficamente al seleccionar el icono del motor. Esta potencia se mantiene constante durante la ejecución del programa en esta resolución. El cabeceo puede llegar a ser excesivo en algunos casos y provocar que el robot se salga de la línea.

El siguiente es el programa del sigue líneas básico.

Existe sin embargo la posibilidad de programar los motores con un valor de potencia variable. Con esta idea en mente podemos conseguir que la potencia del motor dependa de las lecturas del valor de luminosidad de forma proporcional. En este sistema el control de la potencia del motor depende de la realimentación del valor recibido por el sensor. En el sistema de control más básico la lectura del sensor de luminosidad se interpretar de forma booleana, de manera que a partir de un umbral decidimos si estamos sobre la línea o fuera de ella y aplicamos la potencia al motor izquierdo o derecho según corresponda (en una construcción en la que la tracción es -puede ser- diferencial.

Frente a la versión básica anterior, esta segunda versión hará uso de todo el rango de valores continuo que puede encontrarse el sensor de luminosidad. Para comprobar de qué estamos hablando basta tomar el sensor de luminosidad y realizar medidas:

• Si lo colocamos sobre la superficie blanca recibimos el valor máximo de luz reflejada.
• Si lo colocamos sobre la línea, que normalmente será negra, recibimos el valor mínimo de luz reflejada.
• Pero… ¿Que está sucediendo si colocamos el sensor sobre el borde de la línea? Como la luz que recibimos reflejada procede de una superficie, y no de un punto, el valor de la lectura recibida por el sensor depende de la cantidad de luz que se refleja en esa superficie, es decir, que si el spot que vemos como rojo contiene parte de negro y parte de blanco tendremos un valor intermedio entre el valor que recibimos cuando el spot está sobre negro y el valor recibido cuando el spot está sólo sobre blanco. El valor exacto depende de la proporción de negro y blanco.

La posible continuidad de esta lectura nos permite dotar de una mayor inteligencia al comportamiento de nuestro robot. Con tracción diferencial, de lo que trataremos es de dar una potencia a ambos motores continuamente, pero en un valor proporcional a la lectura del sensor recibida. Debemos de tener en cuenta el rango de entrada del sensor, que hay que conocer previamente, y adaptar este rango de valores a los que nos serán de utilidad en nuestro motor (potencias del 30% no consiguen mover el motor, por ejemplo, y potencias superiores a 100 tampoco son válidas). Esta adaptación es una operación de escalado que haremos mediante varias operaciones matemáticas sencillas.

Vamos a ver el programa.

Como podéis comprobar es muy largo, lo que dificulta su comprensión, por eso hemos untilizado la herramienta MiBloque para encapsular algunos elementos, que luego veremos por separado.

El primer bloque es VariableIni, donde damos a las variables un valor inicial.

En este programa, hemos realizado unas mediciones previas para los valores máximo y mínimo que tenemos en el tapete de pruebas (fondo blanco con línea negra).
La variable potencia será la velocidad de inicio que tienen nuestros motores (antes de la corrección). La variable ganancia nos dará el valor del giro (qué motor gira más rápido en función de las mediciones del sensor de luz).

Un vez les hemos dado el valor inicial, realizamos una serie de operaciones para definir el Rango y el PuntoMedio. De eso se encarga el bloque de Asignación de valores.

El Rango es máximo-mínimo. Y el PuntoMedio es (máximo+mínimo)/2.

Ahora queremos que nos muestre en pantalla el valor de las lecturas, el bloque encargado se llama MuestraPantalla y simplemente lee el valor de la variable y lo imprime en pantalla haciendo uso del bloque conversor de Número a Texto.

Finalmente, tras una pausa de 5 segundos llega el bloque de SigueLineas.

Para poder seguir la línea de forma suave, debemos aplicar una corrección a la variable Potencia que inicializamos antes. Esta corrección se calcula con la lectura actual, el rango y la ganancia.

Debemos tener en cuenta que la Ganancia la definimos nosotros, si bien una ganancia grande nos hará ir más fluidos, si la hacemos demasiado grande se producirá un enorme cabeceo debido a una sobre corrección, además de que perderemos la posibilidad de hacer ciertas curvas al aumentar el tiempo de reacción.

En este caso anterior hemos supuesto de que conocíamos unas condiciones iniciales en el tapete, si no conocemos esas condiciones, podemos añadir un bloque que calibre el sigue líneas almacenando los valores de máximo y mínimo.

Para que este calibrado funcione necesitamos inicializar la variable Maximo a 0 y la variable Minimo a un valor lo más alto posible, pues lo que haremos es leer de forma continua y comparar con los valores que ya están almacenados en las variables.

Este sería el programa con calibración

A parte del nuevo bloque de calibrado hemos tenido que añadir un pequeño giro hacia la derecha (con el objetivo de leer valores dentro y fuera de la linea) y posteriormente un giro hacia la izquierda para recuperar la posición inicial.
El programa sin encapsular quedaría así

El bloque de calibrado automático está inspirado en el trabajo de Dave Parker.

Este libro trabaja la programación y diseño, tanto físico como virtual, e incluye multitud de fotografías para facilitar el aprendizaje y trabajo con el LEGO MINDSTORMS NXT, así como las instrucciones de montaje y programación de 9 robots de ejemplo. Los capítulos cubren el uso del lenguaje de programación gráfica con NXT-G, trucos, diseño, uso de sensores, Bluetooth, y hasta la forma de crear un control remoto.

Si estás interesado en disfrutar creando robots de LEGO, este es el libro adecuado. En este se incluye información y consejos que algunos de los autores de The NXT STEP han ido acumulando a lo largo de sus años de experiencia con el NXT. Ha sido escrito por Martijn Boogaarts (uno de los organizadores iniciales de LEGO WORLD), Jonathan Daudelin, Brian L. Davis, James Floyd Kelly, Fay Rhodes, y algunos más. De su mano nos llega una pequeña explicación de los fundamentos de programación y diseño, así como una presentación de las piezas que emplea el NXT, tales como sensores, ejes, vigas, engranajes, etc, y la forma de combinarlas para construir y programar robots.

Los siguientes son algunos de los robots que se construyen en este libro:

• RaSPy, un robot que fruto del trabajo colaborativo entre autores distantes, nos explica las dificultades de dicho procedimiento.
• 3D PhotoBot, que puede ayudarte a tomar fotografías susceptibles de ser convertidas a imágenes 3D, argumento que sirve de base para explicar los fundamentos del proceso.
• Slot Machine, una máquina de juegos que hace uso de 2 NXT.
• ScanBot, un escáner de blanco y negro que presenta el resultado en el display gráfico del NXT.
• Beach Buggy Chair, un robot orientado a la ayuda de los discapacitados
• CraneBot, un sencillo manipulador con forma de grúa.

Se trata en definitiva de una ayuda para avanzar un poco más en el proceso creativo del desarrollo de aplicaciones con el MINDSTORMS NXT.

English

Ya hemos hablado sobre las conexiones bluetooth entre dispositivos (tutorial bluetooth), ahora vamos a profundizar un poco más en las posibilidades de envío y recepción de información en NXT-G.

Primero algunos datos esenciales:

- Cuando hablamos de conexión bluetooth entre NXT debemos distinguir entre NXT Maestro – en adelante NXT-M – y NXT Esclavo – en adelante NXT-E1, NXT-E2… , donde el número denota la conexión que tienen ocupada- . El NXT-M es el que envía la señal, mientras que los NXT-E serán los que la reciban.

- Cada NXT puede conectarse simultáneamente con un máximo de 3 robots (tiene 3 conexiones), que aparecen numeradas del 1 al 3 cuando elegimos conectarnos a otro mindstorms, el número de conexión es su dirección.

- Existe una conexión denotada como “0″, en los NXT-E que es la que ocupa el NXT-M.
OJO Cuando un NXT1 solicita conectarse a un NXT2, no importa la conexión que ocupemos en NXT1, en NXT2 habremos ocupado la “0″! Aún nos quedarán las 3 conexiones (1, 2 y 3) de ese robot libres para conectarse con 3 esclavos.

Es decir, cada robot puede tener:
- 1 maestro (el primero que se conecta con él, ocupa la conexión “0″)
- 3 esclavos (ocupan las conexiones 1, 2 y 3, la conexión debe iniciarse desde el robot que será maestro).

Un error muy común es que NXT1 se conecta a NXT0 (conexión “0″) y NXT2 también intenta conectarse a NXT0 –> “Line is busy!” (”¡Linea ocupada!”).

Sin embargo, si NXT1 se conecta a NXT0 (conexión “0″), NXT0 puede conectarse a NXT2 (conexión “1″), NXT3 (conexión “2″) y NXT4 (conexión “3″) sin problemas, pues éstos últimos serán esclavos de NXT0.

- La conexión siempre debe iniciarse desde el NXT-M. Si lo hacemos al revés no funcionará.

- Aunque podemos estar conectados a varios NXT de forma simultánea, no podremos enviarles información a la vez, tiene que pasar al menos 1 segundo para cambiar de conexión.

- Cada conexión tiene 10 buzones para almacenar información, si las conexiones son las direcciones, los buzones son casilleros. Los buzones pueden almacenar un máximo de 5 mensajes que irán limpiando de más antiguo a más nuevo (sistema FIFO – First In First Out “el Primero en Entrar es el Primero en Salir”)

Ahora que sabemos esto vamos a detallar las condiciones de nuestro experimento.

Si las conexiones son limitadas, ¿cómo puedo trabajar con más de 3 NXT a la vez?

Y la respuesta no es otra que usando repetidores, es decir, si cada uno de los robots que están conectados a NXT-M no sólo ejecutan la acción que corresponde si no que además envían la señal a otros robots, podemos extender la cadena hasta el infinito.

Como se puede apreciar en el diagrama anterior, el NXT-M conecta con 3 NXT-E, cada uno de los cuales conecta con otros 3 (no olvidemos que NXT-E1, NXT-E2 y NXT-E3 tienen ocupada la conexión “0″ por NXT-M, pero las conexiones 1 a 3 siguen libres para enlazar posibles NXT esclavos).

Así, la segunda línea de NXT-E tiene 9 dispositivos, denotados NXT-E XX, donde XX representa con el dígito de la izquierda qué conexión tiene ocupada el NXT que le envía la señal, y el dígito de la derecha, qué conexión se está ocupando en el propio dispositivo.

Bien, lo primero que vamos a hacer es conseguir que un NXT-M se conecte a un NXT-E1, este a su vez conectará con NXT-E12, que conectará con NXT-E121.

El siguiente vídeo muestra los NXT en acción:

Como se puede apreciar, el robot que da la espalda a la cámara es el NXT-M, los demás actúan de forma secuencial de izquierda a derecha desde la recepción de la primera orden.

Los programas que se han usado son simples, vamos a verlos. Mucha atención a los bloques de espera que aparecen en los programas, si bien no tienen porqué durar tanto tiempo, si es imprescindible que existan, tal y como vimos al principio.

Programa de NXT-M

Primero se conecta con NXT-E1 en la conexión 1 (por eso NXT-E1)
Emite una señal lógica verdadero cuando pulsamos el botón derecho del ladrillo.

Programa de NXT-E1 y NXT-E12

Los dos esclavos intermedios tienen el mismo programa base, reciben la señal lógica, ejecutan una acción – en nuestro caso avanzar una rotación-, desconectan de la conexión previa (en esta primera versión) y se conectan automáticamente al siguiente E1 conecta con E12, y E12 conecta con E121.

Programa de NXT-E121

Este, al ser el último de la serie, simplemente espera la señal lógica y actúa.

En estos programas, los NXT enlazan automáticamente entre sí, también podríamos haberlos enlazado de forma manual antes de comenzar la ejecución.

Una cosa muy importante a tener en cuenta antes de empezar es que, para que la conexión automática se lleve a cabo, es necesario que se hayan enlazado previamente al menos una vez.

Además debemos asegurarnos que los NXT-E que enlazan con más de un NXT, realmente enlazan, para ello debemos hacer la comprobación manualmente en: Bluetooth –> Search –> “Nombre de dispositivo” -> Connect –> “conexión que nos interese”. Aceptamos la contraseña, si nos la pide. En ocasiones podemos recibir el aviso “BT store is full error” y la conexión no podrá realizarse, por eso debemos asegurarnos de que enlazan antes de la ejecución.

Como consejo, aunque no es imprescindible, apagad los NXT después de cada ejecución, ya que de no hacerlo se producen problemas de conexión y/o recepción de información.

English

Hoy queremos mostraros en detalle el robot de sumo radio control que ganó más combates en la última competición, aunque su participación estaba fuera de concurso. Que en todo momento estuvo en lo alto de la clasificación ya que se trata de un modelo de perfil bajo, potente y ágil.

En el siguiente esquema se detallan sus especificaciones. Y su misión es clara: “Search & Destroy” (”Localizar y destruir”) ¿Alguien quiere enfrentarse a él?

Tiene dos ruedas con tracción diferencial y una rueda loca en la parte trasera, que le ayuda a mantener la estabilidad. La gran anchura de las ruedas le confieren estabilidad lateral y gran superficie de agarre. En las pruebas que hicimos en el torneo el modelo carecía de la rueda loca posterior (no se aprecia porque está en su interior), lo que hacía que avanzara a saltos en algunos casos. Con esta mejora el problema se ha solucionado.

El robot dispone de una pala frontal que hace uso de dos actuadores lineales para subir y bajar. Estos actuadores se despliegan mediante el motor que hemos denominado de combate. Al estar basados en un tornillo sin fin, estos actuadores tienen bastante potencia y precisión, pero la palanca que se le exige es tan grande que impide volcar a los contrincantes más pesados. En combate se mostró que, si bien no podía volcarlos, por lo menos conseguía desestabilizar a los contrincantes.

La implementación de un nuevo joystick con NXT le permite una mayor capacidad de maniobra, como se puede apreciar en el siguiente vídeo. La gran mejora del nuevo programa permite el giro del robot sobre sí mismo, lo que supone un incremento de maniobrabilidad necesario para un modelo de un tamaño relativamente grande.

El bajo perfil impide que otros vehículos puedan hacer palanca y volcar el modelo. Por otra parte los laterales están fuertemente reforzados y el robot, a pesar de ser bastante sólido no llega a ser tan pesado como para carecer de capacidad de aceleración.

Recientemente vimos un artículo sobre Joystick con NXT-G en base al diseño de Philo y trabajamos con el programa para ir solucionando los problemas que nos fuimos encontrando. Hoy queremos presentar una versión renovada, tanto de hardware como de software, con nuevo diseño y nuevas funciones.

El nuevo montaje permite un mayor grado de libertad de movimientos, además es más estable y sólido.

Incorpora también 2 sensores de presión para trabajar con las distintas acciones posibles del robot que vamos a dirigir.

El programa del joystick es el mismo que vimos la vez anterior.

Lo que ha cambiado sustancialmente es el programa del vehículo, con el fin de dotarle de una de las posibilidades que no tenía su antecesor: giros rápidos sin que exista avance o retroceso.

Vamos a ver cómo funciona el programa.

Esta nueva versión de programa tiene bastantes diferencias con respecto a la anterior, la necesidad de conseguir giros rápidos cuando no se produce avance/retroceso requiere de la inclusión de varias bifurcaciones (o if’s) anidadas.

El valor umbral para las comprobaciones es el intervalo [0,|10|] es decir [-10, 0] U [0,10], nos referiremos a él de ahora en adelante como umbral. Además haremos referencia en las próximas líneas a bifuración 1 – en la que mediremos la potencia que nos llega por bluetooth – y bifurcación 2 – en la que se mide el giro a realizar-.

La idea es la siguiente, mientras que la potencia sea menor el umbral (bifurcación 1 – Opción 1) y el giro sea menor que el umbral (bifurcación 2 – Opción 1) el vehículo no debe moverse.

Si la potencia es menor que el umbral (bifurcación 1 – Opción 1 de nuevo) pero el giro es mayor que el umbral (bifurcación 2 – Opción 2), giramos a toda potencia en el sentido que nos indique el motor, recordemos que el sentido de giro viene dado por el signo, +/- , de la lectura del sensor de rotación.

Cuando la potencia de avance es superior al umbral (bifurcación 1 – Opción 2) trabajamos igual que en el programa de vehículo que ya habíamos visto.

Los programas están disponibles en el foro para su descarga y consulta.

English

El firmware es un programa que está altamente integrado en un dispositivo hardware y forma parte de la lógica de más bajo nivel que controla la electrónica. Suele estar grabado en una memoria tipo ROM, flash ROM o como una imagen binaria que se descarga en el hardware. El hecho de estar tan integrado en la electrónica del dispositivo es lo que lo diferencia del software convencional y que hace que este programa no tenga ninguna utilidad fuera del harware para el que ha sido creado. El firmware es, funcionalmente, el intermediario entre las órdenes externas que recibe el dispositivo y su electrónica (hardware). Por encima del mismo tendríamos el kernel, sistema operativo y aplicaciones.

En ocasiones puede ser necesario volver a descargar el firmware en el NXT. El caso más típico es cuando necesitamos actualizarlo a una nueva versión.

Descarga del firmware
El procedimiento de descarga del firmware en el NXT es el siguiente:
1. Conecta el NXT directamente al PC/Mac mediante un cable USB. Ten en cuenta que la conexión Bluetooth no funcionará: sólo puedes hacer la descarga mediante USB.
2. Presiona el botón de reset hardware en el ladrillo NXT durante al menos 5 segundos. Se trata de un botón muy pequeño que se encuentra en uno de los huecos de la parte inferior de la carcasa del NXT, justo debajo del conector USB. Para presionarlo basta con un clip.

3. Si el NXT está emitiendo un sonido parecido a un “click” antes de presionar el pulsador, dejará de hacerlo después de que presiones el pulsador. Continúa presionando el botón de reset durante varios segundos hasta que haga click de nuevo. Ya puedes soltar el pulsador de reset.
4. Espera a que el NXT-G vuelva a emitir el click de forma contínua (tardará unos 2-4 sg.)
5. Inicia el software NXT-G. Ve a “Herramientas”->”Actualizar Firmware del NXT” y selecciona la versión de firmware que quieres descargar (si tienes varias). Si tienes conexión a internet puedes comprobar si existe alguna versión nueva pulsando “Comprobar”. Al presionar el botón de “Descarga” se realizará la descarga.

6. Si el software es incapaz de descargar el firmware correctamente, verifica todos los pasos anteriores y, además, comprueba que tienes instalada la versión correcta del driver USB:
6.1. Abre una ventana del explorador.
6.2. Ve al directorio “WINNT” o “windows”.
6.3. Ve al directorio “system32″.
6.4. Busca el fichero “fantom.dll”.
6.5. Haz click con el botón derecho y selecciona “propiedades”.
6.6. Comprueba que el número de versión es el 1.0.2.49152. Si difiere debes actualizar el driver USB. Para ello ve a la página de soporte de mindstorms.lego.com (sección Drivers), descarga e instala el MINDSTORMS NXT Driver v1.02 y sigue las instrucciones de instalación. Antes de realizar la instalación debes cerrar el software LEGO MINDSTORMS NXT y desconectar el cable USB del ordenador.

Consideraciones a tener en cuenta en la descarga de firmware
El proceso de actualización del firmware supone reescribir en la memoria FLASH del NXT. Este proceso requiere una alimentación superior a la que se necesita para las lecturas o escrituras habituales, por lo que para la correcta descarga del firmware es aconsejable:

• bien realizar el proceso alimentando el NXT con pilas alcalinas nuevas (podremos volver a nuestra batería una vez la descarga se haya realizado correctamente), o bien
• asegurarnos de que la batería recargable está perfectamente cargada (cargarlas previamente por lo menos durante un par de horas).

Ya publicamos un artículo sobre distintas versiones de joystick con NXT y hablamos de sus posibilidades y el hardware necesario. Hoy queremos centrarnos en la programación de un joystick con NXT-G.

Usaremos como base hardware el diseño del joystick de Philo. Partiendo de esta base hemos añadido un nuevo sensor de contacto para ampliar las funciones. Comentar, sin restar méritos, que el modelo es algo endeble y ciertas partes de desmontan con facilidad – sometido, por ejemplo a la tensión de un combate de sumo-, nada que no pueda solucionarse con un poco de inventiva y algún refuerzo.

Referente al software, tenemos los programas del mando y del vehículo disponibles para descarga, pero al intentar cargarlos a nuestros robots para realizar las pruebas, usamos la versión 2.0 Educativa, no funcionaban.

Vamos a ver los programas originales -atención a los signos de exclamación que aparecen en los iconos, indicando problemas de compatibilidad. Conviene que amplieis la imagen para poder apreciar los detalles.

Programa del joystick (original)

Programa del vehículo (original)

Encontramos los siguientes problemas:

1. Los bloques pertenecen a una versión distinta del software y nuestro NXT-G no los reconocía.
2. Algunos de los intercambios de información entre los bucles/bifurcaciones y los bloques externos a ellos resultan caóticos.
3. El sistema no permite la posibilidad de girar si no se está avanzando o retrocediendo, limitando así las posibilidades de giros rápidos sin desplazamiento.

La solución inicial pasa por reescribir los programas con los bloques nuevos, añadir variables para clarificar los intercambios de información (tutorial de variables) y volver a probar.

Veamos los nuevos programas.

Joystick

Incluye un sensor de contacto adicional y elimina las operaciones innecesarias.

En el programa original del joystick podemos ver cómo antes de enviar la información se realiza una operación matemática que tiene como fin dotar a la lectura del sensor de rotación de un signo (que nos indicará la dirección del movimiento).

En los bloques actuales la lectura del sensor de rotación ya tiene signo, y por lo tanto la información puede ser enviada directamente omitiendo esta operación, tal y como se observa en la segunda versión.

Vehículo

Añade variables para facilitad la legibilidad del programa, atención al inversor de la señal lógica (Verdadero/Falso) que indica la dirección de giro de los motores: sólo es necesaria en nuestro montaje de pruebas – un tribot – ya que los motores están dados la vuelta.

Además quiero destacar el escalado del valor numérico a partir del cual obtendremos el giro (variable Buzón 2) que utiliza una fórmula:

Valor escalado = signo(mensaje recibido)* mensaje² / 30

Como hemos dicho antes, el valor numérico procedente del sensor de rotación, ya tiene signo, pero nuestra fórmula elevamos ese valor al cuadrado (mensaje²), lo que lo elimina; de ahí la necesidad de añadírselo de nuevo (signo(mensaje recibido)*).
No debemos olvidar que el elemento Dirección del bloque Mover está representado como un valor numérico comprendido entre -100 y 100, donde los valores inferiores a 0 representan movimientos hacia la izquierda, y los valores mayores que 0 movimientos hacia la derecha.

Esta implementación que acabamos de ver soluciona los dos primeros problemas. Veremos cómo resolver el tercer problema en otro artículo.

Información adicional:

• Instrucciones en PDF del diseño del joystick de Philo.