Documentation
Estructuras de programación
Descripción
Instrucciones básicas
Estructuras de programación
- comentario
- bucles
- estructuras condicionales
- procedimientos
- final
Los scripts de ejemplo

Estructuras de programación

Aquí encontrarás las estructuras gramaticales que permiten definir el comportamiento del robot:

Comentario

# texto libre que no se evalúa

Todo texto que aparezca después del simbolo '#' no se interpretará como instrucción. El robot procederá con la siguiente línea en el script. Utiliza esta función para hacer anotaciones sobre partes del script como nota recordatoria para ti mismo sobre cómo algo funciona.

Bucles

repetir(n){...instrucciones...}
repite las instrucciones entre las {llaves} exactamente n veces.

Ejemplo:

# un cuadrado de 2x2
repetir(4)
{
	adelante(2)
	derecha()
}
                  

repetir(){...instrucciones...}
repite las instrucciones entre las {llaves} indefinidamente.

Ejemplo:

# avanza hacia adelante indefinidamente
# (aunque al final se quedará golpeando la pared)
repetir()
{
	adelante()

}

repetirmientras(condición){...instrucciones...}
repite las instrucciones entre las {llaves} siempre y cuando la condición se cumpla. La condición debe ser siempre una instrucción básica de percepción (consulta la sección sobre instrucciones básicas) (por ejemplo frenteEsClaro())

Ejemplo:

# continúa hacia adelante 
# pero se para cuando no puede continuar
repetirMientras(frenteEsClaro)
{
	adelante(1)

}

Interrupción

Te permite interrumpir un bucle (por ejemplo: repetir()sección) y asi dejar de realizar las instrucciones entre las llaves. El robot reanudará la realización de las instrucciones que queden después del la llave de cierre del bucle.

Ejemplo:

# sigue hacia adelante, hasta que no pueda avanzar más
repetir()
{
	si(frenteEsObstáculo())	{	
		interrumpir
	}
	sino
	{	
		adelante(1)
	}
}
                  

If-structures

si(condición){...instrucciones...}
El robot realizará las instrucciones entre {llaves} si la condición se da. Si la condición no se da, el robot seguirá realizando las instrucciones que se encuentren inmediatamente después de la llave de cierre del bucle. La condición debe ser una instrucción de percepción (consulta la sección sobre instrucciones básicas). (por ejemplo frenteEsClaro())

Ejemplo:

# si ves pintura blanca a tu izquierda, pintar de negro
si(izquierdaEsBlanco())
{
	izquierda()    
	adelante(1)
	pintarNegro()
	detenerPintar()
	hacia atras(1)
	derecha()
}
                  

si(condición){...instrucciones...}sino{...instrucciones...}
El robot realizará las instrucciones entre el primer par de {llaves} si la condición existe. Las instrucciones entre las segundas {llaves} o bloque sino (segunda instrucción) no se realizarán. Cuando la condición no existe, el robot realizará entonces las instrucciones del bloque sino (segunda instrucción). Una vez que haya realizado una de las dos instrucciones, continuará realizando las instrucciones que se encuentren después de la última llave. La condición debe ser una de las instrucciones básicas de percepción(consulta la sección de instrucciones básicas) (por ejemplo frenteEsClaro())

Ejemplo:

# si ves pintura blanca a la izquierda, pintar de negro
# sino avanza unos pasos hacia adelante
si(izquierdaEsBlanco())
{
	izquierda()    
	adelante(1)
	pintarNegro()
	detenerPintar()
	hacia atras(1)
	derecha()
}
sino
{
	adelante(3)
}
                  

Expresiones
lógicas

Llamamos expresiones lógicas a las condiciones si y repetir si. Estas expresiones resultarán en un valor verdadero o falso, que determinarán la reanudación de la ejecución en la parte apropiada del script.

Una expresión lógica puede ser una instrucción de percepción (consulta la sección de instrucciones básicas), por ejemplo: (izquierdaEsBlanco())). Instrucciones básicas también pueden estar compuestas de conectivas lógicas (álgebra de Boole) no, y, o (~, &, |).

Ejemplo:

si(izquierdaEsBlanco())
{
    izquierda()    
    adelante(1)    
}

Al usar una (o una combinación) de las siguientes operaciones, podremos refinar aún más la condición para indicar con mayor precisión cuándo se deben ejecutar las instrucciones correspondientes:

Operación
Notación alternativa
Número de
argumentos
Descripción
no ~ 1

Niega el valor del argumento:

Tabla de valores de verdad:
~ no verdadero = falso
~ no falso = verdadero

Ejemplo:
~ no frenteEsClaro()

y & 2

Sólo es verdadero cuando los dos argumentos son verdaderos.

Tabla de valores de verdad:
verdadero & verdadero = verdadero
verdadero & falso = falso
falso & verdadero = falso
falso & falso = falso

Ejemplo:
frenteEsClaro() & derechaEsBlanco()

o | 2

Verdadero cuando al menos uno de los argumentos lo es.

Tabla de valores de verdad:
verdadero | verdadero = verdadero
verdadero | falso = verdadero
falso | verdadero = verdadero
falso | falso = falso

Ejemplo:
frenteEsClaro() | derechaEsBlanco()

Los valores verdadero y falso también pueden ser aplicados directamente como si fuesen una instruccion de percepción.

El orden en que las operaciones ocurrent es importante ( tal como lo es cuando se multiplica y suma). La operación no (~) es la más fuerte, seguida de y (&), y por último o (|). Se pueden usar paréntesis para influenciar el orden de la evaluación.

Ejemplos:

				
repetirmientras(no frenteEsClaro() y (izquierdaEsBlanco() o derechaEsBlanco())){
    adelante(1)
}

si(lanzarMoneda() y no derechaEsBlanco())
{
    derecha()
    atras(1)
}

si(verdadero y falso){
    # esta instruccion no se ejecuta nunca
    adelante(1)
}
              

Procedimiento

procedimientonombre(par1, par2, ... , parN){...instrucciones...}
Define un nuevo procedimiento con el nombre que tu le quieras dar. El procedimiento puede tener cero o más parámetros, a los cuales también puedes nombrar. En nuestro ejemplo se llaman par1, par2, . . . , parN. Estas son las variables que puedes usar en las instrucciones entre llaves. El script del procedimiento no se ejecutará automáticamente, sino que tendrás que escribir una "llamada" de procedimiento cada vez que desees ejecutar las instrucciones del nuevo procedimiento (consulta la próxima instrucción).
Consejo: crea un nuevo procedimiento cuando quieras usar una secuencia de instrucciones en más de una ocasión.

Ejemplo:

# define como dibujar un rectángulo
procedimiento rectángulo(anchura, altura)
{
	pintarBlanco()
	repetir(2)
	{
		adelante(altura)
		derecha()
		adelante(anchura)
		derecha()
	}
	detenerPintar()
}
                  

nombre(arg1, arg2, . . . , argN)
es la "llamada" de procedimiento que debes escribir y usar cada vez que quieras ejecutar el nuevo procedimiento creado, con el nombre correspondiente y tantos parámetros como argumentos haya en el procedimiento. El argumento, aqui llamado arg1, arg2, ..., argN, son los valores particulares que se usaran en la definición del procedimiento.

Ejemplo:

# las instrucciones siguientes se ejecutarán:
adelante(1)
rectángulo(3,2) # una llamada al procedimiento 'rectángulo'
adelante(3)
rectángulo(1,4) # otra llamada con otros argumentos


# esta es la definición de 'rectángulo'
procedimiento rectángulo (anchura, altura)
{
	pintarBlanco()
	repetir(2)
	{
		adelante(height)
		derecha()
		adelante(width)
		derecha()
	}
	pararPintar()
}                  

Final

Final
Esta instrucción hará que todo el programa se detenga cuando este comando se lleve a cabo.

Ejemplo:

# parar después de 5 pasos, o antes si encuentra una baliza a la derecha
repetir(5)
{
	adelante(1)
	si(derechaEsBaliza())
	{
		final # detiene la ejecución del programa
	}
}
# normal fin del programa
                  
RoboMind - Copyright © 2005 - 2014 - Research Kitchen