Sunteți pe pagina 1din 32

GUA DEL PROGRAMADOR

Para RCX y NXT NIVEL BSICO

Gustavo Zazo

NDICE
1 2 INTRODUCCIN....................................................................................................4 REGLAS LXICAS ..................................................................................................4 2.1 2.2 2.3 2.4 2.5 2.6 2.7 3 CDIGO ......................................................................................................4 SIGNOS DE PUNTUACIN..................................................................................4 ESPACIOS EN BLANCO .....................................................................................4 INSTRUCCIONES ............................................................................................5 COMENTARIOS ..............................................................................................5 COLOREADO DE CDIGO ..................................................................................6 IDENTIFICADORES Y PALABRAS RESERVADAS ..........................................................6

BLOQUES DE CDIGO ............................................................................................6 3.1 3.2 TAREAS ......................................................................................................7 FUNCIONES ..................................................................................................7

VARIABLES Y CONSTANTES ......................................................................................9 4.1 4.2 VARIABLES...................................................................................................9 CONSTANTES.............................................................................................. 10

INSTRUCCIONES GENERALES .................................................................................. 11 5.1 5.2 ASIGNACIN............................................................................................... 11 INSTRUCCIONES COMPUESTAS ......................................................................... 11

INSTRUCCIONES DE CONTROL DE FLUJO.................................................................... 12 6.1 6.1.1 6.1.2 6.1.3 6.1.4 6.2 6.2.1 6.2.2 BUCLES..................................................................................................... 12 repeat .................................................................................................. 12 while.................................................................................................... 12 do while .............................................................................................. 13 for ....................................................................................................... 13 INSTRUCCIONES DE CONDICIN........................................................................ 14 if - else ................................................................................................. 14 switch .................................................................................................. 15

INSTRUCIONES DE SALTO ...................................................................................... 16 7.1 7.2 7.3 7.4 goto ........................................................................................................ 16 return ...................................................................................................... 16 break ....................................................................................................... 16 continue ................................................................................................... 16

OPERADORES .................................................................................................... 16 8.1 8.2 8.2.1 8.2.2 8.2.3 OPERADOR DE ASIGNACIN ( = ) ...................................................................... 16 OPERADORES ARITMTICOS ............................................................................ 17 Operador (+) : Suma ................................................................................. 17 Operador (+=): Incremento ......................................................................... 17 Operador (++): Incremento en 1 ................................................................... 17 RobotC. Gua del programador

8.2.4 8.2.5 8.2.6 8.2.7 8.2.8 8.2.9 8.2.10 8.3 8.4 9

Operador (-) : Resta / Negativo ................................................................... 17 Operador (-=): Decremento......................................................................... 18 Operador (--): Decremento en 1 ................................................................... 18 Operador (*): Multiplicacin........................................................................ 18 Operador (/): Divisin ............................................................................... 18 Operador (%) : Resto ................................................................................. 18 Resumen ............................................................................................ 18

OPERADORES DE CONDICIN ........................................................................... 19 OPERADORES LGICOS .................................................................................. 19

MOTORES (Salidas) ............................................................................................. 20 9.1 9.2 CONTROL BSICO ........................................................................................ 20 CONTROL PID (NXT) ..................................................................................... 21 SENSORES (Entradas) ....................................................................................... 21 SONIDOS ...................................................................................................... 23 CONTROL DE TIEMPO ....................................................................................... 24 COMUNICACIONES ........................................................................................... 25 RCX ......................................................................................................... 25 NXT ......................................................................................................... 26 PANTALLA LCD ............................................................................................... 26 RCX ......................................................................................................... 26 NXT ......................................................................................................... 27 Funciones para texto ............................................................................. 27 Cdigos de formateo de texto en pantalla ................................................... 28 Funciones para formas geomtricas ........................................................... 29

10 11 12 13 13.1 13.2 14 14.1 14.2

14.2.1 14.2.2 14.2.3 15 15.1 15.2 16 17

REGISTRO DE DATOS (DATALOG) ......................................................................... 30 RCX ......................................................................................................... 30 NXT ......................................................................................................... 30 OTRAS FUNCIONES Y VARIABLES .......................................................................... 31 REFERENCIAS ................................................................................................. 32

RobotC. Gua del programador

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 ] m m

100

El lenguaje C (y, por tanto, RobotC, que es un derivado suyo) diferencia entre maysculas y minsculas, por lo que hay que prestar atencin cuando se escribe un programa. As, por ejemplo, wait se reconoce como una pieza del lenguaje, pero Wait no se reconoce como tal.

2.2
;

SIGNOS DE PUNTUACIN
Se emplean varios signos de puntuacin para diferentes cometidos: Fin de instruccin

( ) [ ] 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:

RobotC. Gua del programador

x=2; x = 2 ; Algunos de los operadores de C++ estn formados por mltiples caracteres. Para preservar estas piezas no se debe insertar espacio en blanco entre ellos. En el ejemplo siguiente, la primera lnea usa un operador de cambio a la derecha (>>), pero en la segunda lnea el espacio aadido hace que los smbolos > se interpreten como dos elementos separados y en consecuencia se genere un error. x = 1 >> 4; x = 1 > > 4; //dar a x el valor de 1 desplazado a la derecha 4 bits // error

El uso de espacios, tabulaciones y lneas ayuda al programador a leer el cdigo con mayor facilidad. Es muy recomendable hacer un buen uso de los espacios en blanco en un programa.

2.4

INSTRUCCIONES
Una instruccin (orden, sentencia o declaracin) es una orden directa al robot. Por ejemplo, la instruccin motor[motorC] = 100; indica al robot que ponga en marcha el motor conectado al puerto C al 100 % de potencia. Las instrucciones son ejecutadas de izquierda a derecha y de arriba abajo. RobotC reconoce las diferentes instrucciones porque la gran mayora acaban en ; , pero no porque estn en diferentes lneas. Los dos siguientes trozos de cdigo son exactamente iguales para RobotC, pero el segundo es prcticamente ilegible para un programador humano.

task main() { motor[motorC] = 100; wait1Msec(3000); }

task main(){motor[motorC ]=100;wait1Msec(3000);}

2.5

COMENTARIOS
RobotC soporta dos tipos de comentarios. El primer tipo (comentarios C tradicionales) empieza con /* y termina con */. Pueden abarcar varias lneas, pero no pueden anidarse.

/* esto es un comentario */ /* esto es un comentario de dos lneas */ /* otro comentario /* intentando anidar finalizando el comentario interior */ este texto ya no es un comentario! */ RobotC. Gua del programador 5

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() { motor[motorC] = 100; 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 case const continue default do

else false for goto if int

repeat return start stop sub switch

task true void while

3 BLOQUES DE CDIGO
Un programa en RobotC se compone de bloques de cdigo y variables globales. Hay dos tipos de bloques de cdigo: tareas y funciones en lnea. Cada tipo de bloque de cdigo tiene sus propias caractersticas y restricciones particulares, pero todos comparten una estructura comn. 6 RobotC. Gua del programador

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 programa en curso)

StopAllTasks();

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.

RobotC. Gua del programador

Las funciones RobotC siempre se expanden como funciones en lnea. Esto significa que cada llamada a una funcin hace que se incluya en el programa otra copia del cdigo de la funcin. Si no se usan con sensatez, las funciones en lnea hacen que el tamao del cdigo sea excesivo.

EJEMPLOS DE APLICACIN 1. En el siguiente ejemplo se define la funcin GiraDerecha, que luego es llamada desde la tarea principal task main. Se declara la funcin GiraDerecha (sin argumentos), que hace girar a la derecha al robot al 60 % de potencia void GiraDerecha() { motor[motorA] = 60; motor[motorC] = -60; }

Se define la tarea principal

task main () {

El robot avanza al 100 % de potencia durante 1 s

motor[motorA] = 100; motor[motorC] = 100; wait1Msec(1000);

Se llama a la funcin GiraDerecha, y el robot gira durante s Despus continua avanzando al 100 % de potencia durante 3 s

GiraDerecha(); wait1Msec(500); motor[motorA] = 100; motor[motorC] = 100; wait1Msec(3000); }

2. En este otro ejemplo la funcin GiraDerecha se declara con el argumento tiempo. Se declara la funcin GiraDerecha (con el argumento 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. void GiraDerecha(int tiempo) { motor[motorA] = 60; motor[motorC] = -60; wait1Msec(tiempo); } Se define la tarea principal task main () { El robot avanza al 100 % de potencia durante 1 s motor[motorA] = 100; motor[motorC] = 100; wait1Msec(1000);

RobotC. Gua del programador

Se llama a la funcin GiraDerecha, especificando un tiempo de 500 y el robot gira durante s Despus continua avanzando al 100 % de potencia durante 3 s

GiraDerecha (500);

motor[motorA] = 100; motor[motorC] = 100; wait1Msec(3000); }

4 VARIABLES Y CONSTANTES
4.1 VARIABLES
Los principales tipos de variables que soporta RobotC son los siguientes: TIPO DE DATOS Entero Decimal de coma flotante DESCRIPCIN Nmeros enteros positivos y negativos, incluido el cero. Valores numricos con parte decimal. Una cadena de caracteres que puede incluir nmeros, letras o smbolos. Verdadero o falso. til para expresar el resultado de una comparacin. EJEMPLOS -35, -1, 0, 33, 100, 345 CDIGO int

Una variable es un contenedor que puede almacenar un valor determinado: cantidades numricas, cadenas alfanumricas o valores booleanos.

-0.123, 0.56, 3.0, 1000.07 El contador ha llegado a 4 ALTO Hora de comer!

float

Cadena

string

Booleano

true, false

bool

Las variables se declaran usando una de las palabras reservadas int, float, string o bool seguida de una lista de nombres de variables separados por coma y terminados por un punto y coma. int x; bool conectado; Crea una variable de tipo entero llamada x Crea un variable conectado de tipo booleano llamada

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

RobotC. Gua del programador

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 o Si una variable necesita estar en posicin global, se declara como variable global. Si una variable no necesita ser global, hacer que sea lo ms local posible.

Por ejemplo:

int x;

// x es global

void aaa () { int z; } // z local declarada

task main() { int y; x = y; y = z; } // y es local de la tarea main // ok // error aqu no est definida z

task otra () { x = 1; y = 2; } // ok // error - y no es global

4.2

CONSTANTES
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.

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.

10

RobotC. Gua del programador

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 ; y = 7 ; x += y ; // asigna a x el valor 2 // asigna a y el valor 7 // 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 }).

RobotC. Gua del programador

11

{ x = 2 ; y = 7 ; }

Aunque puede no parecer muy significativo, juega un papel crucial al construir estructuras de control ms complicadas. Muchas estructuras de control requieren una instruccin sencilla como cuerpo. Usando una instruccin compuesta, la misma estructura de control se puede usar para controlar mltiples instrucciones.

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) { motor[motorA] = 100; motor[motorC] = 100; wait1Msec(1000); Este pedazo de cdigo ejecuta las instrucciones entre los corchetes cuatro veces. Dependiendo de la potencia y el tiempo, el robot podra describir un cuadrado.

motor[motorA] = 60; motor[motorC] = -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

12

RobotC. Gua del programador

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: RobotC. Gua del programador 13

task main() { int i;

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. i<20 Esta es la parte condicin. En ella se pone la condicin de que i sea menor que 20, de modo que el bucle se ejecutar mientras i sea menor que 20, es decir, mientras se cumpla la condicin. 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.

for ( i=0 ; i<20 ; i++ ) { PlaySound(soundBeepBeep); }

Como vemos, el for va delante del grupo de instrucciones a ejecutar, de manera que si la condicin es falsa, esas instrucciones no se ejecutan ni una sola vez. Se puede omitir cualquiera de las secciones (inicializacin, condiciones o incrementos). Tambin se pueden poner ms de una variable a inicializar, ms de una condicin y ms de un incremento.

6.2

INSTRUCCIONES DE CONDICIN
6.2.1 if - else

La instruccin if evala una condicin. Si la condicin es verdadera ejecuta una instruccin sencilla o compuesta (la consecuencia). Una segunda instruccin opcional (la alternativa, else) se ejecuta si la condicin es falsa. A continuacin se muestran las sintaxis posibles para una instruccin if o if else.

if (condicin) instruccin;

if (condicin) instruccin;

if (condicin) instruccin; else instruccin;

if (condicin) { cuerpo }

if (condicin) { cuerpo } 14 RobotC. Gua del programador

else { cuerpo }

Obsrvese que la condicin va encerrada entre parntesis. Vanse los ejemplos a continuacin. En el ltimo ejemplo se utiliza una instruccin compuesta para permitir que se ejecuten dos instrucciones como consecuencia de la condicin.

if (x==1) y = 2;

if (x==1) y = 3; else y = 4;

if (x==1) { y = 1; z = 2; }

6.2.2

switch

La instruccin switch sirve par elegir una opcin entre varias disponibles. No se evala una condicin que se debe cumplir sino el valor de una variable. Dependiendo del valor se cumplir un caso u otro. La sintaxis es: switch (x) { case 1 : // haz algo cuando x es 1 break; case 2 : case 3 : // haz otra cosa cuando x es 2 3 break; default : // haz esto cuando x no es ni 1, ni 2 ni 3 } Las palabras reservadas case y default no son instrucciones en s mismas sino que son etiquetas que preceden a las instrucciones. Mltiples etiquetas pueden preceder a la misma instruccin. El cdigo con switch es ms cmodo de leer que con la instruccin if else. Sin embargo switch tiene algunas limitaciones; por ejemplo, no se pueden usar condiciones en los case. RobotC. Gua del programador 15

7 INSTRUCIONES DE SALTO
7.1 goto

La instruccin goto fuerza al programa a saltar a una posicin determinada. Las instrucciones de un programa pueden ser marcadas precedindolas de un identificador y dos puntos, a lo que se llama etiqueta. La instruccin goto especifica la etiqueta a la que el programa debe saltar. goto nombre_de_etiqueta; Por ejemplo: mi_bucle: x++; goto mi_bucle; El goto slo se puede usar dentro de funciones, y no se puede saltar desde una funcin a otra. La instruccin goto debe usarse con moderacin y precaucin. En la mayora de los casos las estructuras de control tales como if, while y switch hacen los programas ms fciles de leer y modificar. // etiqueta

7.2

return

Es posible hacer que una funcin finalice antes de llegar al final de su cdigo usando la instruccin return. return;

7.3

break

Dentro de los bucles (por ejemplo, en un bucle while) la instruccin break puede utilizarse para salir del bucle. La instruccin break tambin puede utilizarse para salir de la instruccin switch. break;

7.4

continue

La instruccin continue se puede utilizar para saltar a la parte superior de la siguiente iteracin de un bucle. continue;

8 OPERADORES
Un operador sirve para manipular datos. Los hay de varios tipos: de asignacin, de relacin, lgicos, aritmticos y de manipulacin de bits.

8.1

OPERADOR DE ASIGNACIN ( = )

Sirve para dar un valor a una variable. Este valor puede ser un nmero que tecleamos directamente u otra variable: a = 3; a = b; // Se asigna a la variable a el valor 3 // Se asigna a la variable a el valor de la variable b

Podemos dar valores a varias variables a la vez:

16

RobotC. Gua del programador

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


// se incrementa en 5 el valor de x

Existe una forma abreviada para el ltimo ejemplo: x += 5;

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; // x es 6 // 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;

RobotC. Gua del programador

17

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 Suma Incremento Incremento en 1 Resta Decremento Decremento en 1

OPERADOR

NOMBRE Multiplicacin Divisin Resto

+ += ++ -= --

* / %

18

RobotC. Gua del programador

8.3

OPERADORES DE CONDICIN
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 igual que distinto a mayor que menor que mayor o igual que menor o igual que Siempre verdadero Siempre falso DESCRIPCIN se cumple si son iguales se cumple si son diferentes se cumple si el primero es mayor que el segundo se cumple si el primero es menor que el segundo se cumple si el primero es mayor o igual que el segundo se cumple si el primero es menor o igual que el segundo

Los operadores de condicin se utilizan para comprobar las condiciones de las instrucciones de control de flujo.

== != > < >= <=


true false

No slo se pueden comparar constantes, tambin se pueden comparar variables. Ejemplos: if ( a > b) while ( a<= b) while (true) if (a != b) Se cumple (devuelve un 1) si a es mayor que b Se cumple si a es menor o igual que b Se cumple siempre (bucle infinito) Se cumple si a es distinto de b

8.4

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

&& || !

Ejemplos de && (AND): if ( a==3 && b==2 ) Se cumple si a es 3 Y b es dos

RobotC. Gua del programador

19

if ( a>10 && a<100 ) if ( a==10 && b<300 )

Se cumple si a es mayor que 10 Y menor que 100 Se cumple si a es igual a 10 Y b es menor que 300

Ejemplos de || (OR): if ( a<100 || b>200 ) if ( a<10 || a>100 ) Se cumple si a es menor que 100 O b mayor que 200 Se cumple si a es menor que 10 O a mayor que 100

Se pueden poner ms de dos condiciones: if ( a>10 && a<100 && b>200 && b<500 ) Se cumple si a est entre 10 y 100 y b est entre 200 y 500

Tambin se pueden agrupar mediante parntesis varias condiciones: Esta condicin se leera como sigue: if ( ( a>10 && a<100 ) || ( b>200 && b<500 ) ) si a es mayor que 10 y menor 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: motor[motorA] = 100; Pone el motor conectado al puerto A girando hacia delante al 100% de velocidad. Pone el motor conectado al puerto C girando hacia atrs al 60% de velocidad. Para el motor conectado al puerto B.

motor[motorC] = -60; motor[motorC] = 0;

20

RobotC. Gua del programador

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 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 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

nMotorPIDSpeedCtrl[puerto_motor] = mtrSpeedReg;

nSyncedMotors = synchesclavo_maestro;

Ejemplo 1: task main() { nMotorPIDSpeedCtrl[motorA] = mtrSpeedReg; motor[motorA] = 60; } Ejemplo 2: task main() { nMotorPIDSpeedCtrl[motorA] = mtrSpeedReg; nSyncedMotors = synchAB; nSyncedTurnRatio = 100; motor[motorA] = 50; } El motor maestro es A, ajustado a una velocidad deseada de 50. El motor B (esclavo) se ajustar a su vez a la misma velocidad (100%) que el A. Se habilita el control PID del motor A y se ajusta su velocidad a 60. En caso necesario se aumentar o disminuir la potencia del motor para que gire a 60.

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.

RobotC. Gua del programador

21

Como la configuracin de sensores puede ser una tarea algo complicada, RobotC incorpora un asistente que facilita la configuracin. El asistente contiene una serie de ventanas en las que se pueden introducir los siguientes campos: 1. El nombre de la constante que se le quiere asignar al sensor (el nombre del sensor). Pueden usarse los valores numricos del puerto (S1, S2, S3 o S4), pero es una buena prctica de programacin asignar a los sensores un nombre que tenga sentido como sensorLuz, bumperIzquierdo o sonar. 2. El tipo de sensor: touch, light, sound, sonar, etc. El firmware debe conocer el tipo de sensor de tal manera que pueda configurarlo correctamente. 3. El modo del sensor. El modo ms comn es percentage (porcentaje), que normalizar el valor del sensor a una lectura entre 0 y 100. El siguiente ms comn es raw (valores en bruto), que simplemente devuelve el valor sin normalizar del sensor (de 0 a 1024). El modo del sensor se configura automticamente al elegir el tipo de sensor. Tipos de sensores y valores devueltos: TIPO DE SENSOR Raw value Valor en bruto Touch Toque Temperature (legacy) Temperatura (antiguo) Reflection (legacy) Reflexin (luz antiguo) Rotation (legacy) Rotacin (antiguo) Light active Luz activo Light inactive Luz inactivo Sound DB Sonido dB Sound DBA Sonar 9V Encoder NXT (*) Custom (sensores no fabricados por LEGO) PLATAFORMA RCX y NXT VALORES DEVUELTOS 0 a 1024 (raw)

RCX y NXT

0 o 1 (booleano)

RCX

C o F

RCX

0 a 100 ( % ) 0 a 16 (360 = 16, 90 = 4, ) 0 a 100 ( % )

RCX

NXT

NXT

0 a 100 ( % )

NXT NXT NXT NXT RCX y NXT

0 a 100 ( % ) 0 a 100 ( % ) cm al obstculo 360 = 1 vuelta Segn el sensor

Usando el asistente para configuracin de sensores y motores (Motors and Sensors Setup), RobotC genera automticamente el cdigo necesario y lo incluye al principio del programa:

22

RobotC. Gua del programador

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. Esta variable de lectura/escritura se usa para configurar el modo del sensor. Esta variable contiene la lectura actual normalizada del sensor. Esta variable contiene la lectura actual no normalizada del sensor.

SensorMode[nombre_sensor]

SensorValue[nombre_sensor]

SensorRaw[nombre_sensor]

(*) Los motores NXT incorporan un encoder (sensor que detecta el movimiento de rotacin de un eje). El encoder mide grados sexagesimales, de manera que devuelve un valor de 360 por cada giro del motor. Esto permite posicionar con mucha precisin determinados movimientos. Existe una funcin que permite leer y escribir el valor del encoder de un determinado motor: nMotorEncoder[puerto_motor]=valor; Ejemplos: while (nMotorEncoder[motorA] < 720) nMotorEncoder[motorA] = 0; Espera a que el motor A gire dos vueltas 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.

RobotC. Gua del programador

23

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 soundBlip soundDownwardTones soundException soundFastUpwardTones soundLast soundLowBuzz soundLowBuzzShort soundShortBlip soundUpwardTones

Ejemplos de aplicacin: PlaySound(soundBeepBeep); PlayTone(440, 10); PlaySoundFile(hola.rso); // reproduce el sonido BeepBeep // reproduce un tono de 440 Hz durante 1 s // 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

24

RobotC. Gua del programador

wait10Msec(centsimas_de_segundo); time1[cronmetro] time10[cronmetro] time100[cronmetro] ClearTimer(cronmetro);

unidades especificadas: milsimas o centsimas de segundo.

Almacena el valor del cronmetro especificado: T1, T2, T3 o T4. El valor puede ser obtenido en unidades de 1, 10 o 100 milisegundos.

Pone a cero el cronmetro especificado.

Ejemplos: motor[motorC] = 100; wait1Msec(1000); wait10Msec(1000); if (time1[T1] = 3000) Pone el motor C en marcha durante 1s. Despus contina con la ejecucin del programa. Espera 10 s antes de seguir con la ejecucin del programa. Ejecuta las instrucciones si el valor del cronmetro T1 es igual a 3 s (3000 milisegundos). Ejecuta las instrucciones mientras el valor del cronmetro T2 sea menor que 2 s (20 dcimas de segundo). Pone a cero el cronmetro T3.

while (time100[T2] < 20) ClearTimer(T3);

13 COMUNICACIONES
13.1 RCX
El RCX puede enviar y recibir mensajes simples utilizando los infrarrojos para comunicarse con otro RCX. Un mensaje puede tener un valor desde 1 hasta 255. El ltimo mensaje recibido es guardado y puede accederse a l mediante la variable message(). Si no ha sido recibido ningn mensaje, message()devolver el valor 0. Debe tenerse en cuenta que, debido a la naturaleza de la comunicacin mediante infrarrojos, no se podrn recibir mensajes mientras un mensaje se est transmitiendo. Funciones y variables: Enva un mensaje de 1 byte a travs del canal infrarrojo del RCX. ID_mensaje debe estar entre 1 y 255. ClearMessage(); Borra el buffer de mensajes. A partir de esta orden el RCX puede recibir nuevos mensajes. Variable que contiene el valor (1 a 255) del ltimo mensaje no procesado y recibido por el RCX.

sendMessage(ID_mensaje);

message()

Ejemplos: sendMessage(1); RobotC. Gua del programador Enva el mensaje identificado como 1. 25

if (message == 3) motor[motorA]= 100; while (message == 0)

Si el mensaje recibido est identificado con el 3 pone en marcha el motor A. 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. sendMessageNew(ID_mensaje); ID_mensaje debe de estar entre -32767 y 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. Idntica a la anterior, pero el mensaje contiene tres valores de 16 bits. Variable que contiene el valor del mensaje recibido. Matriz que adicionales. contiene los valores optativos

sendMessageWithParm(nmero_mensaje, nParm1, nParm2); message()

messageParm() 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.

SetUserDisplay(valor ,precisin);

Muestra en la pantalla un valor (una cifra, una constante o el valor de una variable) con la precisin especificada.

La precisin puede ser: TPrecision0 TPrecision1 26 Ninguna cifra decimal Una cifra decimal RobotC. Gua del programador

TPrecision2 TPrecision3 Ejemplos:

Dos cifras decimales Tres cifras decimales

SetUserDisplay(SensorValue(luz),TPrecision0);

Muestra la lectura del sensor luz, expresndolo como un nmero entero. Muestra el valor del cronmetro T1, expresndolo con una cifra decimal. Muestra el valor de la variable x, expresndolo con tres cifras decimales.

SetUserDisplay(T1, TPrecision1);

SetUserDisplay(x,TPrecision3);

14.2 NXT
El NXT est equipado con una pantalla monocroma LCD de 100 pxeles de ancho por 64 pxeles de alto. La esquina inferior izquierda es el punto (0,0) y la esquina superior derecha es el punto (99, 63). RobotC tiene un completo conjunto de funciones para mostrar texto y diferentes formas geomtricas en la pantalla LCD.

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: Si se escribe este cdigo nxtDisplayString(0,"Hola mundo"); aparece en la pantalla:

Hola mundo
27

RobotC. Gua del programador

nxtDisplayString(3,"El valor es %d,entero"); nxtDisplayString(6,Sensor es %03d,SensorValue[S1]); nxtDisplayString(2,%2d %3.2f,aaa, BBB);

El valor es 8 Sensor es 038 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] [.precisin] tipo

Indica el nmero de caracteres que ocupar el nmero o cadena. Indica cuantas posiciones decimales tendr el nmero. Indica el tipo de variable: d (entero), f (floating), s (cadena).

28

RobotC. Gua del programador

Ejemplos: ENTEROS %d Ejemplo int x = 7;

La rutina de formato simplemente calcula el ancho de la variable. El elemento tendr 6 caracteres de largo. Estar alineado a la derecha y se rellenarn con espacios en blanco el resto. Los 6 caracteres incluyen - para 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 6 caracteres. Igual que %6d pero se incluir el smbolo de signo (+ o -).

7 7 000007 +00007

%6d

%06d %+6d

DECIMALES DE COMA FLOTANTE %f

Ejemplo float y = 12.34;

Se representa el valor alineado a la izquierda. Por defecto se representan 6 cifras decimales. El elemento tendr 5 caracteres de largo (sin incluir el punto decimal), y 3 de ellos sern decimales

12.340000

%5.3f

12.340

14.2.3 Funciones para formas geomtricas


Las funciones que incorpora RobotC para dibujar en la pantalla son: nxtSetPixel(x, y); Dibuja un punto en la posicin de coordenadas (x,y). Borra el punto en la posicin de coordenadas (x,y). Dibuja una lnea entre los puntos(x1, y1) y (x2, y2). Dibuja una circunferencia desde las coordenadas (Izda,Arriba) con el Dimetro especificado. Dibuja un rectngulo vaco definido por las coordenadas (Izda, Arriba, Derecha, Abajo). Dibuja un rectngulo relleno definido por las coordenadas (Izda, Arriba, Derecha, Abajo). Borra una zona rectangular de la pantalla definida por las coordenadas (Izda, Arriba, Derecha, Abajo).

nxtClearPixel(x, y);

nxtDrawLine(x1, y1, x2, y2);

nxtDrawCircle(Izda, Arriba, Dimetro);

nxtDrawRect(Izda,Arriba,Derecha,Abajo);

nxtFillRect(Izda,Arriba,Derecha,Abajo);

nxtEraseRect(Izda,Arriba,Derecha,Abajo);

RobotC. Gua del programador

29

nxtDrawEllipse(Izda,Arriba,Derecha,Abajo);

Dibuja una elipse vaca inscrita en el rectngulo definido por las coordenadas (Izda, Arriba, Derecha, Abajo). Dibuja una elipse rellena inscrita en el rectngulo definido por las coordenadas (Izda, Arriba, Derecha, Abajo). Borra una zona elptica inscrita en el rectngulo definido por las coordenadas (Izda, Arriba, Derecha, Abajo). Muestra un archivo ICON en el punto especificado por las coordenadas (x,y).

nxtFillEllipse(Izda,Arriba,Derecha,Abajo);

nxtEraseEllipse(Izda,Arriba,Derecha,Abajo);

nxtDisplayIconFile(x, y, nombre_archivo)

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 tamao de 0 elimina el anterior sin crear uno nuevo. Aade el valor x, que puede ser una expresin, al registro de datos. Si el registro de datos est lleno la llamada no tiene efecto. Inicia y transmite un nmero de datos igual a contador, comenzando por el valor de comienzo.

CreateDatalog(tamao);

AddToDatalog(x);

UploadDatalog(comienzo, contador);

15.2 NXT
Los datos se almacenan en la RAM. Despus pueden ser copiados en un archivo flash del NXT. No se almacenan en tiempo real en el archivo flash porque se invertiran entre 3 y 6 milisegundos en la operacin, lo que podra perturbar la ejecucin del programa. Hay utilidades en la interfaz de RobotC para importar el registro y mostrarlo en una ventana del PC. Se encuentran en debug display y en NXT -> Files Management.

30

RobotC. Gua del programador

CreateDatalog(tamao);

Crea un registro de datos del tamao especificado (que debe ser constante). Un tamao de 0 elimina el anterior sin crear uno nuevo. Aade el valor x, que puede ser una expresin, al registro de datos. Si el registro de datos est lleno la llamada no tiene efecto. Inicia y transmite un nmero de datos igual a 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 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.

AddToDatalog(x);

UploadDatalog(comienzo, contador);

SaveNxtDatalog();

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.

RobotC. Gua del programador

31

17 REFERENCIAS
Ayuda de RobotC. Tutorial de RobotC. http://www.RobotC.net/ Baum, Dave. Gua del programador de NQC. http://www.elo.utfsm.cl/~mindstorm/documentos/manuales/NQC_Programmer_s_Guide_2.5Dave_Baum%5BES%5D.pdf Overmars, Mark. Programacin de robots Lego usando NQC. http://people.cs.uu.nl/markov/lego/tutorial.pdf http://www.brickshelf.com/gallery/inaki/Doks/Castellano/nqcovsp.pdf Schueller, Albert W.. Programming with Robots carrot.whitman.edu/Robots/notes.pdf Conversor de formato wav a rso. http://mikrobot.blogspot.com/2008/10/sofware-for-convert-wav-to-rso-nxt.html Urrutia, Gorka. Curso de C. http://www.elrincondelc.com/cursoc/cursoc.html

32

RobotC. Gua del programador

S-ar putea să vă placă și