¿Qué es este blog?

La idea de este blog nace para compartir los avances que se vayan realizando a lo largo de un estudio sobre cómo interconectar los distintos sensores que se pueden encontrar en el mercado, o fabricar de forma casera, con la plataforma Mindstorms de LEGO. Para ello se hará uso ARDUINO, un entorno de desarrollo abierto basado en microcontrolador.
Mostrando entradas con la etiqueta NXT. Mostrar todas las entradas
Mostrando entradas con la etiqueta NXT. Mostrar todas las entradas

lunes, 7 de marzo de 2011

Solución a los problemas entre Arduino Mega 2560 y el Mindstorm

En primer lugar, hacer referencia a una publicación que hice hace unos días, donde explicaba el problema y aún no le había encontrado solución: enlace

En ella, básicamente comentaba los problemas que tenía para comunicar el NXT con la placa Arduino Mega 2560 mediante I2C. Voy a resumir el problema con datos y medidas para que todo quede bien claro, y finalmente pondré la solución a la que hemos llegado.
  • En primer lugar, se hicieron pruebas de comunicación I2C entre Arduino Duemilanove y el NXT. La conexión entre ambos era la siguiente:
    • Pines 2 y 3 del NXT (Rojo y negro) (tierra) --> Arduino GND.
    • Pin 4 del NXT (alimentacion) (verde) --> Arduino 5V
    • Pin 5 del NXT (Amarillo) (SCL) --> Arduino A5
    • Pin 6 del NXT (Azul) (SDA) --> Arduino A4
    Con estas conexiones, y un programa sencillo que simplemente recogiera algunos datos del Arduino y los mostrara en la pantalla del NXT todo funcionó perfectamente. El programa usado también lo comenté en otra publicación y lo podéis encontrar aquí.
  • El siguiente paso era hacer el mismo intercambio de datos usando una placa algo más potente y con más prestaciones: la Arduino Mega 2560. Las conexiones que se tienen que hacer para ellos son estas:
    • Pines 2 y 3 del NXT (Rojo y negro) (tierra) --> Arduino GND
    • Pin 4 del NXT (alimentacion) (verde) --> Arduino 5V
    • Pin 5 del NXT (Amarillo) (SCL) --> Arduino SCL
    • Pin 6 del NXT (Azul) (SDA) --> Arduino SDA
Bien, haciendo esto y lanzando exactamente el mismo programa que en el caso del Arduino Duemilanove tanto para el Mindstorm como para el Arduino... no pasó absolutamente nada. Es decir, no hubo intercambio de datos. ¿Por qué? Bueno, voy a ir explicando los pasos que he dado hasta dar con la solución...
    Diferencias entre Arduino Duemilanove y Arduino Mega 2560
    Si nos fijamos en los esquemáticos de ambos (disponibles en la página oficial de Arduino), hay una diferencia en el camino que recorren tanto la señal de datos (SDA) como la de reloj (SCL) del protocolo I2C desde el conector hasta el microcontrolador. Se trata de dos resistencias de pull-up, de un valor de 10K que sirven para mantener el valor lógico "uno" si la tensión en la línea no es suficiente. Estas resistencias son las que nos están originando el problema, como entenderemos enseguida. Estas resistencias las vemos en la siguiente captura (extraída del esquemático):

    ¿Por qué pueden dar problemas?
    En principio, una resistencia de pull-up no es malo, sino todo lo contrario. Pero en este caso nos está perjudicando. Vamos a analizar el recorrido de las señales de reloj (SCL) y de datos (SDA) en el Mindstorm en el caso del puerto A (es idéntico para todos los puertos). 

    En la figura que tenemos aquí vemos como del procesador (AT91SAM7S256) salen las señales DIG1A0 y DIG1A1. Estas son las señales SCL y SDA respectivamente. 



    Estas señales, van a parar al circuito siguiente:


    En él vemos el recorrido que hacen hasta obtener las señales DIGIAI0 y DIGIAI1 que son las que tendremos a la salida (podemos ver el conector en la figura inferior). Si nos fijamos, estas señales pasan por una resistencia en serie de 4,7 K y a continuación tienen conectadas unas resistencias de pull-up de 82 K que van alimentadas a 5V (ver nota 1). 


    Esta resistencia de pull-up de 82 K, al conectar nuestro Mindstorm con la placa Arduino Mega 2560 se asocia en paralelo con la de 10 K de dicha placa, formando una resistencia equivalente de 8,91 K (es decir, casi diez veces inferior a la original). 
    El procesador nos dará como nivel alto un valor de 3,3 V, y como nivel bajo 0 V. Si hacemos algunos cálculos (teniendo en cuenta el circuito equivalente) para calcular qué valores vamos a tener a la salida en cada caso, obtendremos lo siguiente:


    • Circuito equivalente conectando el NXT con Arduino Duemilanove: se obtiene un valor a la salida de 3,40 V (nivel alto) y de 0,28 V (nivel bajo).
    • Circuito equivalente conectando el NXT con Arduino Mega 2560 (y por tanto con el paralelo de las dos resistencias de pull-up): se obtiene un valor a la salida de unos 3,89 V (nivel alto) y 1,70 V (nivel bajo).

    Lo que parece, es que el valor de tensión a la salida para el nivel alto será detectado sin problemas, pero para el nivel bajo, en el caso del Arduino Mega tenemos 1,70 V. Es un valor demasiado alto, y probablemente pueda confundirse con el '1' lógico haciendo que la comunicación falle. Esto se debe a que la resistencia de 4,7 K que vemos en serie a la salida del Mindstorm, está alterando el valor de tensión que hay a la salida y hace que las resistencias de pull-up entren en acción cuando no deberían, es decir, cuando la línea está a nivel bajo.

    Primeras medidas
    Todas las medidas que se describen a continuación han sido realizadas con un osciloscopio digital de la marca Tektronix, modelo TDS 210, del departamento de Ingeniería de Sistemas y Automática de la Universidad de Málaga.

    Lo primero que se hizo fue, para descartar que hubiera cualquier problema en los puertos I2C de la placa Arduino Mega 2560, interconectar dicha placa con la de Arduino Duemilanove y ponerlas a intercambiar datos. Hay muchos ejemplos de esto por internet, pero el que seguimos fue este. Al hacer esto, vimos que la comunicación era correcta, y que las señales de datos y de reloj mantenían un valor medio de señal próximo a los 5 v (de aproximadamente 4,90 V y cercano a 0 para el '0' lógico.

    A continuación, para comprobar los cálculos teóricos que comentamos en el apartado anterior, se hicieron las medidas conectando en primer lugar el NXT con la placa Duemilanove, y a continuación con la Mega. Lo que se vio confirmó lo que pensábamos, ya que, aunque el valor medio de las señales era similar, en el caso de la conexión con Arduino Mega la señal tenía la mitad de amplitud (unos 2 V pico a pico) y su extremo inferior estaba cercana a los 2 V, mientras que con Duemilanove el pico inferior rozaba los 0 V y tenía una amplitud de 4 V pico a pico.

    Por lo tanto, efectivamente el nivel bajo de la señal se está confundiendo con el nivel alto. 

    La solución
    Tras todo este proceso, la única solución viable era la de eliminar las resistencias de la placa de Arduino Mega 2560. Para aquellos que tengan el modelo Arduino Mega (versión anterior) lo tendrán más fácil, ya que lo que tienen es simplemente dos resistencias separadas que se pueden desoldar y eliminar fácilmente. En nuestro caso, es algo más complejo ya que las resistencias están dentro de un encapsulado DIL, que contiene además la resistencia que mantiene el reset a nivel alto hasta que lo pulsemos. Si se eliminase este encapsulado (que vemos en la figura inferior con un 103 escrito), se estaría dejando el reset permanentemente a nivel bajo, y por lo tanto la placa no llegaría a encenderse. 


    (Gracias por la captura a Chiva, del foro oficial de Arduino :) )

    Aunque había otra alternativa, como desoldar el encapsulado, y colocar después una resistencia de 10k para el reset, optamos por "cortar" las líneas de datos que unían las pistas de SDA y SCL con las resistencias. Para ello, nos fijamos en el esquema de PCB de Arduino (también disponible en la página oficial) y elegimos el mejor sitio para el corte. En las dos figuras de abajo se han resaltado las líneas SDA y SCL, y se ha marcado en verde el sitio por el que se ha hecho el corte:




    Y tras hacer estos cortes (con cuidado, arañando con un cúter hasta comprobar con un multímetro que la vía por la que pasa la señal y la patilla de la resistencia ya no hacían contacto) se ha vuelto a probar la comunicación entre el NXT y el Arduino Mega 2560 y... todo funciona correctamente :)

    Nota1: Sobre la tensión VCC_RS485


    En los cálculos se ha asumido que la tensión VCC_RS485 es de 5 V. Para ello, se ha recurrido una vez más al esquemático. El diagrama de bloques del sistema de alimentación se puede ver a continuación.



    Si nos fijamos, la señal VCC_RS485 tiene a su entrada un conmutador que alterna su valor entre 5 V y un circuito abierto. La señal que controla esto es POWER_EN que procede del ATMEGA48, y que corresponde al pin PB7. Se trata de una señal periódica generada por el oscilador interno del microcontrolador y que hace que el conmutador vaya abriéndose y cerrándose continuamente. 







    miércoles, 26 de enero de 2011

    Configurar Lejos en Eclipse en Mac OS X

    A continuación pongo un tutorial (el mejor que he encontrado) de cómo configurar Eclipse en OS X. Está hecho por los chicos de RoboByte, y el enlace está al final. Funciona a la perfección.

    Instalación de Entorno Eclipse
    Para los que se instalen por primera vez la versión 3.5.1, avisar de que esta tiene problemas con la gestión de ventanas de Gnome (debido a recientes cambios en Gtk). Cuando no funcionen los botones utilizar el INTRO ó ALT+Tecla Botón.
    1. Instalamos Eclipse si todavía no lo tenemos
      Bajar la versión Classic desde Eclipse.org
      Lo descomprimir en un directorio cualquiera y lo ejecutamos
    2. Añadir el Plugin a Eclipse
      Help > Install New Software > Add...
      Name: leJOS
      Location: http://lejos.sourceforge.net/tools/eclipse/plugin/nxj/
    3. Lo instalamos
      Para la versión 3.5.1 es necesario desmarcar la opción "Group items by category"
      Establecer las preferencias:
      Window > Preferences > leJOS NXJ
      NXJ_HOME: /opt/lejos
      Marcar "Conection Type > USB"
      Marcar "Run program after upload"
      Marcar "Verbose"
    Crear un Proyecto
    1. Para crear un proyecto para nuestro lego lo hacemos como uno normal de Java
      File > New > Java Project
    2. Convertimos el proyecto Java en leJOS
      Sobre el Proyecto, botón derecho: leJOS NXJ > Convert to leJOS NXT Project
    Añadir documentación Javadoc
    1. Seleccionamos la librería desde el Package Explorer
      References Libraries > classes.jar > (botón derecho) >Properties > Javadoc Location
      Javadoc URL: http://lejos.sourceforge.net/p_technologies/nxt/nxj/api/
    Compilar un Proyecto
    Podemos compilar el proyecto manualmente cada vez que queramos probarlo, pero resultará a la larga más cómodo tener unos accesos directos ya puestos en Eclipse. Vamos a crear tres enlaces, para compilar, enlazar y subir al Lego.
    1. Nos dirigimos a: Run > External Tools > External Tools Configuration
    2. Sobre: Program > New launch configuration
    3. Creamos el enlace de compilacion con los siguientes parámetros
      Name: LeJOS Compile
      Location: ${env_var:NXJ_HOME}/bin/nxjc
      Directory: ${project_loc}/src/
      Arguments: ${java_type_name}.java
    4. Creamos el enlace de enlazado
      Name: LeJOS Link
      Location: ${env_var:NXJ_HOME}/bin/nxjlink
      Directory: ${project_loc}/src/${java_type_name} -o ${java_type_name}.nxj
      Arguments: ${java_type_name} -o ${java_type_name}.nxj
    5. Creamos el enlace para subir el programa al lego
      Name: LeJOS Upload
      Location: ${env_var:NXJ_HOME}/bin/nxjupload
      Working Directory: ${project_loc}/src/
      Arguments: ${java_type_name}.nxj
    6. Creo obvio decir que para compilar y subir el programa habrá que seguir los pasos de forma ordenada: Compilar, Enlazar y Subir, xD
    Como último paso, hacemos un simple "Hello World" para comprobar que toda la configuración está correcta y que ya podemos ponernos manos a la obra.

    ----------------------------------------------------------------------------
    REFERENCIAS:
    Este tutorial ha sido sacado de aquí.

    Como instalar LejOS en Windows XP usando Eclipse

    Antes que nada comentaros que el siguiente tutorial no está redactado por mi. El sitio del que lo he sacado se encuentra al final de este post (como siempre en referencias) y todo el mérito es de los respectivos autores. Mi idea es elaborar un tutorial más actualizado, y si tengo tiempo lo subiré al blog en sustitución de este. Mientras tanto, espero que os sea de ayuda :)

    -------------------------------  
    Aquí explicaremos como instalar y configurar todo el software necesario para desarrollar programas en java para el robot Lego Mindstorms NXT usando Lejos y software enbebido en el robot, es un metodo que permite colocar pequeños programas java adentro de la memoria del mismo y así proveer más independencia al mismo.
    Se incluyen también referencias a sitios de interés y dos libros muy buenos para trabajar con los NXT.
    Java es mucho más poderoso y flexible que el software provisto por Lego, NXT-G. Usaremos el editor Eclipse para escribir el código Java y bajarlo al NXT. Esta combinación permite escribir el software y convenientemente probarlo rápido en el NXT. Claro que hay muchos otros editores de Java, pero esta es una opción bastante viable. El tutorial es para plataforma Windows con la compilación LeJOS una alternativa muy buena para iniciarse en este campo, ya que no es dificil de instalar y las funciones son bastante intuitivas como se verá en el programa de ejemplo, seguiremos los siguientes 5 pasos:
    1. Instalar Java en la computadora
    2. Instalar el driver Lego NXT USB en la computadora.
    3. Instalar Lejos en la computadora y en el Robot NXT
    4. Instalar y configurar Eclipse en la computadora
    5. Escribir, bajar y correr un programa “HolaMundo”

    Es importante seguir el orden de estos pasos uno a uno, además recomendamos estos excelentes libros, mayan adventure y extreme NXT, ambos con información básica de los robots como su construcción y empleo pasando luego a cualidades más avanzadas (se detallará más en otro post sobre los libros).
    En Mayan se diseña software para que salgan de un laberinto y en extreme se presentan múltiples ideas de proyectos con los NXT y cuestiones avanzadas como el quemador de pics y otros, con fotografías y guías paso a paso.

    Libros

    Mayan AdventureLego Extreme NXT

    1. Instalar Java en la computadora

    Descargar e instalar Java SE (Stadard Edition) JRE (Java Runtime Environment). No es necesario instalar el JDK (Java DEveloper Kit). Luego se instalará Eclipse, que contiene todas las herramientas necesarias para escribir y compilar los programas. Luego de la instalación no es necesario definir ningún Path o Classpath para Java. Java se instala normalmente en C:\Program Files\Java.

    Si ya se tiene Java hay que revisar que por lo menos sea la versión 5, de preferencia del JRE, el JDK también funciona. Luego se instalará Eclipse que requiere esta versión como mínimo.

    2.Instalar driver USB de Lego

    El NXT se puede conectar a la computadora por USB o por Bluetooth. La comunicación por USB es más confiable y rápida que la por Bluetooth. El Bluetooth depende de cada computadora en especifico. USB en cambio, esta más estandarizado. Primero se debe instalar el driver y hasta después, conectar el NXT con el cable USB. No se necesita instalar el software que viene en el CD del robot porque no se programará en NXT-G (El software de lego basado en Labview). Solo se necesita instalar el driver USB que esta disponible en el sitio oficial de Mindstorms. Si ya se ha instalado el software original de Mindstorms no es necesario desinstalarlo, solo revisar si el sitio de mindstorms tiene alguna actualización para el dirver USB.
    Descargar el Driver de Mindstorms NXT.

    Descomprimir el archivo y ejecutar setup.exe.

    Recorrer el programa de instalación

    Es possible que windows solicite reiniciar el equipo luego de la instalación. Luego, se conecta el NXT por medio del USB. Comprobar la correcta instalación del driver comprobando si esta en el adminstrador de dispositivos. Para hacer esto, dar click derecho en “My Computer” y luego “Properties” pasar a Hardware. Dar Click en “Device manager”. Tiene que aparecer “Lego Devices=>Lego Mindstorms NXT”

    3. Instalar Lejos en la computadora y en el Mindstorms NXT

    Bajar Lejos.

    Crear un directorio llamado “ProgramFiles” en el disco duro. Esto para evitar problemas con el espacio asociado al usual “Program Files” que a veces no funciona correctamente con Java. Luego se instalará Eclipse también en “ProgramFiles”.
    Descomprimir Lejos. Esto nos dará una carpeta llamada “lejos_nxj”. Colocar esta carpeta en “ProgramFiles”.

    Ahora hay que informar a Java de la existencia de la librería Lejos. Dar click derecho en “My Computer” y seleccionar “Propiedades”. Click en la pestaña “Advanced”. Click en “Environment Variables” hasta abajo. Crear una nueva “System variable”dando click en “New” hasta abajo. No crear una “User variable” de arriba.

    Por nombre poner a la nueva system variable:
    LEJOS_HOME
    Y dar el value:
    C:\ProgramFiles\lejos_nxj
    En pocas palabras, Lejos necesita saber donde fue instalado. Notar que ahora ya usamos el nuevo directorio “ProgramFiles” que no tiene el carácter de espacio. Al finalizar, dar click en OK.

    Verificar que la variable del sistema aparece en la lista. Ahora, se necesita agregar la variable LEJOS_HOME a la variable del sistema “Path”. Seleccionar “Path”de la lista y dar click en “edit”. Agregar:
    ;%LEJOS_HOME%\bin
    Al final del valor. Los distintos valores estan separados por punto y coma y no se require punto y coma al final de la linea.

    Ahora hay que probar si se instaló correctamente Lejos usando una ventana de comandos DOS. Dar click en el menú inicio, luego “All Programs=>Accessories=>Command Prompt”. Escribir:
    lejosdl
    El resultado debe ser como en esta imagen, si es así, todo esta bien.

    Ahora hay que reemplazar el firmware original que viene con el NXT por Lejos. Esto solo se hace una vez. Luego Lejos funcionará como el sistema operativo del NXT. Implementa una maquina virtual Java donde se pueden correr los programas Java. Asegurarse de que el NXT está conectado a ala computadora con un cable USB y que ha sido reconocido por el sistema operativo. Para asegurarse ir al Device Manager. Primero se necesita colocar al NXT en modalidad de subida del firmware. Usar un clip para presionar y sostener el botón oculto abajo del bloque. El NXT tocará un sonido suave y pulsante que indica que está listo.

    Escribir:
    lejosfirmdl
    En la linea de comandos DOS.

    Lejos necesita Libusb para comunicarse con el NXT. Si no se ha instalado este software gratuito en la computadora, se iniciará el instalador del mismo. Libusb permite a los programas acceder a cualquier dispositivo USB de forma genérica. Hay que asegurarse de que no se ejecute la aplicación de prueba mencionada al final. En caso de que Lejos ya esté instalado en el NXT aún será necesario instalar LibUSB para ser capaz de bajar los programas. Se puede encontrar en “lejos_nxj\3rdparty\lib\libusb-win32-filter-bin-0.1.12.1.exe”. El nombre puede cambiar cuando una nueva versión de libusb esté disponible.

    Una vez que Libusb está instalado el instalador de Lejos continuará hasta terminar exitosamente, viéndose de la siguiente manera:

    Ahora se reiniciará el NXT y luego mostrará el logo de Lejos antes de cambiar al menú principal.

    Ahora el NXT está listo para corer programas Java.

    4. Instalar y configurar Eclipse en la computadora

    Bajar Eclipse IDE para desarrolladores Java. Eclips está escrito en Java y no contiene un instalador, viene en un ZIP sencillo que habrá que extraer en nuestro foler “ProgramFiles”. Se puede crear un acceso directo para conveniencia de “eclipse.exe” en el escritorio o donde sea necesario.


    Al iniciar Eclipse se solicitará escoger un espacio de trabajo. El espacio de trabajo contendrá todos los archives que se creen. De nuevo, se debería crear un directorio en una ubicación que no contenga espacios en blanco “ “. Usaremos un directorio “d:\programming\workspace”. Luego se da la pantalla de bienvenida de Eclipse.

    Ahora crearemos un programa “Hola Mundo” y lo subiremos (o bajaremos) al NXT. Primero se necesita crear un nuevo proyecto Java. Dar click en “File => New => Java Project”. Escribir un nombre para el proyecto, evitar siempre los caracteres en blanco. En este caso se llamará “LeJOS_NXJ”

    A continuación, se requiere convertir este proyecto en un proyecto Lejos. Dar click derecho en el proyecto y seleccionar “properties”. Seleccionar “Java Build Path” en la izquierda y dar click en la pestaña “libraries”. Luego, dar click en “Add External JARs…” y encontrar el directorio “lib”en la carpeta “ProgramFiles\lejos_nxj”. Seleccionar “clases.jar” y presionar “Open”. Ahora la librería Lejos aparecerá en el listado.

    En propiedades, nos movemos a la sección “Java Compiler” que está a la izquierda. Seleccionamos la opción “Enable prject specific settings”y escoger nivel 1.3 para el nivel de compatibilidad del compilador. Esta hará que el compilador optimice para una versión anterior de Java. Esta versión anterior es más compatible con el NXT ya que ha sido diseñada para sistemas enbebidos. Requiere mucho menos recursos que la última versión de Java. Dar click en “Apply” luego en “OK” para dejar las propiedades.

    El siguiente paso es configurar Eclipse para bajar el software al NXT. Dar clic en “Run => External Tools => Open External Tools Dialog…”.

    Seleccionar “program” en la izquierda y luego dar click en “New”. Nombrar la herramienta “lejos Download” arrba. En la pestaña principal, ingresar la ubicación del archivo “lejosd1.bat” que tendría que estar en la carpeta “lejos-nxj\bin\” que se puede ubicar dando click en “Browse File System”. Entrar a:
    ${project_loc}\bin
    En el “Working directory” e ingresar
    ${java_type_name}
    En la sección de argumentos.

    Ahora crearemos un acceso directo para bajar el programa al NXT. Dar click en el icono “run” en la barra de herramientas y seleccionar “Organize Favorites…” Dar click en “Add…” en la ventana que aparece y luego seleccionar la opción de “lejos Download”, que es la herramienta externa que hemos configurado anteriormente. Presionar “OK”y luego “Ok” de nuevo.

    5. Escribir, bajar y ejecutar un programa “Hola mundo”


    Primero, creamos la clase principal para nuestro programa. Dar click en “New=>Class”. Nombrarla “HelloWorld” y seleccionar “public static void(String[] args)”. Luego recibira una clase casí vacia. Eclipse es un editor de Java muy inteligente que intent compilar el programa a medida que se escribe. Similar a lo que ocurre en Word, subraya errores con una línea roja. En ocaciones esta compilación automática no funciona y se necesita forzar a que Eclipse compile. Esto se puede lograr simplemente guardando el archivo.

    Ahora se ingresarán algunas lineas de codigo java. En la primera línea escribir:
    import lejos.nxt.LCD;
    Esta linea permitirá que el programa use el display LCD del NXT. Luego, necesitamos definir que se mostrará y cuando. Agregar estas líneas al método principal:
    LCD.drawString(”Hola mundo!”, 2, 2);
    LCD.refresh();
    while(true) {}
    Ahora se puede bajar el programa al NXT. En la siguiente pantalla se pueden ver estos pasos. Antes de empezar con el proceso de bajado hay que asegurarse de que el NXT este conectado a la computadora y de que el NXT ha sido reconocido por el sistema operativo, de nuevo, esto se puede comprobar en el administrador de dispositivos. Tambien hay que seleccionar la clase principal al centro antes de empezar a bajar, para que Eclipse sepa que clase es la que se quiere bajar. Usar el menú desplegable (4 en la pantalla) para seleccionar el favorito de bajada que antes creamos. Esto iniciará el proceso de bajado al NXT.

    Luego de que la descarga ha sido completada se puede iniciar el program usando los botones en el NXT. Notar que el programa correrá para siempre. Para detenerlo se necesita resetear el NXT presionando los dos botones del centro por un tiempo más largo. Esto finalizará la conexión USB así que habrá que esperar un poco para reconectarse antes de bajar un nuevo programa. Claro que hay mejores maneras de terminar el programa, como escuchar por un botón o luego de algún tiempo, se puede reemplazar el while sin fin por esto:
    try {
    Thread.sleep(5000);
    } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    }
    Esto hará que el NXT duerma 5 segundos antes de que el programa termine. Ahora verá “Hola Mundo!” por cinco segundos y luego el programa termina. Para mas información de cómo programar en Java para el NXT se puede visitar el sitio leJOS.
    -------------------------------------------------------------------------------------------
    REFERENCIAS:
    - Este tutorial está sacado de aquí