Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Gustavo Zazo
NDICE
1
INTRODUCCIN....................................................................................................4
2.1
CDIGO ......................................................................................................4
2.2
SIGNOS DE PUNTUACIN..................................................................................4
2.3
2.4
INSTRUCCIONES ............................................................................................5
2.5
COMENTARIOS ..............................................................................................5
2.6
2.7
TAREAS ......................................................................................................7
3.2
FUNCIONES ..................................................................................................7
VARIABLES...................................................................................................9
4.2
CONSTANTES.............................................................................................. 10
ASIGNACIN............................................................................................... 11
5.2
repeat .................................................................................................. 12
6.1.2
while.................................................................................................... 12
6.1.3
do while .............................................................................................. 13
6.1.4
for ....................................................................................................... 13
6.2
BUCLES..................................................................................................... 12
INSTRUCCIONES DE CONDICIN........................................................................ 14
6.2.1
if - else ................................................................................................. 14
6.2.2
switch .................................................................................................. 15
goto ........................................................................................................ 16
7.2
return ...................................................................................................... 16
7.3
break ....................................................................................................... 16
7.4
continue ................................................................................................... 16
OPERADORES .................................................................................................... 16
8.1
8.2
8.2.1
8.2.2
8.2.3
8.2.4
8.2.5
8.2.6
8.2.7
8.2.8
8.2.9
8.2.10
Resumen ............................................................................................ 18
8.3
8.4
9.2
10
11
SONIDOS ...................................................................................................... 23
12
13
COMUNICACIONES ........................................................................................... 25
13.1
RCX ......................................................................................................... 25
13.2
NXT ......................................................................................................... 26
14
14.1
RCX ......................................................................................................... 26
14.2
NXT ......................................................................................................... 27
14.2.1
14.2.2
14.2.3
15
15.1
RCX ......................................................................................................... 30
15.2
NXT ......................................................................................................... 30
16
17
REFERENCIAS ................................................................................................. 32
1 INTRODUCCIN
RobotC es un potente lenguaje textual de programacin basado en el lenguaje C con un entorno
Windows para escribir y depurar programas, y que ofrece un depurador completo en tiempo real. RobotC
es una solucin para varias plataformas, en especial para NXT y RCX de LEGO, que permite a los
estudiantes el aprendizaje del tipo de programacin basado en C para aplicaciones educativas y
profesionales.
RobotC ha sido desarrollado por la Robotics Academy de la Carnegie Mellon University de Pittsburg
(Pensilvania, EUA).
La presente GUA DEL PROGRAMADOR (nivel bsico) no es, ni mucho menos, una exhaustiva
descripcin ni del lenguaje C, ni del propio RobotC, sino un documento al que los estudiantes puedan
acudir si les surgen dudas acerca de programacin sencilla de sus robots en RobotC.
2 REGLAS LXICAS
2.1
CDIGO
Las rdenes al robot se escriben como texto en la pantalla del ordenador, se procesan por el
compilador de RobotC para obtener un archivo en lenguaje mquina y despus se cargan en el
robot, en el que se pueden ejecutar. El texto que se escribe como parte de un programa se llama
cdigo.
El cdigo de un programa en RobotC consiste en una serie de piezas (tokens) ordenadas
secuencialmente.
Cada pieza est integrada por letras, nmeros, signos de puntuacin o smbolos matemticos.
Grficamente se puede expresar como sigue:
Cdigo en RobotC
motor[motorC] = 100;
motor [ motorC ]
m
m
100
El lenguaje C (y, por tanto, RobotC, que es un derivado suyo) diferencia entre maysculas y
minsculas, por lo que hay que prestar atencin cuando se escribe un programa. As, por
ejemplo, wait se reconoce como una pieza del lenguaje, pero Wait no se reconoce como tal.
2.2
SIGNOS DE PUNTUACIN
Se emplean varios signos de puntuacin para diferentes cometidos:
;
Fin de instruccin
2.3
ESPACIOS EN BLANCO
El espacio en blanco (espacios, tabuladores y saltos de lnea) se usa para separar piezas y para
hacer los programas ms legibles. Con tal de que se distingan las piezas, no tiene efecto en el
programa aadir o suprimir espacios en blanco. Por ejemplo, las siguientes lneas de cdigo
tienen el mismo significado:
x=2;
x = 2 ;
Algunos de los operadores de C++ estn formados por mltiples caracteres. Para preservar estas
piezas no se debe insertar espacio en blanco entre ellos. En el ejemplo siguiente, la primera
lnea usa un operador de cambio a la derecha (>>), pero en la segunda lnea el espacio
aadido hace que los smbolos > se interpreten como dos elementos separados y en
consecuencia se genere un error.
x = 1 >> 4;
x = 1 > > 4;
// error
El uso de espacios, tabulaciones y lneas ayuda al programador a leer el cdigo con mayor
facilidad. Es muy recomendable hacer un buen uso de los espacios en blanco en un programa.
2.4
INSTRUCCIONES
Una instruccin (orden, sentencia o declaracin) es una orden directa al robot. Por ejemplo, la
instruccin motor[motorC] = 100; indica al robot que ponga en marcha el motor conectado
al puerto C al 100 % de potencia.
Las instrucciones son ejecutadas de izquierda a derecha y de arriba abajo.
RobotC reconoce las diferentes instrucciones porque la gran mayora acaban en ; , pero no
porque estn en diferentes lneas. Los dos siguientes trozos de cdigo son exactamente iguales
para RobotC, pero el segundo es prcticamente ilegible para un programador humano.
task main()
{
motor[motorC] = 100;
wait1Msec(3000);
}
task main(){motor[motorC
]=100;wait1Msec(3000);}
2.5
COMENTARIOS
RobotC soporta dos tipos de comentarios. El primer tipo (comentarios C tradicionales) empieza
con /* y termina con */. Pueden abarcar varias lneas, pero no pueden anidarse.
/* esto es un comentario */
/* esto es un comentario
de dos lneas */
/* otro comentario
/* intentando anidar
finalizando el comentario interior */
este texto ya no es un comentario! */
RobotC. Gua del programador
La segunda clase de comentarios empieza con // y termina con una nueva lnea (conocidos a
veces como comentarios estilo C++).
2.6
COLOREADO DE CDIGO
RobotC colorea automticamente las palabras, smbolos y signos que reconoce como propios del
lenguaje :
task main()
{
motor[motorC] = 100;
wait1Msec(3000); // Esto es un comentario: Espera 3 s
}
2.7
break
else
repeat
task
case
false
return
true
const
for
start
void
continue
goto
stop
while
default
if
sub
do
int
switch
3 BLOQUES DE CDIGO
Un programa en RobotC se compone de bloques de cdigo y variables globales. Hay dos tipos de
bloques de cdigo: tareas y funciones en lnea. Cada tipo de bloque de cdigo tiene sus propias
caractersticas y restricciones particulares, pero todos comparten una estructura comn.
6
3.1
TAREAS
RobotC soporta implcitamente multitarea, de modo que una tarea en RobotC corresponde a una
tarea RCX o NXT.
El nmero mximo de tareas es 10.
Las tareas se definen por medio de la palabra reservada task utilizando la siguiente sintaxis:
task nombre()
{
// El cdigo de la tarea se escribe aqu (cuerpo)
}
El nombre de la tarea puede ser cualquier identificador legal. Un programa debe tener al menos
una tarea, que se llama main y que se inicia cada vez que se ejecuta el programa.
Funciones referentes a tareas:
3.2
StartTask(nombre_tarea);
StopTask(nombre_tarea);
StopAllTasks();
FUNCIONES
A menudo es til agrupar un conjunto de instrucciones en una sola funcin, que puede ser llamada
cuando sea necesario. RobotC soporta funciones con argumentos, pero no valores de retorno. Las
funciones se definen con la siguiente sintaxis:
void nombre(lista_de_argumentos)
{
// cuerpo de la funcin
}
La palabra reservada void es consecuencia de la herencia de RobotC (en C las funciones se
especifican con el tipo de datos que devuelven). Las funciones que no devuelven datos se
declaran con void (vaco). La devolucin de datos no est soportada por RobotC, de modo que
todas las funciones se declaran usando la palabra reservada void.
La lista de argumentos puede estar vaca o puede contener una o ms definiciones de
argumento. Un argumento se define por su tipo seguido de su nombre. Los argumentos mltiples
se separan por comas.
Para llamar a una funcin simplemente, donde se desee que se ejecute el cdigo, se escribe su
nombre seguido de parntesis (con o sin argumentos) y de punto y coma.
Las funciones RobotC siempre se expanden como funciones en lnea. Esto significa que cada
llamada a una funcin hace que se incluya en el programa otra copia del cdigo de la funcin. Si
no se usan con sensatez, las funciones en lnea hacen que el tamao del cdigo sea excesivo.
EJEMPLOS DE APLICACIN
1. En el siguiente ejemplo se define la funcin GiraDerecha, que luego es llamada desde la
tarea principal task main.
Se declara la funcin GiraDerecha (sin argumentos),
que hace girar a la derecha al robot al 60 % de potencia
void GiraDerecha()
{
motor[motorA] = 60;
motor[motorC] = -60;
}
task main ()
{
motor[motorA] = 100;
motor[motorC] = 100;
wait1Msec(1000);
GiraDerecha();
wait1Msec(500);
motor[motorA] = 100;
motor[motorC] = 100;
wait1Msec(3000);
}
task main ()
{
motor[motorA] = 100;
motor[motorC] = 100;
wait1Msec(1000);
GiraDerecha (500);
motor[motorA] = 100;
motor[motorC] = 100;
wait1Msec(3000);
}
4 VARIABLES Y CONSTANTES
4.1
VARIABLES
Una variable es un contenedor que puede almacenar un valor determinado: cantidades numricas,
cadenas alfanumricas o valores booleanos.
Los principales tipos de variables que soporta RobotC son los siguientes:
TIPO DE DATOS
DESCRIPCIN
EJEMPLOS
Entero
Decimal de coma
flotante
Cadena
Booleano
CDIGO
int
float
El contador ha llegado a 4
ALTO
string
Hora de comer!
true, false
bool
Las variables se declaran usando una de las palabras reservadas int, float, string o bool
seguida de una lista de nombres de variables separados por coma y terminados por un punto y
coma.
int x;
bool conectado;
Crea un variable
conectado
de
tipo
booleano
llamada
Si una variable necesita estar en posicin global, se declara como variable global.
Si una variable no necesita ser global, hacer que sea lo ms local posible.
Por ejemplo:
int x;
// x es global
void aaa ()
{
int z;
// z local declarada
task main()
{
int y;
x = y;
// ok
y = z;
task otra ()
{
x = 1;
// ok
y = 2;
// error - y no es global
4.2
CONSTANTES
Una constante es un contenedor que almacena un valor determinado pero, a diferencia de las
variables, dicho valor no puede ser modificado posteriormente en el programa.
Las constantes se declaran de la misma manera que las variables, pero anteponiendo la palabra
reservada const.
Es obligatorio adjudicarlas un valor en la instruccin de la declaracin.
10
Se rigen por las mismas reglas que las variables respecto a su utilizacin y mbito de aplicacin.
Ejemplos:
const float DECIMAL = 14.256;
const string NOMBRE = Jorge;
const int EDAD = 25;
NOTA: No es obligatorio, pero es una costumbre entre los programadores usar maysculas para los
nombres de constantes y minsculas para los nombres de variables.
5 INSTRUCCIONES GENERALES
5.1
ASIGNACIN
Una vez declaradas las variables se les puede asignar el valor de una expresin:
Variable operador_de_asignacin expresin;
Accin
+=
-=
*=
/=
Algunos ejemplos:
5.2
x = 2 ;
// asigna a x el valor 2
y = 7 ;
// asigna a y el valor 7
x += y ;
// x es 9. y sigue siendo 7
INSTRUCCIONES COMPUESTAS
La estructura de control ms sencilla es una instruccin compuesta. Esto es, una lista de
instrucciones encerradas entre llaves ({ y }).
11
{
x = 2 ;
y = 7 ;
}
Aunque puede no parecer muy significativo, juega un papel crucial al construir estructuras de
control ms complicadas. Muchas estructuras de control requieren una instruccin sencilla como cuerpo.
Usando una instruccin compuesta, la misma estructura de control se puede usar para controlar mltiples
instrucciones.
BUCLES
Los bucles nos ofrecen la solucin cuando queremos repetir una instruccin compuesta un nmero
determinado de veces.
6.1.1
repeat
repeat (nmero_de_repeticiones)
{
cuerpo
}
Ejemplo:
repeat (4)
{
motor[motorA] = 100;
motor[motorC] = 100;
wait1Msec(1000);
motor[motorA] = 60;
motor[motorC] = -60;
wait1Msec(500);
6.1.2
while
12
contina hasta que la condicin se vuelve falsa (o se ejecuta la instruccin break). A continuacin
aparece la sintaxis para el bucle while:
while (condicin)
{
cuerpo
}
Es normal utilizar una instruccin compuesta como cuerpo del bucle.
while (x < 10)
{
x = x+1;
y = y*2;
}
Si se usa true como condicin de while se establece un bucle infinito.
while (true)
{
// las instrucciones se repiten indefinidamente
}
6.1.3
do while
do
{
cuerpo
}
while (condicin)
En la instruccin while la condicin se comprueba antes de ejecutar el cuerpo, mientras que en
la instruccin do while la condicin se comprueba al final. Por tanto, en el bucle do - while
siempre ejecuta el cuerpo al menos una vez mientras que el bucle while puede no ejecutarse
nunca.
6.1.4
for
Ejemplo:
RobotC. Gua del programador
13
task main()
{
int i;
Como vemos, el for va delante del grupo de instrucciones a ejecutar, de manera que si la
condicin es falsa, esas instrucciones no se ejecutan ni una sola vez.
Se puede omitir cualquiera de las secciones (inicializacin, condiciones o incrementos). Tambin
se pueden poner ms de una variable a inicializar, ms de una condicin y ms de un
incremento.
6.2
INSTRUCCIONES DE CONDICIN
6.2.1
if - else
La instruccin if evala una condicin. Si la condicin es verdadera ejecuta una instruccin sencilla
o compuesta (la consecuencia). Una segunda instruccin opcional (la alternativa, else) se ejecuta si la
condicin es falsa. A continuacin se muestran las sintaxis posibles para una instruccin if o if else.
if (condicin) instruccin;
if (condicin)
instruccin;
if (condicin)
instruccin;
else
instruccin;
if (condicin)
{
cuerpo
}
if (condicin)
{
cuerpo
}
14
else
{
cuerpo
}
Obsrvese que la condicin va encerrada entre parntesis. Vanse los ejemplos a continuacin. En
el ltimo ejemplo se utiliza una instruccin compuesta para permitir que se ejecuten dos instrucciones
como consecuencia de la condicin.
if (x==1) y = 2;
if (x==1)
y = 3;
else
y = 4;
if (x==1)
{
y = 1;
z = 2;
}
6.2.2
switch
La instruccin switch sirve par elegir una opcin entre varias disponibles. No se evala una
condicin que se debe cumplir sino el valor de una variable. Dependiendo del valor se cumplir un caso u
otro. La sintaxis es:
switch (x)
{
case 1 :
// haz algo cuando x es 1
break;
case 2 :
case 3 :
// haz otra cosa cuando x es 2 3
break;
default :
// haz esto cuando x no es ni 1, ni 2 ni 3
}
Las palabras reservadas case y default no son instrucciones en s mismas sino que son
etiquetas que preceden a las instrucciones. Mltiples etiquetas pueden preceder a la misma
instruccin.
El cdigo con switch es ms cmodo de leer que con la instruccin if else. Sin embargo
switch tiene algunas limitaciones; por ejemplo, no se pueden usar condiciones en los case.
RobotC. Gua del programador
15
7 INSTRUCIONES DE SALTO
7.1
goto
La instruccin goto fuerza al programa a saltar a una posicin determinada. Las instrucciones de un
programa pueden ser marcadas precedindolas de un identificador y dos puntos, a lo que se llama
etiqueta. La instruccin goto especifica la etiqueta a la que el programa debe saltar.
goto nombre_de_etiqueta;
Por ejemplo:
// etiqueta
mi_bucle:
x++;
goto mi_bucle;
El goto slo se puede usar dentro de funciones, y no se puede saltar desde una funcin a otra.
La instruccin goto debe usarse con moderacin y precaucin. En la mayora de los casos las
estructuras de control tales como if, while y switch hacen los programas ms fciles de leer
y modificar.
7.2
return
Es posible hacer que una funcin finalice antes de llegar al final de su cdigo usando la instruccin
return.
return;
7.3
break
Dentro de los bucles (por ejemplo, en un bucle while) la instruccin break puede utilizarse para
salir del bucle. La instruccin break tambin puede utilizarse para salir de la instruccin switch.
break;
7.4
continue
La instruccin continue se puede utilizar para saltar a la parte superior de la siguiente iteracin
de un bucle.
continue;
8 OPERADORES
Un operador sirve para manipular datos. Los hay de varios tipos: de asignacin, de relacin, lgicos,
aritmticos y de manipulacin de bits.
8.1
OPERADOR DE ASIGNACIN ( = )
Sirve para dar un valor a una variable. Este valor puede ser un nmero que tecleamos directamente
u otra variable:
a = 3;
a = b;
16
a = b = c = 10;
Tambin podemos asignar a varias variables el valor de otra en solo una instruccin:
a = b = c = d;
8.2
OPERADORES ARITMTICOS
Los operadores aritmticos son aquellos que sirven para realizar operaciones tales como suma,
resta, divisin y multiplicacin. Otras operaciones aritmticas ms complejas estn fuera del nivel bsico
de esta gua.
8.2.1
// c es 5
8.2.2
// se incrementa en 5 el valor de x
8.2.3
// se incrementa en 5 el valor de x
Este operador equivale a sumar uno a la variable. Se puede poner antes o despus de la variable:
int x = 5;
x++;
// x es 6
++x;
// x es 7
8.2.4
Este operador tiene dos usos: uno es la resta, que funciona como el operador suma, y el otro es
cambiar de signo a la variable.
Resta:
x = x - 5;
// resta 5 a x
17
a = 3;
b = -a;
8.2.5
// b es -3
8.2.6
8.2.7
Este operador sirve para multiplicar y funciona de manera parecida a los anteriores.
8.2.8
Este operador funciona tambin como los anteriores pero hay que tener cuidado. Si dividimos dos
nmeros en coma flotante (tipo float) tenemos la divisin con sus correspondientes decimales. Pero si
dividimos dos enteros obtenemos un nmero entero. Es decir que si dividimos 4/3 tenemos como resultado
1. El redondeo se hace por truncamiento, simplemente se eliminan los decimales y se deja el entero.
Cuando dividimos dos enteros, si queremos saber cual es el resto (o mdulo) usamos el operador %,
que vemos ms abajo.
8.2.9
Si con el operador divisin (/) se obtiene el mdulo o cociente de una divisin entera, con ste se
puede obtener el resto. Slo funciona con enteros (int), no vale para nmeros float.
Ejemplo:
int a, b;
float c;
a = 18;
b = 5;
c = a % b ;
// c es 3
8.2.10 Resumen
OPERADOR
OPERADOR
NOMBRE
Suma
Multiplicacin
+=
Incremento
Divisin
++
Incremento en 1
Resto
18
NOMBRE
Resta
-=
Decremento
--
Decremento en 1
8.3
OPERADORES DE CONDICIN
Los operadores de condicin se utilizan para comprobar las condiciones de las instrucciones de
control de flujo.
Cuando se evala una condicin el resultado que se obtiene es 0 si no se cumple la condicin y
un nmero distinto de 0 si se cumple(los nmeros negativos se consideran como verdadero).
Normalmente cuando se cumple la condicin devuelve un 1.
Los operadores de comparacin son:
OPERADOR
SIGNIFICADO
DESCRIPCIN
==
igual que
!=
distinto a
>
mayor que
<
menor que
>=
<=
true
Siempre verdadero
Siempre falso
false
8.4
if ( a > b)
while ( a<= b)
while (true)
if (a != b)
Se cumple si a es distinto de b
OPERADORES LGICOS
Estos operadores permiten unir varias comparaciones. Son los siguientes:
OPERADOR
OPERACIN LGICA
SIGNIFICADO
&&
Y (AND)
||
O (OR)
NEGACIN (NOT)
Se cumple si a es 3 Y b es dos
19
Ejemplos de || (OR):
if ( a<100 || b>200 )
if ( a<10 || a>100 )
9 MOTORES (Salidas)
Tanto RCX como NXT tienen 3 salidas (A, B y C) a las que se pueden conectar motores o bombillas.
Con la excepcin de algunas aplicaciones concretas, generalmente se conectan motores.
9.1
CONTROL BSICO
RobotC incorpora una funcin para el control de los motores:
motor[puerto_motor] = potencia;
puerto_motor se sustituye por cualquiera de las tres salidas: motorA, motorB o motorC.
potencia especifica la velocidad (potencia) del motor. El rango de potencia es de -100 a 100.
Ejemplos:
20
motor[motorA] = 100;
motor[motorC] = -60;
motor[motorC] = 0;
9.2
nMotorPIDSpeedCtrl[puerto_motor] = mtrSpeedReg;
nSyncedMotors = synchesclavo_maestro;
nSyncedTurnRatio = %_relacin;
50 es la mitad
-100 es la misma velocidad pero con el
sentido de giro opuesto
Ejemplo 1:
task main()
{
nMotorPIDSpeedCtrl[motorA] = mtrSpeedReg;
motor[motorA] = 60;
}
Ejemplo 2:
task main()
{
nMotorPIDSpeedCtrl[motorA] = mtrSpeedReg;
nSyncedMotors = synchAB;
nSyncedTurnRatio = 100;
motor[motorA] = 50;
}
10 SENSORES (Entradas)
El NXT tiene cuatro puertos de entrada (el RCX tres) a los que se pueden conectar diferentes
sensores. Hay numerosas funciones y variables para configurar estos puertos y acceder a sus lecturas.
21
Como la configuracin de sensores puede ser una tarea algo complicada, RobotC incorpora un
asistente que facilita la configuracin. El asistente contiene una serie de ventanas en las que se pueden
introducir los siguientes campos:
1. El nombre de la constante que se le quiere asignar al sensor (el nombre del sensor). Pueden
usarse los valores numricos del puerto (S1, S2, S3 o S4), pero es una buena prctica de
programacin asignar a los sensores un nombre que tenga sentido como sensorLuz,
bumperIzquierdo o sonar.
2. El tipo de sensor: touch, light, sound, sonar, etc. El firmware debe conocer el tipo de sensor
de tal manera que pueda configurarlo correctamente.
3. El modo del sensor. El modo ms comn es percentage (porcentaje), que normalizar el valor
del sensor a una lectura entre 0 y 100. El siguiente ms comn es raw (valores en bruto), que
simplemente devuelve el valor sin normalizar del sensor (de 0 a 1024). El modo del sensor se
configura automticamente al elegir el tipo de sensor.
Tipos de sensores y valores devueltos:
TIPO DE SENSOR
Raw value
Valor en bruto
Touch
Toque
Temperature (legacy)
Temperatura (antiguo)
Reflection (legacy)
Reflexin (luz antiguo)
Rotation (legacy)
Rotacin (antiguo)
Light active
PLATAFORMA
VALORES DEVUELTOS
RCX y NXT
0 a 1024 (raw)
RCX y NXT
0 o 1 (booleano)
RCX
C o F
RCX
0 a 100 ( % )
RCX
0 a 16
(360 = 16, 90 = 4, )
NXT
0 a 100 ( % )
NXT
0 a 100 ( % )
NXT
0 a 100 ( % )
Sound DBA
NXT
0 a 100 ( % )
Sonar 9V
NXT
cm al obstculo
NXT
360 = 1 vuelta
Custom (sensores no
fabricados por LEGO)
RCX y NXT
Segn el sensor
Luz activo
Light inactive
Luz inactivo
Sound DB
Sonido dB
Usando el asistente para configuracin de sensores y motores (Motors and Sensors Setup),
RobotC genera automticamente el cdigo necesario y lo incluye al principio del programa:
22
Ejemplo 1:
const tSensors bumper
= (tSensors) S1;
//sensorTouch
Ejemplo 2:
const tSensors ojo
= (tSensors) S2;
//sensorLightActive
SensorMode[nombre_sensor]
SensorValue[nombre_sensor]
SensorRaw[nombre_sensor]
(*) Los motores NXT incorporan un encoder (sensor que detecta el movimiento de rotacin de un
eje). El encoder mide grados sexagesimales, de manera que devuelve un valor de 360 por cada
giro del motor. Esto permite posicionar con mucha precisin determinados movimientos. Existe
una funcin que permite leer y escribir el valor del encoder de un determinado motor:
nMotorEncoder[puerto_motor]=valor;
Ejemplos:
while (nMotorEncoder[motorA] < 720)
nMotorEncoder[motorA] = 0;
Pone el encoder a 0
11 SONIDOS
RobotC suministra una coleccin de funciones de control del altavoz del NXT y el RCX. Las
principales son las siguientes:
RCX y NXT
PlaySound(sonido);
23
RCX y NXT
Reproduce un tono de la frecuencia (en
HZ) y duracin (en dcimas de s)
especificadas.
PlayTone(frecuencia, duracin);
RCX y NXT
ClearSounds();
PlaySoundFile(nombre_archivo);
El firmware de RobotC pone en la cola (en el buffer) hasta 10 sonidos para ser reproducidos. Esto
permite al programa iniciar la reproduccin de un sonido y continuar la ejecucin de otras instrucciones
sin tener que esperar a que acabe el sonido para continuar la ejecucin del programa. Este modo de
reproduccin es muy til en robots en los que si se espera a la completa reproduccin del sonido se
pueden tener retrasos en la reaccin de los motores ante la lectura de los sensores.
Sonidos predefinidos:
sounBeepBeep
soundFastUpwardTones
soundShortBlip
soundBlip
soundLast
soundUpwardTones
soundDownwardTones
soundLowBuzz
soundException
soundLowBuzzShort
Ejemplos de aplicacin:
PlaySound(soundBeepBeep);
PlayTone(440, 10);
PlaySoundFile(hola.rso);
Los archivos de sonido en el NXT tienen un formato especial con extensin rso y pueden ocupar un
mximo de 64 kb. Existen utilidades para transformar archivos con formato wav en archivos rso (ver el
apartado Referencias). Una vez transformado el archivo a formato wav, se debe copiar al NXT mediante la
utilidad File Management de RobotC.
12 CONTROL DE TIEMPO
El firmware del RCX y del NXT maneja un reloj interno de 32 bits. Cuenta en unidades de 1
milisegundo. Cuatro cronmetros (T1, T2, T3 y T4) estn integrados y usan esta caracterstica.
Funciones y variables para control de tiempo:
wait1Msec(milisegundos);
24
wait10Msec(centsimas_de_segundo);
time1[cronmetro]
time10[cronmetro]
time100[cronmetro]
ClearTimer(cronmetro);
Ejemplos:
motor[motorC] = 100;
wait1Msec(1000);
wait10Msec(1000);
if (time1[T1] = 3000)
ClearTimer(T3);
13 COMUNICACIONES
13.1 RCX
El RCX puede enviar y recibir mensajes simples utilizando los infrarrojos para comunicarse con otro
RCX. Un mensaje puede tener un valor desde 1 hasta 255. El ltimo mensaje recibido es guardado y puede
accederse a l mediante la variable message(). Si no ha sido recibido ningn mensaje,
message()devolver el valor 0. Debe tenerse en cuenta que, debido a la naturaleza de la comunicacin
mediante infrarrojos, no se podrn recibir mensajes mientras un mensaje se est transmitiendo.
Funciones y variables:
sendMessage(ID_mensaje);
ClearMessage();
message()
Ejemplos:
sendMessage(1);
RobotC. Gua del programador
while (message == 0)
13.2 NXT
El sistema NXT tiene una potente capacidad de comunicacin entre dos NXT mediante el uso del
sistema inalmbrico Bluetooth que incorporan los NXT. Bluetooth es un protocolo de comunicacin
inalmbrica a corta distancia que opera en la frecuencia de radio de 2.4 GHz. El alcance mximo del
protocolo Bluetooth que incorpora el NXT es de 10 m.
Para lograr que se comuniquen dos NXT es necesario configurarlos previamente mediante la sencilla
utilidad que incluyen los propios ladrillos NXT.
Las funciones y variables que permiten la comunicacin bsica entre dos NXT son las siguientes:
Enva un nico mensaje de 16 bits.
sendMessageNew(ID_mensaje);
sendMessageWithParm(nmero_mensaje,
nParm1, nParm2);
message()
messageParm()
Matriz que
adicionales.
ClearMessage();
contiene
los
valores
optativos
No se deben enviar mensajes con una separacin menor de 30 milisegundos, pues podran perderse.
14 PANTALLA LCD
14.1 RCX
El RCX tiene una pantalla de una lnea en el que se pueden mostrar diferentes valores numricos.
SetUserDisplay(valor ,precisin);
26
TPrecision0
TPrecision1
TPrecision2
TPrecision3
Ejemplos:
SetUserDisplay(SensorValue(luz),TPrecision0);
SetUserDisplay(T1, TPrecision1);
SetUserDisplay(x,TPrecision3);
14.2 NXT
El NXT est equipado con una pantalla monocroma LCD de 100 pxeles de ancho por 64 pxeles de
alto. La esquina inferior izquierda es el punto (0,0) y la esquina superior derecha es el punto (99, 63).
RobotC tiene un completo conjunto de funciones para mostrar texto y diferentes formas
geomtricas en la pantalla LCD.
Ejemplos:
Si se escribe este cdigo
aparece en la
pantalla:
nxtDisplayString(0,"Hola mundo");
Hola mundo
27
El valor es
8
Sensor es
038
8 4.60
nxtDisplayClearTextLine(nmero_lnea);
Borra la lnea especificada en nmero_lnea.
eraseDisplay();
Borra el contenido de la pantalla.
28
[ancho]
[.precisin]
tipo
Ejemplos:
ENTEROS
Ejemplo int x = 7;
%d
%6d
%06d
Igual que el anterior pero se rellena con ceros el espacio hasta completar los
6 caracteres.
000007
%+6d
+00007
%f
12.340000
%5.3f
12.340
nxtClearPixel(x, y);
nxtDrawRect(Izda,Arriba,Derecha,Abajo);
nxtFillRect(Izda,Arriba,Derecha,Abajo);
nxtEraseRect(Izda,Arriba,Derecha,Abajo);
29
nxtDrawEllipse(Izda,Arriba,Derecha,Abajo);
nxtFillEllipse(Izda,Arriba,Derecha,Abajo);
nxtEraseEllipse(Izda,Arriba,Derecha,Abajo);
nxtDisplayIconFile(x, y, nombre_archivo)
15.1 RCX
CreateDatalog(tamao);
AddToDatalog(x);
UploadDatalog(comienzo, contador);
15.2 NXT
Los datos se almacenan en la RAM. Despus pueden ser copiados en un archivo flash del NXT. No se
almacenan en tiempo real en el archivo flash porque se invertiran entre 3 y 6 milisegundos en la
operacin, lo que podra perturbar la ejecucin del programa.
Hay utilidades en la interfaz de RobotC para importar el registro y mostrarlo en una ventana del PC.
Se encuentran en debug display y en NXT -> Files Management.
30
CreateDatalog(tamao);
AddToDatalog(x);
UploadDatalog(comienzo, contador);
SaveNxtDatalog();
31
17 REFERENCIAS
Ayuda de RobotC.
Tutorial de RobotC.
http://www.RobotC.net/
Baum, Dave. Gua del programador de NQC.
http://www.elo.utfsm.cl/~mindstorm/documentos/manuales/NQC_Programmer_s_Guide_2.5Dave_Baum%5BES%5D.pdf
Overmars, Mark. Programacin de robots Lego usando NQC.
http://people.cs.uu.nl/markov/lego/tutorial.pdf
http://www.brickshelf.com/gallery/inaki/Doks/Castellano/nqcovsp.pdf
Schueller, Albert W.. Programming with Robots
carrot.whitman.edu/Robots/notes.pdf
Conversor de formato wav a rso.
http://mikrobot.blogspot.com/2008/10/sofware-for-convert-wav-to-rso-nxt.html
Urrutia, Gorka. Curso de C.
http://www.elrincondelc.com/cursoc/cursoc.html
32