Robotc guia

GUÍA DEL PROGRAMADOR
Para RCX y NXT

NIVEL BÁSICO

Gustavo Zazo

ÍNDICE
1 INTRODUCCIÓN....................................................................................................4
2 REGLAS LÉXICAS ..................................................................................................4
2.1 CÓDIGO ......................................................................................................4
2.2 SIGNOS DE PUNTUACIÓN..................................................................................4
2.3 ESPACIOS EN BLANCO .....................................................................................4
2.4 INSTRUCCIONES ............................................................................................5
2.5 COMENTARIOS ..............................................................................................5
2.6 COLOREADO DE CÓDIGO ..................................................................................6
2.7 IDENTIFICADORES Y PALABRAS RESERVADAS ..........................................................6
3 BLOQUES DE CÓDIGO ............................................................................................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 ASIGNACIÓN............................................................................................... 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 CONDICIÓN........................................................................ 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 ASIGNACIÓN ( = ) ...................................................................... 16
8.2 OPERADORES ARITMÉTICOS ............................................................................ 17
8.2.1 Operador (+) : Suma ................................................................................. 17
8.2.2 Operador (+=): Incremento ......................................................................... 17
8.2.3 Operador (++): Incremento en 1 ................................................................... 17

2 RobotC. Guía 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 (*): Multiplicación........................................................................ 18
8.2.8 Operador (/): División ............................................................................... 18
8.2.9 Operador (%) : Resto ................................................................................. 18
8.2.10 Resumen ............................................................................................ 18
8.3 OPERADORES DE CONDICIÓN ........................................................................... 19
8.4 OPERADORES LÓGICOS .................................................................................. 19
9 MOTORES (Salidas) ............................................................................................. 20
9.1 CONTROL BÁSICO ........................................................................................ 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 Códigos de formateo de texto en pantalla ................................................... 28
14.2.3 Funciones para formas geométricas ........................................................... 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. Guía del programador 3

1 INTRODUCCIÓN
RobotC es un potente lenguaje textual de programación 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 solución para varias plataformas, en especial para NXT y RCX de LEGO, que permite a los
estudiantes el aprendizaje del tipo de programación 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 “GUÍA DEL PROGRAMADOR (nivel básico)” no es, ni mucho menos, una exhaustiva
descripción ni del lenguaje C, ni del propio RobotC, sino un documento al que los estudiantes puedan
acudir si les surgen dudas acerca de programación sencilla de sus robots en RobotC.

2 REGLAS LÉXICAS

2.1 CÓDIGO
• 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 máquina y después se cargan en el
robot, en el que se pueden ejecutar. El texto que se escribe como parte de un programa se llama
código.
• El código de un programa en RobotC consiste en una serie de piezas (tokens) ordenadas
secuencialmente.
• Cada pieza está integrada por letras, números, signos de puntuación o símbolos matemáticos.
Gráficamente se puede expresar como sigue:

Código en RobotC motor[motorC] = 100;

Descomposición en piezas (tokens) motor [ motorC ] = 100 ;
m m

• El lenguaje C (y, por tanto, RobotC, que es un derivado suyo) diferencia entre mayúsculas y
minúsculas, por lo que hay que prestar atención 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 PUNTUACIÓN
• Se emplean varios signos de puntuación para diferentes cometidos:
; Fin de instrucción
( ) [ ] Inicio y fin de parámetros
{} Inicio y fin de estructuras de control

2.3 ESPACIOS EN BLANCO
• El espacio en blanco (espacios, tabuladores y saltos de línea) se usa para separar piezas y para
hacer los programas más legibles. Con tal de que se distingan las piezas, no tiene efecto en el
programa añadir o suprimir espacios en blanco. Por ejemplo, las siguientes líneas de código
tienen el mismo significado:


x=2;
x = 2 ;

• Algunos de los operadores de C++ están formados por múltiples caracteres. Para preservar estas
piezas no se debe insertar espacio en blanco entre ellos. En el ejemplo siguiente, la primera
línea usa un operador de cambio a la derecha (“>>”), pero en la segunda línea el espacio
añadido hace que los símbolos “>” 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 líneas ayuda al programador a leer el código con mayor
facilidad. Es muy recomendable hacer un buen uso de los espacios en blanco en un programa.

2.4 INSTRUCCIONES
• Una instrucción (orden, sentencia o declaración) es una orden directa al robot. Por ejemplo, la
instrucción 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 mayoría acaban en “ ; “, pero no
porque estén en diferentes líneas. Los dos siguientes trozos de código son exactamente iguales
para RobotC, pero el segundo es prácticamente 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 líneas, pero no pueden anidarse.

/* esto es un comentario */
/* esto es un comentario
de dos líneas */
/* 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 línea (conocidos a
veces como comentarios estilo C++).

// un comentario de una línea sencilla

• El compilador ignora los comentarios. Su único propósito es permitir al programador documentar
el código fuente.

2.6 COLOREADO DE CÓDIGO
• RobotC colorea automáticamente las palabras, símbolos 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 carácter de
un identificador debe ser una letra mayúscula o minúscula o el guión bajo (“_”). Los caracteres
restantes pueden ser letras, números y el guión bajo. ( ¿ )
• Se reserva un número 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 CÓDIGO
Un programa en RobotC se compone de bloques de código y variables globales. Hay dos tipos de
bloques de código: tareas y funciones en línea. Cada tipo de bloque de código tiene sus propias
características y restricciones particulares, pero todos comparten una estructura común.


3.1 TAREAS
• RobotC soporta implícitamente multitarea, de modo que una tarea en RobotC corresponde a una
tarea RCX o NXT.
• El número máximo de tareas es 10.
• Las tareas se definen por medio de la palabra reservada task utilizando la siguiente sintaxis:

task nombre()
{
// El código 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 ejecución de la tarea especificada

StopTask(nombre_tarea); Detiene la ejecución de la tarea especificada

Detiene la ejecución 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 función, 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 función
}

• 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 (vacío). La devolución 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 vacía o puede contener una o más definiciones de
argumento. Un argumento se define por su tipo seguido de su nombre. Los argumentos múltiples
se separan por comas.
• Para llamar a una función simplemente, donde se desee que se ejecute el código, se escribe su
nombre seguido de paréntesis (con o sin argumentos) y de punto y coma.


• Las funciones RobotC siempre se expanden como funciones en línea. Esto significa que cada
llamada a una función hace que se incluya en el programa otra copia del código de la función. Si
no se usan con sensatez, las funciones en línea hacen que el tamaño del código sea excesivo.

EJEMPLOS DE APLICACIÓN
1. En el siguiente ejemplo se define la función GiraDerecha, que luego es llamada desde la
tarea principal task main.

Se declara la función 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 función GiraDerecha, y el robot gira GiraDerecha();
durante ½ s wait1Msec(500);

Después continua avanzando al 100 % de potencia motor[motorA] = 100;
durante 3 s
wait1Msec(3000);
}

2. En este otro ejemplo la función GiraDerecha se declara con el argumento tiempo.

Se declara la función 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 función. 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 función GiraDerecha, especificando un GiraDerecha (500);
tiempo de 500 y el robot gira durante ½ s

Después 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 numéricas,
cadenas alfanuméricas o valores booleanos.
• Los principales tipos de variables que soporta RobotC son los siguientes:

TIPO DE DATOS DESCRIPCIÓN EJEMPLOS CÓDIGO

Números enteros positivos y
Entero -35, -1, 0, 33, 100, 345 int
negativos, incluido el cero.

Decimal de coma Valores numéricos 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 números, letras o “ALTO” string
símbolos.
“¡Hora de comer!”

Verdadero o falso. Útil para
Booleano expresar el resultado de una true, false bool
comparación.

• 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 asignación:

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 aplicación de las variables:
1. Las variables globales se declaran al principio del programa (antes de cualquier bloque de
código en el que vayan a ser usadas). Una vez declaradas se pueden utilizar dentro de
cualquier tarea o función. Su ámbito comienza en la declaración y termina al final del
programa.
2. Las variables locales se pueden declarar dentro de las tareas o funciones. Estas variables sólo
son accesibles dentro del bloque de código en el que se definen. Su ámbito comienza con la
declaración y termina al final del bloque de código (del conjunto de instrucciones incluido
entre dos llaves).
3. Como regla general,
o Si una variable necesita estar en posición global, se declara como variable global.
o Si una variable no necesita ser global, hacer que sea lo más 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 instrucción de la declaración.


• Se rigen por las mismas reglas que las variables respecto a su utilización y ámbito de aplicación.

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 mayúsculas para los
nombres de constantes y minúsculas para los nombres de variables.

5 INSTRUCCIONES GENERALES

5.1 ASIGNACIÓN
Una vez declaradas las variables se les puede asignar el valor de una expresión:
Variable operador_de_asignación expresión;

Los operadores de expresión más comunes son:

Operador Acción

= Asigna a una variable una expresión

+= Añade a una variable una expresión

-= Resta a una variable una expresión

*= Multiplica una variable por una expresión

/= Divide una variable por una expresión

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 más sencilla es una instrucción 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 más complicadas. Muchas estructuras de control requieren una instrucción sencilla como cuerpo.
Usando una instrucción compuesta, la misma estructura de control se puede usar para controlar múltiples
instrucciones.

6 INSTRUCCIONES DE CONTROL DE FLUJO

6.1 BUCLES
Los bucles nos ofrecen la solución cuando queremos repetir una instrucción compuesta un número
determinado de veces.

6.1.1 repeat
La instrucción repeat ejecuta un bucle un número determinado de veces:

repeat (número_de_repeticiones)
{
cuerpo
}

Ejemplo:

repeat (4) Este pedazo de código ejecuta las instrucciones entre
los corchetes cuatro veces. Dependiendo de la
{
potencia y el tiempo, el robot podría describir un
motor[motorA] = 100; cuadrado.
wait1Msec(1000);

motor[motorA] = 60;
wait1Msec(500);

}

6.1.2 while
La instrucción while se usa para construir un bucle condicional. La condición se evalúa y si es
verdadera se ejecuta el cuerpo del bucle, a continuación se comprueba de nuevo la condición. El proceso


continúa hasta que la condición se vuelve falsa (o se ejecuta la instrucción break). A continuación
aparece la sintaxis para el bucle while:

while (condición)
{
cuerpo
}

• Es normal utilizar una instrucción compuesta como cuerpo del bucle.
while (x < 10)
{
x = x+1;
y = y*2;
}

• Si se usa true como condición 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 (condición)

• En la instrucción while la condición se comprueba antes de ejecutar el cuerpo, mientras que en
la instrucción do – while la condición 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; condición; 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 condición. En ella se
pone la condición 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 condición.
PlaySound(soundBeepBeep); i++ Es la parte de incremento, en la que
} se indica cuánto se incrementa la variable en
cada iteración.
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
condición es falsa, esas instrucciones no se ejecutan ni una sola vez.
• Se puede omitir cualquiera de las secciones (inicialización, condiciones o incrementos). También
se pueden poner más de una variable a inicializar, más de una condición y más de un
incremento.

6.2 INSTRUCCIONES DE CONDICIÓN
6.2.1 if - else
La instrucción if evalúa una condición. Si la condición es verdadera ejecuta una instrucción sencilla
o compuesta (la consecuencia). Una segunda instrucción opcional (la alternativa, else) se ejecuta si la
condición es falsa. A continuación se muestran las sintaxis posibles para una instrucción if o if – else.

if (condición) instrucción;

if (condición)
instrucción;

if (condición)
instrucción;
else
instrucción;

if (condición)
{
cuerpo
}

if (condición)
{
cuerpo
}


else
{
cuerpo
}

Obsérvese que la condición va encerrada entre paréntesis. Véanse los ejemplos a continuación. En
el último ejemplo se utiliza una instrucción compuesta para permitir que se ejecuten dos instrucciones
como consecuencia de la condición.

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 instrucción switch sirve par elegir una opción entre varias disponibles. No se evalúa una
condición 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. Múltiples etiquetas pueden preceder a la misma
instrucción.
• El código con switch es más cómodo de leer que con la instrucción 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 instrucción goto fuerza al programa a saltar a una posición determinada. Las instrucciones de un
programa pueden ser marcadas precediéndolas de un identificador y dos puntos, a lo que se llama
etiqueta. La instrucción 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 sólo se puede usar dentro de funciones, y no se puede saltar desde una función a otra.
• La instrucción goto debe usarse con moderación y precaución. En la mayoría de los casos las
estructuras de control tales como if, while y switch hacen los programas más fáciles de leer
y modificar.

7.2 return
Es posible hacer que una función finalice antes de llegar al final de su código usando la instrucción
return.
return;

7.3 break
Dentro de los bucles (por ejemplo, en un bucle while) la instrucción break puede utilizarse para
salir del bucle. La instrucción break también puede utilizarse para salir de la instrucción switch.
break;

7.4 continue
La instrucción continue se puede utilizar para saltar a la parte superior de la siguiente iteración
de un bucle.
continue;

8 OPERADORES
Un operador sirve para manipular datos. Los hay de varios tipos: de asignación, de relación, lógicos,
aritméticos y de manipulación de bits.

8.1 OPERADOR DE ASIGNACIÓN ( = )
Sirve para dar un valor a una variable. Este valor puede ser un número 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

• También podemos asignar a varias variables el valor de otra en solo una instrucción:
a = b = c = d; // a,b,c toman el valor de d

8.2 OPERADORES ARITMÉTICOS
Los operadores aritméticos son aquellos que sirven para realizar operaciones tales como suma,
resta, división y multiplicación. Otras operaciones aritméticas más complejas están fuera del nivel básico
de esta guía.

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 más 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 después 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 operación 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 (*): Multiplicación
Este operador sirve para multiplicar y funciona de manera parecida a los anteriores.

8.2.8 Operador (/): División
Este operador funciona también como los anteriores pero hay que tener cuidado. Si dividimos dos
números en coma flotante (tipo float) tenemos la división con sus correspondientes decimales. Pero si
dividimos dos enteros obtenemos un número 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 módulo) usamos el operador %,
que vemos más abajo.

8.2.9 Operador (%) : Resto
Si con el operador división (/) se obtiene el módulo o cociente de una división entera, con éste se
puede obtener el resto. Sólo funciona con enteros (int), no vale para números 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 * Multiplicación

+= Incremento / División

++ Incremento en 1 % Resto

- Resta

-= Decremento

-- Decremento en 1


8.3 OPERADORES DE CONDICIÓN
Los operadores de condición se utilizan para comprobar las condiciones de las instrucciones de
control de flujo.
• Cuando se evalúa una condición el resultado que se obtiene es 0 si no se cumple la condición y
un número distinto de 0 si se cumple(los números negativos se consideran como verdadero).
Normalmente cuando se cumple la condición devuelve un 1.
• Los operadores de comparación son:

OPERADOR SIGNIFICADO DESCRIPCIÓN

== 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 sólo se pueden comparar constantes, también 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 LÓGICOS
Estos operadores permiten unir varias comparaciones. Son los siguientes:

OPERADOR OPERACIÓN LÓGICA 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 condición se cumple, NOT hace que no se cumpla y
! NEGACIÓN (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 más 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

• También se pueden agrupar mediante paréntesis varias condiciones:

Esta condición se leería 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 excepción de algunas aplicaciones concretas, generalmente se conectan motores.

9.1 CONTROL BÁSICO
RobotC incorpora una función 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 atrás 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
función comentada en el apartado anterior, sino que se ve influida por otros factores tales como las
propias características del motor (no hay dos motores iguales), la carga de la batería, el rozamiento en la
transmisión 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 realimentación) que ajusta la velocidad de los motores mediante la
monitorización continua de los sensores de rotación (encoders) que incluyen los motores NXT. De esta
manera se puede controlar con precisión la velocidad a la que giran los motores.
• Las funciones básicas 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 debería 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.

%_relación:
100 es la misma velocidad del esclavo
que la del maestro
nSyncedTurnRatio = %_relación;
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 configuración de sensores puede ser una tarea algo complicada, RobotC incorpora un
asistente que facilita la configuración. 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 numéricos del puerto (S1, S2, S3 o S4), pero es una buena práctica de
programación 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 más común es percentage (porcentaje), que normalizará el valor
del sensor a una lectura entre 0 y 100. El siguiente más común es raw (valores en bruto), que
simplemente devuelve el valor sin normalizar del sensor (de 0 a 1024). El modo del sensor se
configura automáticamente 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 ( % )
Reflexión (luz antiguo)

Rotation (legacy) 0 a 16
RCX
Rotación (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 obstáculo

Encoder NXT (*) NXT 360 = 1 vuelta

Custom (sensores no
RCX y NXT Según el sensor
fabricados por LEGO)

• Usando el asistente para configuración de sensores y motores (Motors and Sensors Setup),
RobotC genera automáticamente el código 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 rotación 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 precisión determinados movimientos. Existe
una función 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 colección 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, duración); Reproduce un tono de la frecuencia (en
HZ) y duración (en décimas 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 reproducción de un sonido y continuar la ejecución de otras instrucciones
sin tener que esperar a que acabe el sonido para continuar la ejecución del programa. Este modo de
reproducción es muy útil en robots en los que si se espera a la completa reproducción del sonido se
pueden tener retrasos en la reacción de los motores ante la lectura de los sensores.

• Sonidos predefinidos:

sounBeepBeep soundFastUpwardTones soundShortBlip

soundBlip soundLast soundUpwardTones

soundDownwardTones soundLowBuzz

soundException soundLowBuzzShort

• Ejemplos de aplicación:
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 extensión rso y pueden ocupar un
máximo 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 cronómetros (T1, T2, T3 y T4) están integrados y usan esta característica.

• Funciones y variables para control de tiempo:

wait1Msec(milisegundos); La ejecución del programa esperará el número de


unidades especificadas: milésimas o centésimas de
wait10Msec(centésimas_de_segundo); segundo.

time1[cronómetro]
Almacena el valor del cronómetro especificado:
time10[cronómetro] T1, T2, T3 o T4. El valor puede ser obtenido en
unidades de 1, 10 o 100 milisegundos.
time100[cronómetro]

ClearTimer(cronómetro); Pone a cero el cronómetro especificado.

• Ejemplos:

motor[motorC] = 100; Pone el motor C en marcha durante 1s. Después continúa con la
wait1Msec(1000); ejecución del programa.

wait10Msec(1000); Espera 10 s antes de seguir con la ejecución del programa.

Ejecuta las instrucciones si el valor del cronómetro T1 es igual
if (time1[T1] = 3000)
a 3 s (3000 milisegundos).

Ejecuta las instrucciones mientras el valor del cronómetro T2
while (time100[T2] < 20)
sea menor que 2 s (20 décimas de segundo).

ClearTimer(T3); Pone a cero el cronómetro 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 ningún mensaje,
message()devolverá el valor 0. Debe tenerse en cuenta que, debido a la naturaleza de la comunicación
mediante infrarrojos, no se podrán recibir mensajes mientras un mensaje se esté transmitiendo.

• Funciones y variables:

Envía un mensaje de 1 byte a través 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); Envía 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 comunicación entre dos NXT mediante el uso del
sistema inalámbrico Bluetooth que incorporan los NXT. Bluetooth es un protocolo de comunicación
inalámbrica a corta distancia que opera en la frecuencia de radio de 2.4 GHz. El alcance máximo 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 comunicación básica entre dos NXT son las siguientes:

Envía 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 ningún
mensaje cuando se utiliza la variable message.

sendMessageWithParm(número_mensaje, Idéntica 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 recién recibido.

No se deben enviar mensajes con una separación menor de 30 milisegundos, pues podrían perderse.

14 PANTALLA LCD

14.1 RCX
El RCX tiene una pantalla de una línea en el que se pueden mostrar diferentes valores numéricos.

Muestra en la pantalla un valor (una cifra, una
SetUserDisplay(valor ,precisión); constante o el valor de una variable) con la
precisión especificada.

• La precisión 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); expresándolo como un número
entero.

Muestra el valor del cronómetro T1,
SetUserDisplay(T1, TPrecision1);
expresándolo con una cifra decimal.

Muestra el valor de la variable x,
SetUserDisplay(x,TPrecision3); expresándolo con tres cifras
decimales.

14.2 NXT
El NXT está equipado con una pantalla monocroma LCD de 100 píxeles de ancho por 64 píxeles 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
geométricas en la pantalla LCD.

14.2.1 Funciones para texto
nxtDisplayString(número_línea,”cadena form_par1 form_par2”,par1,par2);

• Muestra en la pantalla una cadena de caracteres, con alineación a la izquierda y que se
visualiza en el número_línea indicado. La cadena sustituye a los caracteres que haya
previamente en la línea, si los hubiera, pero en tal caso el resto de la línea permanece
inalterada.
• par1 y par2 son parámetros opcionales y se refieren a un valor (el de una variable o una
constante). Los valores se formatean mediante código (form_par1 y form_par2), que es
obligatorio expresarlo si se incluyen los parámetros.
• Hay ocho líneas de texto numeradas del 0 (la línea superior) al 7 (la línea inferior).
• En cada línea caben 16 caracteres.

Las sintaxis posibles de esta función son las siguientes:
nxtDisplayString(número_línea, ”cadena”);
nxtDisplayString(número_línea, ”cadena form_par1”, par1);
nxtDisplayString(número_línea, ”cadena form_par1 form_par2”, par1, par2);
nxtDisplayString(número_línea, ”form_par1”, par1);
nxtDisplayString(número_línea, ”form_par1 form_par2”, par1, par2);

Ejemplos:
… aparece en la
Si se escribe este código…
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(número_línea,”cadena form_par1 form_par2”,par1,par2);
Igual que nxtDisplayString pero se reemplaza la línea de texto entera. La línea se rellena con
espacios en blanco si es necesario.

nxtDisplayCenteredTextLine(número_línea,”cadena form_par1 form_par2”, par1,
par2);
Igual que nxtDisplayTextLine pero el texto aparece centrado en vez de alineado a la izquierda.

nxtDisplayClearTextLine(número_línea);
Borra la línea especificada en número_línea.

nxtScrollText(número_línea,”cadena form_par1 form_par2”,par1,par2);
Desplaza una línea hacia arriba el contenido de la pantalla y luego se comporta como la función
nxtDisplayTextLine, pero mostrando la cadena en la línea inferior de la pantalla (la línea 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 píxeles de alto.

eraseDisplay();
Borra el contenido de la pantalla.

14.2.2 Códigos de formateo de texto en pantalla
Las especificaciones de formato siempre comienzan con el símbolo ‘%’ y se leen de izquierda a
derecha. Tienen la siguiente forma:

% [ancho] [.precisión] tipo Los campos entre [ ] son opcionales.

[ancho] Indica el número de caracteres que ocupará el número o cadena.
[.precisión] Indica cuantas posiciones decimales tendrá el número.
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 rellenarán con espacios en blanco el resto. Los 6 caracteres incluyen ‘-‘ para 7
los números negativos. Si el número 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 símbolo 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 serán decimales 12.340

14.2.3 Funciones para formas geométricas
Las funciones que incorpora RobotC para dibujar en la pantalla son:

Dibuja un punto en la posición de
nxtSetPixel(x, y);
coordenadas (x,y).

Borra el punto en la posición de
nxtClearPixel(x, y);
coordenadas (x,y).

Dibuja una línea entre los puntos(x1,
nxtDrawLine(x1, y1, x2, y2);
y1) y (x2, y2).

Dibuja una circunferencia desde las
nxtDrawCircle(Izda, Arriba, Diámetro); coordenadas (Izda,Arriba) con el
Diámetro especificado.

Dibuja un rectángulo vacío definido
nxtDrawRect(Izda,Arriba,Derecha,Abajo); por las coordenadas (Izda,
Arriba, Derecha, Abajo).

Dibuja un rectángulo 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 vacía inscrita en el
rectángulo 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 elíptica 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 ejecución de un programa. Esta capacidad es útil para
recoger datos mientras se están tomando medidas. También es útil para depurar programas en los que se
quiere analizar el valor de una variable en particular después de que el programa se haya ejecutado.

15.1 RCX

Crea un registro de datos del tamaño
especificado (que debe ser constante). Un
CreateDatalog(tamaño);
tamaño de 0 elimina el anterior sin crear uno
nuevo.

Añade el valor x, que puede ser una expresión, al
AddToDatalog(x); registro de datos. Si el registro de datos está
lleno la llamada no tiene efecto.

Inicia y transmite un número de datos igual a
UploadDatalog(comienzo, contador); contador, comenzando por el valor de
comienzo.

15.2 NXT
Los datos se almacenan en la RAM. Después pueden ser copiados en un archivo flash del NXT. No se
almacenan en tiempo real en el archivo flash porque se invertirían entre 3 y 6 milisegundos en la
operación, lo que podría perturbar la ejecución 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 tamaño
especificado (que debe ser constante). Un
CreateDatalog(tamaño);
tamaño de 0 elimina el anterior sin crear uno
nuevo.

Añade el valor x, que puede ser una expresión, al
AddToDatalog(x); registro de datos. Si el registro de datos está
lleno la llamada no tiene efecto.

Inicia y transmite un número de datos igual a
UploadDatalog(comienzo, contador); contador, comenzando por el valor de
comienzo.

Almacena el registro en curso en un archivo de
datos estándar NXT. El archivo tiene el nombre
“Datannnn.RDT”, en el que ‘nnnn’ es un número
SaveNxtDatalog(); de cuatro dígitos. El firmware de RobotC buscará
el número más alto que haya en los archivos RDT
e incrementará en uno este número 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:
• Manipulación de variables tipo cadena (strings).
• Constantes y variables incorporadas.
• Depuración de código.
• Funciones matemáticas.
• Control de la Batería.
• Control mediante programación de los botones del NXT.
• Comunicación 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 más allá del ámbito de esta guía. Para obtener
información acerca de ellas se puede consultar la ayuda que proporciona RobotC a través del menú ‘Help’
de su interfaz gráfica.
Asimismo se pueden consultar los documentos que se incluyen en el apartado ‘Referencias’ de esta
guía.


17 REFERENCIAS
• Ayuda de RobotC.
• Tutorial de RobotC.
http://www.RobotC.net/
• Baum, Dave. “Guía 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. “Programación 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


Robotc guia

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (13)

Destacado

Destacado (20)

Similar a Robotc guia

Similar a Robotc guia (20)

Último

Último (20)

Robotc guia