LabVIEW para usuarios del NXT (I)

Artículo nº 1 de la serie de 14 artículos sobre LabVIEW

English

Los programas escritos en LabVIEW se llaman Instrumentos Virtuales o

VIs y se guardan con la extensión Vi. Al iniciar LabVIEW nos encontramos con la ventana de

introducción. Si ya disponemos del LabVIEW, el primer paso para poder trabajar con LabVIEW

sobre Mindstorms NXT es descargar el toolkit gratuito de National Instruments que lo permite. Esta

expansión permite crear y descargar nuevos VIs que nos harán posible controlar el sistema NXT de

LEGO.

El Toolkit para el MINDSTORMS de NI nos permite:

Programar y controlar al NXT con toda la potencia de LabVIEW.

Obtener información actualizada en tiempo real del dispositivo durante la operación del

programa NXT mediante los paneles frontales de LabVIEW.

Crear nuevos bloques nativos para el software gráfico NXT-G o modificar los existentes.

Esto puede ser muy útil si desarrollamos hardware a medida para el NXT.

Poner texto:Nuestro primer programa no podía ser otro que el clásico que

presenta el mensaje “hola mundo” en el display del NXT, pero en nuestro caso, y dada la sencillez

del programa, lo ampliaremos para permitir presentar cualquier mensaje.

Para crear nuestro primer programa es necesario abrir un VI en blanco. Cada vez que queramos

crear un nuevo programa para el ladrillo NXT, tendremos que abrir una nueva VI en blanco. Si

seleccionamos un NXT VI, en lugar de un nuevo VI, la ventana flotante de funciones contendrá los

propios del NXT. La pantalla que nos encontramos es similar a la siguiente:

Vemos que aparecen dos pantallas.

Panel frontal. La pantalla gris se denomina panel frontal. Aquí es donde creamos los

controles e indicadores que queremos que vea el usuario. Los controles se utilizan para

dar valores de entrada al programa, mientras que los indicadores sirven para mostrar los

resultados de la ejecución del programa. Si hacemos clic con el botón derecho sobre el

panel frontal podemos ver la paleta de controles, que nos permitirá hacer uso de los

indicadores, controles y decoraciones. Conviene surfear un poco por la jerarquía de estos

controles para familiarizarnos con ellos.

Diagrama de bloques. La pantalla blanca es el diagrama de bloques. En esta pantalla es

donde debemos crear el código gráfico que se ejecutará en el ladrillo NXT. Los elementos

básicos de los que constarán nuestros programas serán terminales, VIs y funciones, y

cables.

Empecemos nuestro primer programa. El código de programa lo vamos a representar mediante

bloques gráficos, por lo que nos situamos en la ventana del diagrama de bloques. Como queremos

presentar un texto en el display, necesitamos buscar el bloque que se encarga de ello. Para

acceder al mismo pinchamos con el botón derecho sobre la ventana del diagrama de bloques y

seguimos el menú: NXT Robotics, NXT I/O, Display. Pinchamos el icono y lo arrastramos a la

ventana del diagrama de bloques.

En la imagen anterior he representado

el bloque que representa al display del NXT (A),

el aspecto que adquiere cuando posicionamos el cursor sobre el mismo (B), que nos está

mostrando los puertos de entrada y salida del bloque, y

en (C), las opciones que se me presentan cuando pincho sobre el texto “text” que se

encuentra en la parte inferior del bloque. En este caso seleccionamos la operación de

escribir un texto (WRITE TEXT). Entre las otras opciones disponibles tenemos la de escribir

texto en otros formatos (entero o flotantes), dibujar puntos, líneas, círculos, etc, o borrar

el display. Esto nos recuerda a las mismas opciones del icono gráfico del display de NXT-G,

¿verdad?

El siguiente paso es incorporar el bloque que nos permite introducir el texto. Existe una relación

entre el panel frontal y el diagrama de bloques. Podemos hacerlo patente con un ejemplo.

Volvamos al panel frontal pinchando sobre la ventana del mismo, botón derecho del ratón para

abrir el desplegable, NXT Robotics, String & Path, String Control, y obtenemos:

Vemos que con lo anterior no sólo se ha creado la caja de entrada de datos de texto en el panel

frontal, sino que además se ha creado un nuevo bloque en el diagrama de bloques. Lo mismo

habría sucedido si lo hubiéramos creado en el diagrama de bloques, que habría aparecido su

equivalente en el panel frontal.

Dado que la cadena de texto que queremos presentar en el display es la que introducimos en la

caja de datos que acabamos de crear, debemos unir los dos bloques. Para ello pinchamos sobre el

diagrama de bloques con el botón izquierdo y, al acercar el cursor al triángulo del bloque de

entrada de strings vemos que el cursor se transforma en un pequeño carrete de hilo, lo que nos

indica que podemos extender la conexión. Lo hacemos hasta llevar

la conexión a la parte izquierda del bloque del display. Aparecerá un pequeño cuadrado negro

parpadeante indicando el punto de conexión. La conexión creada no va a presentar problemas

porque los datos que genera esta caja de entrada son compatibles con los que espera recibir el

display tal como lo hemos seleccionado.

Lo que hemos realizado hasta ahora ya puede considerarse nuestro primer programa, aunque de

poca utilidad todavía. Para ejecutarlo seguimos el siguiente proceso:

Conectamos el NXT (que debe disponer de batería cargada) al PC mediante el cable USB y

presionamos el botón naranja del NXT. A continuación,

Debemos conectar el LabVIEW con el NXT. Para conseguirlo, bien desde el panel frontal o

desde el diagrama de bloques, vamos al menú Tools, NXT Tools, NXT Terminal. Esto creará

una nueva ventana en la que se indica el NXT al que se ha conectado, su nombre, tensión

de batería, ficheros que contiene, etc. Si no es así, buscamos el desplegable en el que

pone “Find NXT…” para dar con el mismo haciendo scan.

Con el NXT conectado podemos cerrar la ventana flotante del NXT y

presionamos el botón Run de la izquierda con el dibujo de la flecha.

Al ejecutar el programa anterior aparentemente no conseguimos nada, pero si nos fijamos en el

display del NXT vemos que no es así: el display queda en blanco durante un instante, para volver

inmediatamente a mostrar la pantalla de inicio. Lo que sucede es que el programa está

presentando el contenido de la caja de entrada, y éste ¡no contiene nada!.

Probemos ahora lo siguiente: vamos al panel frontal y escribimos “Hola

mundo” en la caja marcada como “String”. Si ejecutamos ahora pinchando el botón de Run y nos

fijamos en el display, ahora sí veremos que en el display aparece nuestro “Hola mundo”. Es un

suspiro, pero suficiente para comprobar que nuestro primer programa funciona.

Para extender el suspiro podemos ejecutar lo anterior de forma repetitiva, por ejemplo

introduciendo el programa anterior dentro de un bucle. Veamos cómo se hace.

Vamos al diagrama de bloques, botón derecho, Express, Exec control, While Loop. Esto nos crea

una caja cuyas dimensiones podemos modificar. Todo su contenido interno se ejecutará

hasta que presionemos el botón de STOP, que también ha

aparecido en el panel frontal. Nos falta introducir nuestro primer programa inicial en el interior del

bucle while que acabamos de crear. Esto podemos hacerlo seleccionando el programa inicial y

desplazándolo al interior del bucle, o selecionando el bucle y desplazándolo hasta que encierre al

programa inicial. Os recomiendo que probeis ambas alternativas. El resultado debe ser parecido al

que aquí se ve.

Si ejecutais este nuevo programa podeis ver que ahora sí que se mantiene el texto en el display

del NXT. ¿Cuánto tiempo? El programa no se detiene hasta que no pulsemos el botón de STOP del

panel frontal, que es la condición de salida del bucle while que hemos dibujado. Podemos jugar a

escribir varias cosas y ver el resultado obtenido. Nos daremos cuenta de que si pulsamos enter

estamos pasando a la línea inferior del display (los resultados que escribimos en el panel frontal no

se actualizarán en el display hasta que no pinchemos con el ratón fuera de la caja de entrada de

datos). Podemos además desplazarnos por el display usando las flechas del teclado.

Si recapitulamos nos podemos dar cuenta de la potencia del LabVIEW. Con tan solo 2 minutos y 3

iconos hemos creado una aplicación en el PC que nos permite presentar datos remotamente y en

tiempo real sobre el NXT. Este mismo programa es imposible de emular, por ejemplo, en NXT-G,

dado que el entorno NXT-G no nos permite crear aplicaciones que se ejecuten fuera del NXT: el

ejemplo anterior es una muestra de la interacción entre dos aplicaciones, una ejecutándose en el

PC y otra en el NXT.

Comentarios y dudas, como siempre, en el foro.

LabVIEW para usuarios del NXT (II)

Artículo nº 9 de la serie de 14 artículos sobre LabVIEW

English

En el artículo LabVIEW para usuarios del NXT (I) vimos como crear

un VI, y empezamos con un programa de prueba (el famoso “Hola Mundo”). En el artículo de hoy

vamos a ahondar un poco más en el manejo básico de LabVIEW, y ver manejo de motores y de

algún sensor.

Manejo de Motores:

Para manejar el motor la función que debemos usar es Motor, que la podéis encontrar haciendo

click derecho en el Block Diagram y seleccionando NXT I/O → Motor:

Una vez coloquemos nuestro motor podemos observar que tiene varios modos de funcionamiento

con distintas entradas y salidas. Para cambiar entre estos modos tenemos que clickear en el menú

desplegable. Los modos son los siguientes:

Motor On: Forward

Hace que los motores se muevan marcha adelante con la potencia que escojamos. En Output Port

escogemos el Puerto (Port A, Port B, Port C o todos), en Power la potencia deseada, y los demás

conectores son para el flujo del programa como ya vimos en el artículo anterior.

Motor On: Reverse

Funciona de manera parecida al anterior, solo que con los motores marcha atrás.

Motor Off: Brake

El motor frena, tratando de detenerse lo más rápido posible. En Port elegimos el puerto del motor

que deseamos que frene.

Motor Off: Coast

El motor deja de acelerar, volviendo poco a poco a la inmovilidad. No es un frenazo brusco, por lo

que se seguirá desplazando hasta detenerse. Igual que en el anterior elegimos el puerto del motor.

A la hora de elegir a que puertos están conectados, o con que potencia van a moverse, tenemos

que enganchar los valores deseados a las entradas (ya sea mediante constantes, controles….). La

manera más cómoda de hacerlo es creando estas constantes, controladores o indicadores ya

enganchados al las salidas y entradas. Para ello haced click derecho en la entrada o salida

deseada y seleccionad Create y lo que queráis enganchar:

Manejo de Sensores:

Para manejar los sensores utilizamos la función Sensor, que la podéis encontrar haciendo click

derecho en el Block Diagram y seleccionando NXT I/O → Sensor. En este caso tenemos muchos

sensores distintos disponibles, aunque no vamos a ver todos aquí. De momento me centraré en los

dos más simples, el de contacto y el de luz.

Contacto: Pressed

Nos devuelve si el sensor de contacto está presionado o no (es un valor booleano). Tenemos que

decirle a que puerto de sensores está conectado (Port 1, Port 2, Port 3 o Port 4).

Luz: Luz encendida

El sensor de luz nos devuelve un valor que representa la cantidad de luz ambiente que detecta. En

este caso el sensor enciende una pequeña luz que le sirve para ver mejor, reflectando esta luz

contra objetos cercanos por ejemplo, lo que sirve para distinguir colores. Hay que decir a que

puerto está conectado.

Luz: Luz apagada

De funcionamiento parecido al anterior esta vez actúa con su luz apagada, lo cual nos sirve para

detectar luz ambiente, y saber por ejemplo que parte de una habitación está más iluminada (ya

que al no tener el sensor su luz encendida, esta no interfiere en los valores que capta). Sin

embargo este modo no sirve para distinguir colores.

Bucles While:

Un bucle es una estructura en la que continuamente se repite lo que haya dentro hasta que se

cumpla una condición de salida que elegimos nosotros. Esta condición de salida tiene que devolver

un valor booleano (verdadero o falso), como el que devuelve el sensor de contacto. Los búcles

While los podéis encontrar en Structures → While Loop:

Veréis un ejemplo sencillo de su uso en el programa de prueba que pongo a continuación.

Programa de prueba:

Vamos ha hacer un pequeño programa en el que usaremos un par de motores y un sensor de luz.

El programa consistirá en un robot que va girando mientras toma valores con el sensor de luz y los

muestra por el Display del NXT. El programa terminará cuando presionemos el sensor de contacto

Para que un robot gire un motor ha de moverse más rápido que el otro, esto se consigue

aumentando la potencia de uno de los dos. En este caso vamos a tener un robot con los motores A

y C, y le daremos mayor potencia al motor A.

Para que se repita la lectura del sensor de luz, y el display del valor en la pantalla del NXT, es

necesario meter todo esto en un bucle (while en este caso). Como condición de salida del bucle

pondremos que el sensor de contacto esté presionado, de manera que el programa terminará su

ejecución cuando esto ocurra. El Block Diagram quedaría así:

Cuando este terminado lo compiláis y descargáis al NXT, y lo ejecutáis. Si tenéis alguna duda

podéis consultar nuestro foro.

LabVIEW para usuarios del NXT (III)

Artículo nº 10 de la serie de 14 artículos sobre LabVIEW

English

En esta tercera entrega de los artículos tutoriales sobre LabVIEW vamos

a ver nuevos sensores, como el de ultrasonido, nuevas estructuras, y otros métodos para usar los

motores. Esto nos servirá para ampliar los conocimientos que ya tenemos y así poder crear

programas más complejos.

Manejo de Motores:

Hemos visto como poner los motores en funcionamiento o pararlos, pero sin embargo a veces

queremos que recorran cierta distancia (que giren un número de grados determinados). Para ello

existe esta función:

Drive distance

Gira el motor x grados, donde x es el valor que especifiquemos en distancia. En Output Port

debemos indicar a que puerto esta conectado el motor/motores que queremos girar.

Esta función la podemos encontrar haciendo click derecho en el Block Diagram y metiéndonos en

NXT I/O → Complete → Motor → Drive Distance.

Manejo de Sensores:

En el artículo anterior vimos como poner un sensor, seleccionar su tipo, y vimos el

funcionamiento del sensor de contacto y de luz. En este artículo introduciré el sensor de

ultrasonido y el sensor de rotación:

Sensor de ultrasonido

El sensor de ultrasonido devuelve la distancia al obstáculo más próximo que tenga enfrente

medida en cm. Hay que indicar a que puerto de sensores está conectado (preferiblemente el 4 ya

que es el puerto rápido). La posibilidad de medir distancias abre muchas posibilidades, nos

permite que el robot navegue por un entorno sin chocar con obstáculos por ejemplo, o también

nos sirve para saber como de cerca estamos de nuestro objetivo.

Sensor de rotación

El sensor de rotación mide la cantidad de grados que hemos recorrido desde que iniciamos el

programa. Esto sirve básicamente para saber la distancia recorrida, y compararla por ejemplo con

la que nosotros queriamos que recorriera. No hay que especificar puerto de sensores, sino de

motores, ya que el sensor de rotación se encuentra dentro de los motores.

Estructura Case:

La estructura case es una estructura condicional que nos permite ejecutar una parte u otra del

código según que valor tome determinada variable o elemento de nuestro programa. La estructura

case la podéis encontrar en Structures → Case Structure:

En este caso vamos a utilizar su variante más simple, que usarla como una estructura if. Lo que le

metemos es una valor booleano, en caso de que valga True ejecutará una parte del programa, y

en caso de que sea False otra. Para escribir en una parte u otra tenemos que clickear en la

pestaña superior para que se nos abra el menú desplegable:

Hay muchas cosas que devuelven valores booleanos, como el sensor de contacto, o todas las

comparaciones que podéis encontrar en Comparison (igual, menor que. mayor que…).

Programa de prueba:

En el programa de hoy vamos a utilizar todo lo que hemos visto hoy más lo que vimos en el

anterior tutorial. El programa va a consistir en un robot móvil que se desplaza gracias a dos

motores (A y C). El robot cuenta con un sensor de ultrasonidos, y cuando este detecte un

obstáculo a menos de 40 cm. el robot se parará instantáneamente y girará para esquivar el

supuesto obstáculo. Una vez termine esta maniobra seguirá adelante hasta que detecte otro

obstáculo. El robot se detendrá cuando su motor A haya recorrido más de 6000º.

Por tanto para este programa necesitamos un bucle while, un case que ejecute cosas diferentes

dependiendo del valor del sensor de ultrasonidos, un sensor de ultrasonidos, un sensor de

rotación, y manejo de motores, tanto para moverlos y frenarlos, como para decirles que recorran

una distancia determinada. El Block Diagram es el siguiente:

En caso de que haya un obstáculo a menos de 40cm.:

En caso de que no haya nada a menos de 40cm.:

Espero que os animéis a intentar programar cosas con LabVIEW ya que es sencillo de manejar y

tiene muchas más posibilidades que NXT-G. Ante cualquier duda podéis preguntar en el foro.