PDF de programación - Tutorial de NXC para programar robots Lego Mindstorms NXT

TUTORIAL DE NXC PAR A

PROGRAMAR

ROBOTS LEGO MINDSTORMS NXT



por Daniele Benedettelli

con la revisión de John Hansen
y traducido al castellano y adaptado por Víctor Gallego

Índice

I.Escribiendo tu primer programa



II. Un programa más interesante

III. Usando variables

IV. Estructuras de control

V. Sensores

VI. Tareas y subrutinas

VII. Más sobre motores

VIII. Más sobre sensores

IX. Tareas en paralelo

X. Más comandos



2

6

8

10

12

16

20

22

25

27



1

I. Escribiendo tu primer programa

En este capítulo escribiremos un programa sencillo. Programaremos un robot para que se mueva hacia
delante durante 4 segundos, luego hacia atrás durante otros 4 segundos y finalmente se detenga. Pero
primero construyamos el robot.

Construyendo un robot

El robot que usaremos es Tribot, cuyas instrucciones vienen con el kit del NXT de Lego. La única
diferencia es que conectaremos el motor derecho al puerto A, el izquierdo al C y la pinza al B.
Además debes asegurarte de haber instalado los drivers del NXT en tu ordenador.



Iniciando el Bricx Command Center

Escribimos los programas usando el interfaz del Bricx Command Center. Una vez que lo ejecutes,
conecta el NXT al ordenador a través de un cable USB. El programa intentará encontrar el robot.
Conéctalo y pulsa OK. Normalmente el programa detectará al NXT. A continuación el interfaz gráfico se
mostrará como en la figura siguiente:



2





La interfaz es semejante a un editor de texto estándar, con los botones de menú habituales. Pero también
aparecen menús especiales para compilar el programa, descargarlo al robot y para obtener información
del mismo.
Como vamos a comenzar un programa nuevo, pulsa sobre New File y aparecerá una nueva ventana
vacía.

Escribiendo el programa

Ahora corta y pega el siguiente programa:


task main()
{
OnFwd(OUT_A, 75);
OnFwd(OUT_C, 75);
Wait(4000);
OnRev(OUT_AC, 75);
Wait(4000);
Off(OUT_AC);
}


Los programas en NXC consisten en tareas (task). Nuestro programa sólo consta de una, llamada main.
Cada programa necesita tener al menos una tarea llamada main, que es la que ejecutará el robot.
Cada tarea consta de un conjunto de comandos llamados sentencias o instrucciones. Estas se encuentran
encerradas entre llaves. Cada sentencia termina con un punto y coma. De esta forma se aprecia
claramente dónde termina una sentencia y dónde empieza la siguiente. Así que una tarea tiene la siguiente
estructura:


task main()
{
sentencia1;
sentencia2;

}


Nuestro programa tiene seis sentencias:



3



OnFwd(OUT_A, 75);

OnFwd(OUT_C, 75);

Esta sentencia le dice al robot que debe conectar el motor de la salida A para que se mueva hacia adelante
a una velocidad del 75% de la velocidad máxima.

Igual que antes, pero ahora conectamos el motor C, de modo que ahora los dos motores avanzan y el
robot se mueve hacia adelante.

Esta sentencia le dice al robot que espere 4 segundos. El argumento, es decir, el número entre paréntesis,
se expresa en 1/1000 de segundo, de forma que podemos definir con gran precisión cuánto debe esperar.
Durante 4 segundos el programa espera y con ello el robot sigue avanzando.


Wait(4000);

OnRev(OUT_AC, 75);

El robot ya se ha alejado lo suficiente, por lo que ya le podemos dar la orden de volver, cambiando su
dirección de avance, es decir, retrocediendo. Podemos asignar como argumento a ambos motores a la vez
escribiendo OUT_AC .

Wait(4000);

De nuevo espera 4 segundos.


Off(OUT_AC);

Con ello detenemos los motores.
Y este es el programa completo. El robot avanza durante 4 segundos y luego retrocede el mismo tiempo,
deteniéndose al final.
Seguramente apreciaste los colores de las instrucciones cuando tecleábamos el programa. Aparecen
automáticamente y nos ayudan a controlar la correcta sintaxis del mismo.

Ejecutando el programa

Una vez escrito el programa, debe ser compilado, es decir convertido en el código máquina del NXT de
modo que éste pueda entenderlo y ejecutarlo, y descargado (downloading) al robot mediante el cable USB
o vía Bluetooth.



Aquí podemos ver los iconos que se ocupan de compilar, descargar, ejecutar y detener el programa. Si
pulsamos el segundo botón, y suponiendo que no hemos cometido errores al teclear el código, se
compilará y descargará. Si cometimos errores, éstos son enumerados para que los depuremos.
Ahora lo podemos ejecutar en el NXT. En el menú del ladrillo vamos a My Files, Software files, y
ejecutamos 1_simple (si este es el nombre con el que lo guardamos previamente).
También podemos usar el atajo CTRL+F5 o después de haberlo descargado pulsar el icono run verde.
¿Se comporta el robot como esperábamos?. Si no es así, revisa el programa y las conexiones de los
motores.

Errores en los programas

Cuando tecleamos los programas es muy probable que cometamos errores. El compilador los localiza e
informa de su posición en la parte inferior de la ventana, como en el ejemplo siguiente:



4





Automáticamente ha seleccionado el primer error (equivocamos el nombre del motor). Cuando hay varios
errores, podemos ir a cada uno de ellos pulsando sobre cada mensaje de error. A veces errores al principio
de un programa conllevan errores más adelante. Por ello es conveniente compilar de nuevo tras corregir
un error. Observa también como el sistema de resaltar comandos con colores evita muchos errores. Por
ejemplo, en la última línea tecleamos Of en lugar de Off. Como es un comando desconocido, no
apareció resaltado.
También hay errores no detectables por el compilador. Si hubiésemos tecleado OUT_B se habría activado
el motor equivocado. Si el robot muestra un comportamiento inesperado, seguramente habrá algo mal en
el programa.

Cambiando la velocidad

Como habrás notado, el robot se mueve bastante deprisa. Para cambiar la velocidad sólo debes modificar
el segundo parámetro de la lista de argumentos, dentro de los paréntesis. La potencia se ajusta entre 0
(apagado) y 100 (máxima). En esta nueva versión del programa, el robot se mueve más despacio:


task main()
{
OnFwd(OUT_AC, 30);
Wait(4000);
OnRev(OUT_AC, 30);
Wait(4000);
Off(OUT_AC);
}



5

II. Un programa más interesante

Nuestro primer programa no era muy impresionante. Hagámoslo más interesante introduciendo una serie
de nuevas características de nuestro lenguaje de programación NXC.

Haciendo giros

Puedes hacer girar tu robot parando o invirtiendo la dirección de giro de uno de los dos motores. Aquí
tienes un ejemplo. Debería avanzar un poco y luego girar un ángulo de 90º hacia la derecha. Tecléalo y
descárgalo en tu robot:

task main()
{
OnFwd(OUT_AC, 75);
Wait(800);
OnRev(OUT_C, 75);
Wait(360);
Off(OUT_AC);
}


Deberás probar con números ligeramente distintos a 500 en el segundo Wait() para conseguir los 90º de
giro ya que la superficie sobre la que se mueve tiene una gran influencia. En lugar de cambiar este valor
cada vez que aparece en el programa, es mejor usar un nombre para él. En NXC puedes definir constantes
como se muestra a continuación:



Las dos primeras líneas definen constantes que pueden utilizarse a lo largo del programa. Definir
constantes mejora la legibilidad del programa y permite cambiar rápidamente sus valores. Veremos en el
capítulo VI que podemos hacer definiciones de otras cosas.

Repitiendo comandos

Escribamos un programa que haga que el robot describa un cuadrado durante su movimiento. Ello
conlleva que el robot avance, gire 90º, vuelva a avanzar, a girar 90º, . Podríamos repetir el código
anterior cuatro veces, pero existe una forma más sencilla, usando la instrucción repeat:


#define TIEMPO_MOVIMIENTO 1000
#define TIEMPO_GIRO 360
task main()
{
OnFwd(OUT_AC, 75);
Wait(TIEMPO_MOVIMIENTO);
OnRev(OUT_C, 75);
Wait(TIEMPO_GIRO);
Off(OUT_AC);
}

#define TIEMPO_MOVIMIENTO 500
#define TIEMPO_GIRO 500
task main()
{ repeat(4)
{
OnFwd(OUT_AC, 75);
Wait(TIEMPO_MOVIMIENTO);
OnRev(OUT_C, 75);
Wait(TIEMPO_GIRO);
}
Off(OUT_AC);
}


El número dentro de los paréntesis que siguen a repeat indica el número de veces que el código entre
llaves se debe repetir.



6

Como un ejemplo final, hagamos que el robot se desplace describiendo 10 cuadrados en su movimiento:


#define TIEMPO_MOVIMIENTO 1000
#define TIEMPO_GIRO 500
task main()
{
repeat(10)
{ repeat(4)
{
OnFwd(OUT_AC, 75);
Wait(TIEMPO_MOVIMIENTO);
OnRev(OUT_C, 75);
Wait(TIEMPO_GIRO);
}
}
Off(OUT_AC);
}


Ahora tenemos una instrucción repeat dentro de otra. Se dice que están anidadas. Se pueden anidar tantas
instrucciones repeat como se quiera. Observa con cuidado como se ha usado la tabulación de las
instrucciones para hacer el programa más legible, y cómo la primera llave se complementa con la última,
la segunda con la penúltima y así. Como vemos, las llaves siempre aparecen a pares.

Añadiendo comentarios

Para hacer un programa más legible, podemos incluir comentarios. Siempre que escribamos // en una
línea, el resto de la misma será ignorado por el compilador y podrá usarse para introducir comentarios. Si
necesitamos más espacio, podemos empezar por /* y finalizar con */. Los comentarios son marcados
con otro tipo de letra por el editor del BricxCC. El programa comentado podría quedar así:


/* 10 CUADRADOS
Este programa hace que el robot se mueva 10 cuadrado