PDF de programación - 7 - Control de comportamiento

Capítulo 7

7

Control de
Comportamiento

!, Comórtate!
Austin Powers (interpretado por Mike Myers) en la pelíula
Austin Powers: Hombre Internacional del Misterio,
New Line Cinema, 1997

Página opuesta: Mis luces de tráfico
Ilustración de Yingshun Wong (yingshun.co.uk)

107

Capítulo 7

Escribir programas es ejercitar el control. En es caso del cerebro de un robot, el
programa dirige las operaciones del robot. Sin embargo, también es importante
observar que el programa en sí mismo está realmente controlando la computadora.
Es decir, cuando escriben programas Python están controlando la computadora que
entonces se está comunicando con el robot. Si quitan a Myro de la escena están
escribiendo programas para controlar la computadora. En este sentido, el
aprendizaje con robots también lleva a aprender computación. Cada programa que
escriben está haciendo computación. Contrariamente a los preconceptos populares
acerca de la computación, ésta no se trata solamente de realizar ecuaciones con
números. Controlar el robot es también realizar computación, como también lo es
predecir la población mundial, componer una imagen, etc. Este es un aspecto del
control.
Al escribir programas para controlar los robots, la estructura que utilizan para
organizar el programa es una estrategia de control. Programar un robot significa
especificar controles automatizados. Como programadores o diseñadores de
comportamiento, ustedes estructuran su programa para lograr las metas de ese
comportamiento: cómo se utilizan los sensores para decidir qué hacer a
continuación. Este es otro aspecto del control. Hasta ahora, han visto cómo escribir
programas de control usando el estilo de cableado sensor-motor de Braitenberg.
También han visto como especificar el control reactivo. Estos son ejemplos de dos
paradigmas de control de robot.
En este capítulo ahondamos más en el mundo de la computación y los paradigmas
de control de robots. Aprenderemos cómo escribir programas de control de robot
para realizar tareas más complejas y más robustas. También veremos cómo,
usando los conceptos aprendidos hasta ahora, podemos escribir aplicaciones de
computadora útiles e interesantes.
Control basado en el comportamiento
Al escribir programas de control de robots, hasta ahora, han usando una técnica
muy básica para diseñar programas de control:
def main():
# hacer por siempre o por algún tiempo
# o hasta que se cumpla alguna condición

# sensar y transformar los valores de los sensores
# razonar y decidir qué hacer
# hacerlo!

Como habrán observado, tales programas de control funcionan bien para tareas
simples. Sin embargo, posiblemente ya se han encontrado con situaciones en las
que, una vez que la tarea se pone un poco más compleja, resulta difícil estructurar
un programa en términos de una línea de control como se muestra arriba. Por
ejemplo, el comportamiento de salida de corral del capítulo anterior les requiere
combinar dos comportamientos simples: resolver un laberinto (evitar obstáculos) y
buscar la luz para salir del corral. Como han visto antes, es relativamente sencillo
programar cada uno de los comportamientos individuales: evitar obstáculos; seguir
la luz. Pero al combinar estos comportamientos para lograr la salida del corral, dos

108

Control de Comportamiento

cosas ocurren: se ven forzados a combinar las dos estrategias de control en una
sola, y puede resultar difícil decidir de qué manera hacerlo. Además, el programa
resultante no es muy bello y es difícil de leer. En realidad, casi ningún programa de
robot se escribe de esa manera. En esta sección, veremos un modo distinto de
estructurar los programas de robot que hace más fácil el diseño de
comportamientos y además, la estructura que resulta del programa global es limpia
y directa. Pueden diseñar comportamientos muy sofisticados usando estas ideas.
La gente de la comunidad robótica llama al estilo de programación mostrado arriba
control reactivo o control directo. También se la llama fusión de sensor, y los
programas resultantes son conducidos puramente por sensores y por lo tanto son
demasiado “bottom-up", es decir, desarrollados de abajo hacia arriba. Es decir, los
valores de los sensores llevan la lógica del control en dirección opuesta a las metas
de las tareas del robot en sí mismas. En el control basado en comportamiento, uno
se aleja de los sensores y focaliza el diseño del programa de robot sobre cierta
cantidad y tipos de comportamientos que el robot puede llevar a cabo.
Veamos cómo el control basado en comportamiento nos permite diseñar el
comportamiento de salida del corral. Básicamente, el robot tiene que llevar a cabo
tres tipos de comportamientos: avanzar (en ausencia de cualquier obstáculo y/o
luz), evitar obstáculos (si están presentes), y buscar la luz (si está presente). En el
estilo de la escritura de programa basada en comportamiento, definiremos cada
uno de estos comportamientos como una unidad de decisión individual. Por lo tanto,
cada una se escribe de manera simple y directa. A continuación, el programa de
control debe fusionar los comportamientos recomendados por cada unidad de
comportamiento. Observen la imagen de abajo:

En el diagrama de arriba, hemos mostrado los tres comportamientos básicos que
estamos intentando combinar: Avanzar, Esquivar, BuscarLuz. Cada uno de estos
comportamientos da un triple: Si/No, una Velocidad de traslado,y una Velocidad de
rotación. Un Si implica que el módulo de comportamiento tiene una recomendación.
Un No implica que no la tiene. Es decir, permite la posibilidad de un comportamiento
que no tenga recomendación. Por ejemplo, en la situación de salida del corral, en
ausencia de una fuente de luz percibida por el robot, el módulo de BuscarLuz no
tendrá una recomendación. Entonces deviene en tarea del árbitro (o el módulo de
decisión) decidir cuál de las recomendaciones disponibles usar para manejar el
robot. Observen que en definitiva, para controlar el robot, todo lo que uno debe
hacer es decidir cuánto trasladar y rotar. Se pueden incorporar muchos esquemas
de arbitraje diferentes. Usaremos uno simple pero efectivo: asignarle una prioridad

109

Capítulo 7

a cada módulo de comportamiento. Luego el árbitro elige la recomendación con la
prioridad más alta. Este estilo de arquitectura de control también se denomina
arquitectura presuntiva. En la figura de arriba, hemos dibujado los módulos según
su orden de prioridad: cuanto más alto está el módulo en el esquema, mayor la
prioridad. El comportamiento más bajo, Avanzar, no requiere de ningún sensor y
siempre está presente: quiere que el robot siempre avance hacia delante.
Resolver el control basado en la combinación de comportamientos simples tiene
varias ventajas: pueden diseñar cada comportamiento individual de manera muy
sencilla; también pueden testear cada comportamiento individual agregando ese
comportamiento y viendo cómo lo lleva a cabo, Pueden agregar cualquier cantidad
de comportamientos uno sobre el otro. En el esquema de arriba el régimen de
control implica que el robot siempre avanzará hacia delante. Pero si se presenta un
obstáculo, pasará por alto el comportamiento Avanzar e intentará esquivar el
obstáculo. Sin embargo, si se detecta una fuente de luz, sobrepasará a los otros
comportamientos y se dedicará al comportamiento de buscador de luz. Lo ideal que
podemos imaginar es que todos los comportamientos estén funcionando
simultáneamente (de manera asincrónica). En esa situación, el árbitro siempre
tendrá una o más recomendaciones para adoptar basándose en la prioridad.
Desarrollemos el programa que implementa el control basado en comportamiento.
Primero, definimos cada comportamiento:
velocidadCrucero = 0.8
velocidadGiro = 0.8
umbralLuz = 80

def avanzar():
# siempre se mueve hacia adelante
return [True, velocidadCrucero, 0]

def esquivar():
# busca si hay algún obstáculo
L, R = getIR()
L = 1 - L
R = 1 - R

if L:
return [True, 0, -velocidadGiro]
elif R:
return [True, 0, velocidadGiro]
else:
return [False, 0, 0]

def buscarLuz():
L, C, R = getLight()

if L < umbralLuz:
return [True, velocidadCrucero/2.0, velocidadGiro]
elif R < umbralLuz:
return [True, velocidadCrucero/2.0, -velocidadGiro]
else:
return [False, 0, 0]

110

Control de Comportamiento

Arriba pueden ver que cada comportamiento individual es simple y fácil de leer (y
de escribir). Hay varias maneras de incorporarlos a un programa basado en
comportamiento. Aquí hay una:
# lista de comportamientos ordenados por prioridad
# (el de la izquierda es el más alta prioridad)
comportamientos = [buscarLuz, esquivar, avanzar]

def main():

while True:
T, R = arbitrar()
mover(T, R)

main()

El programa principal llama a la función de arbitraje que devuelve los comandos de
traslación y de rotación que se aplican entonces al robot. La función arbitrar es lo
suficientemente simple:
# Decidir qué comportamiento, en orden de prioridad
# recomienda para el robot
def arbitrar():

for comportamiento in comportamientos:
output, T, R = comportamiento()
if output:
return [T, R]
Es decir, requiere a cada comportamiento en orden de prioridades para ver si tiene
una recomendación. Si la tiene, ese es el grupo de comandos de motor que se
devuelve.
Realizar la siguiente actividad: Implementen en programa de arriba y vean
cómo se comporta el robot navegando y saliendo del corral. ¿Qué ocurre si cambian
la prioridad (el orden en la lista) de los comportamientos? Al escribir el programa de
arriba, hemos usado dos características Python. Las veremos a continuación.
Nombres y valores devueltos
En el capítulo 3 aprendieron que en Python los nombres pueden ser usados para
representar funciones así como números y strings. También vieron en el Capítulo 5
que las listas, e incluso las fotos o