Robotcguia 120828131403 Phpapp01 PDF

GUA DEL PROGRAMADOR
Para RCX y NXT
NIVEL BSICO
Gustavo Zazo
NDICE
1 INTRODUCCIN....................................................................................................4
2 REGLAS LXICAS ..................................................................................................4
2.1 CDIGO ......................................................................................................4
2.2 SIGNOS DE PUNTUACIN..................................................................................4
2.3 ESPACIOS EN BLANCO .....................................................................................4
2.4 INSTRUCCIONES ............................................................................................5
2.5 COMENTARIOS ..............................................................................................5
2.6 COLOREADO DE CDIGO ..................................................................................6
2.7 IDENTIFICADORES Y PALABRAS RESERVADAS ..........................................................6
3 BLOQUES DE CDIGO ............................................................................................6
3.1 TAREAS ......................................................................................................7
3.2 FUNCIONES ..................................................................................................7
4 VARIABLES Y CONSTANTES ......................................................................................9
4.1 VARIABLES...................................................................................................9
4.2 CONSTANTES.............................................................................................. 10
5 INSTRUCCIONES GENERALES .................................................................................. 11
5.1 ASIGNACIN............................................................................................... 11
5.2 INSTRUCCIONES COMPUESTAS ......................................................................... 11
6 INSTRUCCIONES DE CONTROL DE FLUJO.................................................................... 12
6.1 BUCLES..................................................................................................... 12
6.1.1 repeat .................................................................................................. 12
6.1.2 while.................................................................................................... 12
6.1.3 do while .............................................................................................. 13
6.1.4 for ....................................................................................................... 13
6.2 INSTRUCCIONES DE CONDICIN........................................................................ 14
6.2.1 if - else ................................................................................................. 14
6.2.2 switch .................................................................................................. 15
7 INSTRUCIONES DE SALTO ...................................................................................... 16
7.1 goto ........................................................................................................ 16
7.2 return ...................................................................................................... 16
7.3 break ....................................................................................................... 16
7.4 continue ................................................................................................... 16
8 OPERADORES .................................................................................................... 16
8.1 OPERADOR DE ASIGNACIN ( = ) ...................................................................... 16
8.2 OPERADORES ARITMTICOS ............................................................................ 17
8.2.1 Operador (+) : Suma ................................................................................. 17
8.2.2 Operador (+=): Incremento ......................................................................... 17
8.2.3 Operador (++): Incremento en 1 ................................................................... 17
2 RobotC. Gua del programador

8.2.4 Operador (-) : Resta / Negativo ................................................................... 17
8.2.5 Operador (-=): Decremento......................................................................... 18
8.2.6 Operador (--): Decremento en 1 ................................................................... 18
8.2.7 Operador (*): Multiplicacin........................................................................ 18
8.2.8 Operador (/): Divisin ............................................................................... 18
8.2.9 Operador (%) : Resto ................................................................................. 18
8.2.10 Resumen ............................................................................................ 18
8.3 OPERADORES DE CONDICIN ........................................................................... 19
8.4 OPERADORES LGICOS .................................................................................. 19
9 MOTORES (Salidas) ............................................................................................. 20
9.1 CONTROL BSICO ........................................................................................ 20
9.2 CONTROL PID (NXT) ..................................................................................... 21
10 SENSORES (Entradas) ....................................................................................... 21
11 SONIDOS ...................................................................................................... 23
12 CONTROL DE TIEMPO ....................................................................................... 24
13 COMUNICACIONES ........................................................................................... 25
13.1 RCX ......................................................................................................... 25
13.2 NXT ......................................................................................................... 26
14 PANTALLA LCD ............................................................................................... 26
14.1 RCX ......................................................................................................... 26
14.2 NXT ......................................................................................................... 27
14.2.1 Funciones para texto ............................................................................. 27
14.2.2 Cdigos de formateo de texto en pantalla ................................................... 28
14.2.3 Funciones para formas geomtricas ........................................................... 29
15 REGISTRO DE DATOS (DATALOG) ......................................................................... 30
15.1 RCX ......................................................................................................... 30
15.2 NXT ......................................................................................................... 30
16 OTRAS FUNCIONES Y VARIABLES .......................................................................... 31
17 REFERENCIAS ................................................................................................. 32
RobotC. Gua del programador 3

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;
Descomposicin en piezas (tokens) motor [ motorC ] = 100 ;

m m
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
( ) [ ] Inicio y fin de parmetros
{} Inicio y fin de estructuras de control
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; //dar a x el valor de 1 desplazado a la derecha 4 bits
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! */

La segunda clase de comentarios empieza con // y termina con una nueva lnea (conocidos a
veces como comentarios estilo C++).
// un comentario de una lnea sencilla
El compilador ignora los comentarios. Su nico propsito es permitir al programador documentar

el cdigo fuente.
2.6 COLOREADO DE CDIGO

RobotC colorea automticamente las palabras, smbolos y signos que reconoce como propios del
lenguaje :
task main()
{
wait1Msec(3000); // Esto es un comentario: Espera 3 s
}
2.7 IDENTIFICADORES Y PALABRAS RESERVADAS

Se usan los identificadores para nombres de tarea, variables y funciones. El primer carcter de
un identificador debe ser una letra mayscula o minscula o el guin bajo (_). Los caracteres
restantes pueden ser letras, nmeros y el guin bajo. ( )
Se reserva un nmero potencial de identificadores para uso del propio lenguaje RobotC. Estas
palabras se denominan palabras reservadas y no se pueden usar como identificadores. Algunas
de ellas son las siguientes:
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.

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:
StartTask(nombre_tarea); Inicia o reinicia la ejecucin de la tarea especificada
StopTask(nombre_tarea); Detiene la ejecucin de la tarea especificada
Detiene la ejecucin de todas las tareas (y por tanto del

StopAllTasks();
programa en curso)
3.2 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), void GiraDerecha()

que hace girar a la derecha al robot al 60 % de potencia {
motor[motorA] = 60;
motor[motorC] = -60;
}
Se define la tarea principal task main ()

{
El robot avanza al 100 % de potencia durante 1 s motor[motorA] = 100;

wait1Msec(1000);
Se llama a la funcin GiraDerecha, y el robot gira GiraDerecha();

durante s wait1Msec(500);
Despus continua avanzando al 100 % de potencia motor[motorA] = 100;

durante 3 s
wait1Msec(3000);
}
2. En este otro ejemplo la funcin GiraDerecha se declara con el argumento tiempo.
Se declara la funcin GiraDerecha (con el argumento void GiraDerecha(int tiempo)

tiempo), que hace girar a la derecha al robot al 60 % {
de potencia durante un tiempo que se especificar
cuando se llame a la funcin. motor[motorA] = 60;
wait1Msec(tiempo);
}
Se define la tarea principal task main ()

{
El robot avanza al 100 % de potencia durante 1 s motor[motorA] = 100;

wait1Msec(1000);

Se llama a la funcin GiraDerecha, especificando un GiraDerecha (500);
tiempo de 500 y el robot gira durante s
Despus continua avanzando al 100 % de potencia motor[motorA] = 100;

durante 3 s
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 CDIGO
Nmeros enteros positivos y

Entero -35, -1, 0, 33, 100, 345 int
negativos, incluido el cero.
Decimal de coma Valores numricos con parte

-0.123, 0.56, 3.0, 1000.07 float
flotante decimal.
El contador ha llegado a 4
Una cadena de caracteres que
Cadena puede incluir nmeros, letras o ALTO string
smbolos.
Hora de comer!
Verdadero o falso. til para

Booleano expresar el resultado de una true, false bool
comparacin.
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; Crea una variable de tipo entero llamada x
bool conectado; Crea un variable de tipo booleano llamada

conectado
string nombre, apellido; Crea las variables de tipo cadena llamadas nombre
y apellido
Opcionalmente se pude asignar un valor a la variable en el momento de su asignacin:
int valorLuz = 40; Crea una variable de tipo entero llamada valorLuz y
le asigna un valor inicial de 40

float xx = 0.25, yy = -1.5; Crea las variables decimales xx e yy y les asigna los
valores iniciales de 0.25 y -1.5 respectivamente
mbito de aplicacin de las variables:

1. Las variables globales se declaran al principio del programa (antes de cualquier bloque de
cdigo en el que vayan a ser usadas). Una vez declaradas se pueden utilizar dentro de
cualquier tarea o funcin. Su mbito comienza en la declaracin y termina al final del
programa.
2. Las variables locales se pueden declarar dentro de las tareas o funciones. Estas variables slo
son accesibles dentro del bloque de cdigo en el que se definen. Su mbito comienza con la
declaracin y termina al final del bloque de cdigo (del conjunto de instrucciones incluido
entre dos llaves).
3. Como regla general,
o Si una variable necesita estar en posicin global, se declara como variable global.
o 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; // y es local de la tarea main
x = y; // ok
y = z; // error aqu no est definida 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.

Se rigen por las mismas reglas que las variables respecto a su utilizacin y mbito de aplicacin.
const tipo NOMBRE_DE_CONSTANTE = valor_de_la_constante;
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;
Los operadores de expresin ms comunes son:
Operador Accin
= Asigna a una variable una expresin
+= Aade a una variable una expresin
-= Resta a una variable una expresin
*= Multiplica una variable por una expresin
/= Divide una variable por una expresin
Algunos ejemplos:
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
5.2 INSTRUCCIONES COMPUESTAS

La estructura de control ms sencilla es una instruccin compuesta. Esto es, una lista de
instrucciones encerradas entre llaves ({ y }).

{
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.
6 INSTRUCCIONES DE CONTROL DE FLUJO
6.1 BUCLES
Los bucles nos ofrecen la solucin cuando queremos repetir una instruccin compuesta un nmero
determinado de veces.
6.1.1 repeat
La instruccin repeat ejecuta un bucle un nmero determinado de veces:
repeat (nmero_de_repeticiones)
{
cuerpo
}
Ejemplo:
repeat (4) Este pedazo de cdigo ejecuta las instrucciones entre

los corchetes cuatro veces. Dependiendo de la
{
potencia y el tiempo, el robot podra describir un
motor[motorA] = 100; cuadrado.
wait1Msec(1000);
motor[motorA] = 60;
wait1Msec(500);
6.1.2 while
La instruccin while se usa para construir un bucle condicional. La condicin se evala y si es
verdadera se ejecuta el cuerpo del bucle, a continuacin se comprueba de nuevo la condicin. El proceso

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
Una variante del bucle while es el bucle do-while. Su sintaxis es:
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
Las sintaxis del bucle for es:
for ( valor_inicial; condicin; incremento )
{
cuerpo
}
Ejemplo:

task main() i=0 Se asigna un valor inicial a la variable i.
{ Ese valor es cero en este ejemplo. Esta es la
parte de valor_inicial.
int i;
i<20 Esta es la parte condicin. En ella se
pone la condicin de que i sea menor que 20,
for ( i=0 ; i<20 ; i++ ) de modo que el bucle se ejecutar mientras i
sea menor que 20, es decir, mientras se
{ cumpla la condicin.
PlaySound(soundBeepBeep); i++ Es la parte de incremento, en la que
} se indica cunto se incrementa la variable en
cada iteracin.
El resultado es que se emitir el sonido
}
BeepBeep veinte veces.
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
}

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.

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:
mi_bucle: // etiqueta
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; // Se asigna a la variable a el valor 3
a = b; // Se asigna a la variable a el valor de la variable b
Podemos dar valores a varias variables a la vez:

a = b = c = 10; // Damos a las variables a,b,c el valor 10
Tambin podemos asignar a varias variables el valor de otra en solo una instruccin:
a = b = c = d; // a,b,c toman el valor de 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 Operador (+) : Suma

Este operador permite sumar variables:
int a = 2;
int b = 3;
int c;
c = a + b; // c es 5
Se pueden sumar varias variables o variables ms constantes:

int a = 2;
int b = 3;
int c = 1;
int d;
d = a + b + c + 4; // d es 10
Podemos utilizar este operador para incrementar el valor de una variable:

x = x + 5; // se incrementa en 5 el valor de x
8.2.2 Operador (+=): Incremento

Existe una forma abreviada para el ltimo ejemplo:
x += 5; // se incrementa en 5 el valor de x
8.2.3 Operador (++): Incremento en 1

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 Operador (-) : Resta / Negativo

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
Para la operacin resta se aplica todo lo dicho para la suma.
Cambio de signo. Si se pone delante de una variable o constante equivale a multiplicarla por
menos 1:
int a, b;

a = 3;
b = -a; // b es -3
8.2.5 Operador (-=): Decremento

Equivalente al operador +=, pero en decremento.
8.2.6 Operador (--): Decremento en 1

Es equivalente a ++ pero en vez de incrementar disminuye el valor de la variable. Equivale a restar
uno a la variable.
8.2.7 Operador (*): Multiplicacin

Este operador sirve para multiplicar y funciona de manera parecida a los anteriores.
8.2.8 Operador (/): Divisin

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 Operador (%) : Resto

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 NOMBRE OPERADOR NOMBRE
+ Suma * Multiplicacin
+= Incremento / Divisin
++ Incremento en 1 % Resto
- 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 se cumple si son iguales
!= distinto a se cumple si son diferentes
> mayor que se cumple si el primero es mayor que el segundo
< menor que se cumple si el primero es menor que el segundo
>= mayor o igual que se cumple si el primero es mayor o igual que el segundo
<= menor o igual que se cumple si el primero es menor o igual que el segundo
true Siempre verdadero
false Siempre falso
No slo se pueden comparar constantes, tambin se pueden comparar variables.

Ejemplos:
if ( a > b) Se cumple (devuelve un 1) si a es mayor que b
while ( a<= b) Se cumple si a es menor o igual que b
while (true) Se cumple siempre (bucle infinito)
if (a != b) Se cumple si a es distinto de b
8.4 OPERADORES LGICOS

Estos operadores permiten unir varias comparaciones. Son los siguientes:
OPERADOR OPERACIN LGICA SIGNIFICADO
&& Y (AND) Devuelve un 1 si se cumplen las dos condiciones.
|| O (OR) Devuelve un 1 si se cumple una de las dos condiciones.
Si la condicin se cumple, NOT hace que no se cumpla y

! NEGACIN (NOT)
viceversa.
Ejemplos de && (AND):
if ( a==3 && b==2 ) Se cumple si a es 3 Y b es dos

if ( a>10 && a<100 ) Se cumple si a es mayor que 10 Y menor que 100
if ( a==10 && b<300 ) Se cumple si a es igual a 10 Y b es menor que 300
Ejemplos de || (OR):
if ( a<100 || b>200 ) Se cumple si a es menor que 100 O b mayor que 200
if ( a<10 || a>100 ) Se cumple si a es menor que 10 O a mayor que 100
Se pueden poner ms de dos condiciones:
Se cumple si a est entre 10 y 100 y b est

if ( a>10 && a<100 && b>200 && b<500 )
entre 200 y 500
Tambin se pueden agrupar mediante parntesis varias condiciones:
Esta condicin se leera como

sigue:
si a es mayor que 10 y menor
if ( ( a>10 && a<100 ) || ( b>200 && b<500 ) ) que 100
o
si b es mayor que 200 y menor
que 500
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:
Pone el motor conectado al puerto A girando hacia delante al 100%

motor[motorA] = 100;
de velocidad.
Pone el motor conectado al puerto C girando hacia atrs al 60% de

velocidad.
motor[motorC] = 0; Para el motor conectado al puerto B.

9.2 CONTROL PID (NXT)
La velocidad de giro de un motor no depende solamente de la que se haya ajustado mediante la
funcin comentada en el apartado anterior, sino que se ve influida por otros factores tales como las
propias caractersticas del motor (no hay dos motores iguales), la carga de la batera, el rozamiento en la
transmisin o el tipo de superficie sobre la que se mueva el robot.
RobotC incluye para el equipo NXT un algoritmo llamado PID (Proporcional Integral Derivativo: es
un mecanismo de control por realimentacin) que ajusta la velocidad de los motores mediante la
monitorizacin continua de los sensores de rotacin (encoders) que incluyen los motores NXT. De esta
manera se puede controlar con precisin la velocidad a la que giran los motores.
Las funciones bsicas que permiten este control son las siguientes:
El algoritmo monitoriza la velocidad

real de giro del motor y la velocidad a
nMotorPIDSpeedCtrl[puerto_motor] = mtrSpeedReg; la que debera ir (p.ej. 50) y ajusta el
nivel de potencia del motor para que
alcance la velocidad deseada.
Se fuerza al motor esclavo a ir a la

nSyncedMotors = synchesclavo_maestro;
misma velocidad que el motor maestro.
%_relacin:
100 es la misma velocidad del esclavo
que la del maestro
nSyncedTurnRatio = %_relacin;
50 es la mitad
-100 es la misma velocidad pero con el
sentido de giro opuesto
Ejemplo 1:
task main() Se habilita el control PID del motor A y se

ajusta su velocidad a 60. En caso
{ nMotorPIDSpeedCtrl[motorA] = mtrSpeedReg;
necesario se aumentar o disminuir la
motor[motorA] = 60; potencia del motor para que gire a 60.
}
Ejemplo 2:
task main() El motor maestro es A, ajustado a una

velocidad deseada de 50. El motor B
{
(esclavo) se ajustar a su vez a la misma
nMotorPIDSpeedCtrl[motorA] = mtrSpeedReg; velocidad (100%) que el A.
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.

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 PLATAFORMA VALORES DEVUELTOS
Raw value
RCX y NXT 0 a 1024 (raw)
Valor en bruto
Touch
RCX y NXT 0 o 1 (booleano)
Toque
Temperature (legacy)
RCX C o F
Temperatura (antiguo)
Reflection (legacy)
RCX 0 a 100 ( % )
Reflexin (luz antiguo)
Rotation (legacy) 0 a 16
RCX
Rotacin (antiguo) (360 = 16, 90 = 4, )
Light active
NXT 0 a 100 ( % )
Luz activo
Light inactive
NXT 0 a 100 ( % )
Luz inactivo
Sound DB
NXT 0 a 100 ( % )
Sonido dB
Sound DBA NXT 0 a 100 ( % )
Sonar 9V NXT cm al obstculo
Encoder NXT (*) NXT 360 = 1 vuelta
Custom (sensores no
RCX y NXT Segn el sensor
fabricados por LEGO)
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:

Ejemplo 1:
const tSensors bumper = (tSensors) S1; //sensorTouch
Se configura un sensor de toque, llamado bumper, en el puerto S1.
Ejemplo 2:
const tSensors ojo = (tSensors) S2; //sensorLightActive
Se configura un sensor de luz activo, llamado ojo, en el puerto S2.
Ejemplos de uso de lecturas de sensores:

if(SensorValue(lightSensor) < 45)
while(SensorValue(touchSensor) == 0)
Variables para sensores:
SensorType[nombre_sensor] Esta variable de lectura/escritura se usa para configurar

el tipo del sensor.
SensorMode[nombre_sensor] Esta variable de lectura/escritura se usa para configurar

el modo del sensor.
SensorValue[nombre_sensor] Esta variable contiene la lectura actual normalizada del

sensor.
SensorRaw[nombre_sensor] Esta variable contiene la lectura actual no normalizada

del 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) Espera a que el motor A gire dos vueltas
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); Reproduce uno de los sonidos predefinidos
del sistema.

RCX y NXT
PlayTone(frecuencia, duracin); Reproduce un tono de la frecuencia (en

HZ) y duracin (en dcimas de s)
especificadas.
RCX y NXT
ClearSounds(); Borra todos los comandos de sonido
existentes y en el buffer.
NXT
PlaySoundFile(nombre_archivo); Reproduce un archivo de sonido del sistema
de archivos del NXT (formato .rso).
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); // reproduce el sonido BeepBeep
PlayTone(440, 10); // reproduce un tono de 440 Hz durante 1 s
PlaySoundFile(hola.rso); // reproduce el archivo de sonido 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); La ejecucin del programa esperar el nmero de

unidades especificadas: milsimas o centsimas de
wait10Msec(centsimas_de_segundo); segundo.
time1[cronmetro]
Almacena el valor del cronmetro especificado:
time10[cronmetro] T1, T2, T3 o T4. El valor puede ser obtenido en
unidades de 1, 10 o 100 milisegundos.
time100[cronmetro]
ClearTimer(cronmetro); Pone a cero el cronmetro especificado.
Ejemplos:
motor[motorC] = 100; Pone el motor C en marcha durante 1s. Despus contina con la
wait1Msec(1000); ejecucin del programa.
wait10Msec(1000); Espera 10 s antes de seguir con la ejecucin del programa.
Ejecuta las instrucciones si el valor del cronmetro T1 es igual

if (time1[T1] = 3000)
a 3 s (3000 milisegundos).
Ejecuta las instrucciones mientras el valor del cronmetro T2

while (time100[T2] < 20)
sea menor que 2 s (20 dcimas de segundo).
ClearTimer(T3); Pone a cero el cronmetro 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:
Enva un mensaje de 1 byte a travs del canal

sendMessage(ID_mensaje); infrarrojo del RCX.
ID_mensaje debe estar entre 1 y 255.
Borra el buffer de mensajes. A partir de esta orden el

ClearMessage();
RCX puede recibir nuevos mensajes.
Variable que contiene el valor (1 a 255) del ltimo

message()
mensaje no procesado y recibido por el RCX.
Ejemplos:
sendMessage(1); Enva el mensaje identificado como 1.

Si el mensaje recibido est identificado con
if (message == 3) motor[motorA]= 100;
el 3 pone en marcha el motor A.
while (message == 0) Hace algo mientras no se reciban mensajes.
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.

ID_mensaje debe de estar entre -32767 y
sendMessageNew(ID_mensaje); 32767. No debe usarse el valor 0 porque es el
valor que indica que no se ha recibido ningn
mensaje cuando se utiliza la variable message.
sendMessageWithParm(nmero_mensaje, Idntica a la anterior, pero el mensaje contiene

nParm1, nParm2); tres valores de 16 bits.
Variable que contiene el valor del mensaje

message()
recibido.
Matriz que contiene los valores optativos

messageParm()
adicionales.
ClearMessage(); Borra el mensaje recin recibido.
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.
Muestra en la pantalla un valor (una cifra, una

SetUserDisplay(valor ,precisin); constante o el valor de una variable) con la
precisin especificada.
La precisin puede ser:

TPrecision0 Ninguna cifra decimal
TPrecision1 Una cifra decimal

TPrecision2 Dos cifras decimales
TPrecision3 Tres cifras decimales
Ejemplos:
Muestra la lectura del sensor luz,

SetUserDisplay(SensorValue(luz),TPrecision0); expresndolo como un nmero
entero.
Muestra el valor del cronmetro T1,

SetUserDisplay(T1, TPrecision1);
expresndolo con una cifra decimal.
Muestra el valor de la variable x,

SetUserDisplay(x,TPrecision3); expresndolo con tres cifras
decimales.
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.
14.2.1 Funciones para texto

nxtDisplayString(nmero_lnea,cadena form_par1 form_par2,par1,par2);
Muestra en la pantalla una cadena de caracteres, con alineacin a la izquierda y que se

visualiza en el nmero_lnea indicado. La cadena sustituye a los caracteres que haya
previamente en la lnea, si los hubiera, pero en tal caso el resto de la lnea permanece
inalterada.
par1 y par2 son parmetros opcionales y se refieren a un valor (el de una variable o una
constante). Los valores se formatean mediante cdigo (form_par1 y form_par2), que es
obligatorio expresarlo si se incluyen los parmetros.
Hay ocho lneas de texto numeradas del 0 (la lnea superior) al 7 (la lnea inferior).
En cada lnea caben 16 caracteres.
Las sintaxis posibles de esta funcin son las siguientes:

nxtDisplayString(nmero_lnea, cadena);
nxtDisplayString(nmero_lnea, cadena form_par1, par1);
nxtDisplayString(nmero_lnea, cadena form_par1 form_par2, par1, par2);
nxtDisplayString(nmero_lnea, form_par1, par1);
nxtDisplayString(nmero_lnea, form_par1 form_par2, par1, par2);
Ejemplos:
aparece en la
Si se escribe este cdigo
pantalla:
nxtDisplayString(0,"Hola mundo"); Hola mundo

nxtDisplayString(3,"El valor es %d,entero"); El valor es
8
nxtDisplayString(6,Sensor es %03d,SensorValue[S1]); Sensor es
038
nxtDisplayString(2,%2d %3.2f,aaa, BBB); 8 4.60
nxtDisplayTextLine(nmero_lnea,cadena form_par1 form_par2,par1,par2);

Igual que nxtDisplayString pero se reemplaza la lnea de texto entera. La lnea se rellena con
espacios en blanco si es necesario.
nxtDisplayCenteredTextLine(nmero_lnea,cadena form_par1 form_par2, par1,

par2);
Igual que nxtDisplayTextLine pero el texto aparece centrado en vez de alineado a la izquierda.
nxtDisplayClearTextLine(nmero_lnea);
Borra la lnea especificada en nmero_lnea.
nxtScrollText(nmero_lnea,cadena form_par1 form_par2,par1,par2);

Desplaza una lnea hacia arriba el contenido de la pantalla y luego se comporta como la funcin
nxtDisplayTextLine, pero mostrando la cadena en la lnea inferior de la pantalla (la lnea 7).
nxtDisplayStringAt(xPos, yPos, cadena form_par1 form_par2, par1, par2);

Igual que nxtDisplayString pero muestra la cadena a partir de las coordenadas (xPos, yPos).
nxtDisplayBigStringAt(xPos,yPos,cadena form_par1 form_par2, par1, par2);

Igual que nxtDisplayStringAt pero usando una fuente grande de 16 pxeles de alto.
eraseDisplay();
Borra el contenido de la pantalla.
14.2.2 Cdigos de formateo de texto en pantalla

Las especificaciones de formato siempre comienzan con el smbolo % y se leen de izquierda a
derecha. Tienen la siguiente forma:
% [ancho] [.precisin] tipo Los campos entre [ ] son opcionales.
[ancho] Indica el nmero de caracteres que ocupar el nmero o cadena.

[.precisin] Indica cuantas posiciones decimales tendr el nmero.
tipo Indica el tipo de variable: d (entero), f (floating), s (cadena).

Ejemplos:
ENTEROS Ejemplo int x = 7;
%d La rutina de formato simplemente calcula el ancho de la variable. 7

El elemento tendr 6 caracteres de largo. Estar alineado a la derecha y se
%6d rellenarn con espacios en blanco el resto. Los 6 caracteres incluyen - para 7
los nmeros negativos. Si el nmero es positivo no se muestra +.
Igual que el anterior pero se rellena con ceros el espacio hasta completar los
%06d
6 caracteres.
000007
%+6d Igual que %6d pero se incluir el smbolo de signo (+ o -). +00007
DECIMALES DE COMA FLOTANTE Ejemplo float y = 12.34;
Se representa el valor alineado a la izquierda. Por defecto se

%f
representan 6 cifras decimales. 12.340000
El elemento tendr 5 caracteres de largo (sin incluir el punto

%5.3f
decimal), y 3 de ellos sern decimales 12.340
14.2.3 Funciones para formas geomtricas

Las funciones que incorpora RobotC para dibujar en la pantalla son:
Dibuja un punto en la posicin de

nxtSetPixel(x, y);
coordenadas (x,y).
Borra el punto en la posicin de

nxtClearPixel(x, y);
coordenadas (x,y).
Dibuja una lnea entre los puntos(x1,

nxtDrawLine(x1, y1, x2, y2);
y1) y (x2, y2).
Dibuja una circunferencia desde las

nxtDrawCircle(Izda, Arriba, Dimetro); coordenadas (Izda,Arriba) con el
Dimetro especificado.
Dibuja un rectngulo vaco definido

nxtDrawRect(Izda,Arriba,Derecha,Abajo); por las coordenadas (Izda,
Arriba, Derecha, Abajo).
Dibuja un rectngulo relleno definido

nxtFillRect(Izda,Arriba,Derecha,Abajo); por las coordenadas (Izda,
Arriba, Derecha, Abajo).
Borra una zona rectangular de la

pantalla definida por las coordenadas
nxtEraseRect(Izda,Arriba,Derecha,Abajo);
(Izda, Arriba, Derecha,
Abajo).

Dibuja una elipse vaca inscrita en el
rectngulo definido por las
nxtDrawEllipse(Izda,Arriba,Derecha,Abajo);
coordenadas (Izda, Arriba,
Derecha, Abajo).
Dibuja una elipse rellena inscrita en el

nxtFillEllipse(Izda,Arriba,Derecha,Abajo);
Derecha, Abajo).
Borra una zona elptica inscrita en el

nxtEraseEllipse(Izda,Arriba,Derecha,Abajo);
Derecha, Abajo).
Muestra un archivo ICON en el punto

nxtDisplayIconFile(x, y, nombre_archivo) especificado por las coordenadas
(x,y).
15 REGISTRO DE DATOS (DATALOG)

Tanto el RCX como el NXT tienen capacidad para almacenar valores de los sensores, variables,
temporizadores y del reloj del sistema durante la ejecucin de un programa. Esta capacidad es til para
recoger datos mientras se estn tomando medidas. Tambin es til para depurar programas en los que se
quiere analizar el valor de una variable en particular despus de que el programa se haya ejecutado.
15.1 RCX
Crea un registro de datos del tamao

especificado (que debe ser constante). Un
CreateDatalog(tamao);
tamao de 0 elimina el anterior sin crear uno
nuevo.
Aade el valor x, que puede ser una expresin, al

AddToDatalog(x); registro de datos. Si el registro de datos est
lleno la llamada no tiene efecto.
Inicia y transmite un nmero de datos igual a

UploadDatalog(comienzo, contador); contador, comenzando por el valor de
comienzo.
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.

Crea un registro de datos del tamao
especificado (que debe ser constante). Un
CreateDatalog(tamao);
tamao de 0 elimina el anterior sin crear uno
nuevo.
Aade el valor x, que puede ser una expresin, al

AddToDatalog(x); registro de datos. Si el registro de datos est
lleno la llamada no tiene efecto.
Inicia y transmite un nmero de datos igual a

UploadDatalog(comienzo, contador); contador, comenzando por el valor de
comienzo.
Almacena el registro en curso en un archivo de

datos estndar NXT. El archivo tiene el nombre
Datannnn.RDT, en el que nnnn es un nmero
SaveNxtDatalog(); de cuatro dgitos. El firmware de RobotC buscar
el nmero ms alto que haya en los archivos RDT
e incrementar en uno este nmero para guardar
el nuevo archivo.
16 OTRAS FUNCIONES Y VARIABLES

Existen otras muchas variables, funciones y utilidades que pueden ser usadas. Entre ellas las que
incumben a:
Manipulacin de variables tipo cadena (strings).
Constantes y variables incorporadas.
Depuracin de cdigo.
Funciones matemticas.
Control de la Batera.
Control mediante programacin de los botones del NXT.
Comunicacin Bluetooth.
Sensores digitales I2C.
Preferencias de RobotC.
Acceso a archivos del NXT.
Control del acceso al mapa I/O (entrada/salida).
Todas estas variables, funciones y utilidades van ms all del mbito de esta gua. Para obtener
informacin acerca de ellas se puede consultar la ayuda que proporciona RobotC a travs del men Help
de su interfaz grfica.
Asimismo se pueden consultar los documentos que se incluyen en el apartado Referencias de esta
gua.

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.5-
Dave_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

Robotcguia 120828131403 Phpapp01 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Robotcguia 120828131403 Phpapp01 PDF

Cargado por

Copyright:

Formatos disponibles

GUA DEL PROGRAMADOR

Para RCX y NXT

2 RobotC. Gua del programador

RobotC. Gua del programador 3

Cdigo en RobotC motor[motorC] = 100;

Descomposicin en piezas (tokens) motor [ motorC ] = 100 ;

2.2 SIGNOS DE PUNTUACIN

2.3 ESPACIOS EN BLANCO

4 RobotC. Gua del programador

RobotC. Gua del programador 5

// un comentario de una lnea sencilla

El compilador ignora los comentarios. Su nico propsito es permitir al programador documentar

2.6 COLOREADO DE CDIGO

2.7 IDENTIFICADORES Y PALABRAS RESERVADAS

break else repeat task

case false return true

const for start void

continue goto stop while

6 RobotC. Gua del programador

StartTask(nombre_tarea); Inicia o reinicia la ejecucin de la tarea especificada

StopTask(nombre_tarea); Detiene la ejecucin de la tarea especificada

Detiene la ejecucin de todas las tareas (y por tanto del

La palabra reservada void es consecuencia de la herencia de RobotC (en C las funciones se

RobotC. Gua del programador 7

Se declara la funcin GiraDerecha (sin argumentos), void GiraDerecha()

Se define la tarea principal task main ()

El robot avanza al 100 % de potencia durante 1 s motor[motorA] = 100;

Se llama a la funcin GiraDerecha, y el robot gira GiraDerecha();

Despus continua avanzando al 100 % de potencia motor[motorA] = 100;

2. En este otro ejemplo la funcin GiraDerecha se declara con el argumento tiempo.

Se declara la funcin GiraDerecha (con el argumento void GiraDerecha(int tiempo)

Se define la tarea principal task main ()

El robot avanza al 100 % de potencia durante 1 s motor[motorA] = 100;

8 RobotC. Gua del programador

Despus continua avanzando al 100 % de potencia motor[motorA] = 100;

TIPO DE DATOS DESCRIPCIN EJEMPLOS CDIGO

Nmeros enteros positivos y

Decimal de coma Valores numricos con parte

Verdadero o falso. til para

int x; Crea una variable de tipo entero llamada x

bool conectado; Crea un variable de tipo booleano llamada

Opcionalmente se pude asignar un valor a la variable en el momento de su asignacin:

RobotC. Gua del programador 9

mbito de aplicacin de las variables:

10 RobotC. Gua del programador

const tipo NOMBRE_DE_CONSTANTE = valor_de_la_constante;

Los operadores de expresin ms comunes son:

= Asigna a una variable una expresin

+= Aade a una variable una expresin

-= Resta a una variable una expresin

*= Multiplica una variable por una expresin

/= Divide una variable por una expresin

5.2 INSTRUCCIONES COMPUESTAS

RobotC. Gua del programador 11

6 INSTRUCCIONES DE CONTROL DE FLUJO

repeat (4) Este pedazo de cdigo ejecuta las instrucciones entre

12 RobotC. Gua del programador

Es normal utilizar una instruccin compuesta como cuerpo del bucle.

Si se usa true como condicin de while se establece un bucle infinito.

En la instruccin while la condicin se comprueba antes de ejecutar el cuerpo, mientras que en

RobotC. Gua del programador 13

6.2 INSTRUCCIONES DE CONDICIN

14 RobotC. Gua del programador