|
|
Robobo: Motores de las Ruedas
Introducción
Robobo dispone de un motor independiente para cada una de las dos ruedas con las que gira y se desplaza, situados como se muestra en esta figura:
Robobopy dispone de 4 métodos para controlar el movimiento de las ruedas:
- Mover las ruedas durante un periodo de tiempo (moveWheelsByTime)
- Mover las ruedas una cantidad de grados de giro (moveWheelsByDegrees)
- Mover la ruedas de forma constante (moveWheels)
- Parar las ruedas (stopMotors)
También dispone de 2 métodos asociados a los sensores que dan la posición de las ruedas (encoders):
- Medir la posición de la rueda (readWheelPosition)
- Reiniciar la posición de la rueda (resetWheelEncoders)
A continuación vamos a explicar qué hace cada uno de estos métodos, los parámetros de que soporta y pondremos también un programa de ejemplo que podrás probar. Pero antes debes conocer las abreviaturas que usan, y una propiedad fundamental de algunos métodos de Robobo:
Abreviaturas para nombrar las ruedas
A la hora de hacer referencia a una rueda en concreto o a ambas en los programas, se emplean estas abreviaturas:
- R: Rueda derecha.
- L: Rueda izquierda.
- Both: Ambas ruedas.
Modo bloqueante y no bloqueante
Lo métodos de Robobo permiten, en la mayoría de los casos, dos modos de ejecución, bloqueante y no bloqueante:
- Una instrucción es bloqueante cuando evita que se ejecute la siguiente hasta que haya finalizado completamente.
- Una instrucción es no bloqueante cuando permite que se ejecute otra al mismo tiempo.
Estos dos modos de ejecución quedarán más claros en los ejemplos que irás viendo a lo largo de los cuadernos, pero es importante que te suenen desde ahora.
moveWheelsByTime(rSpeed, lSpeed, duration, wait=True)
Función: Mueve las ruedas de Robobo durante el tiempo especificado, cada una a la velocidad especificada.
Parámetros:
- rSpeed (int): Factor de velocidad para la rueda derecha. El rango de valores permitidos está entre -100 y 100. El valor absoluto de 100 representa la máxima velocidad que la rueda puede alcanzar, mientras que 0 representa que la rueda no se mueve. Los valores positivos mueven la rueda hacia delante y los valores negativos hacia atrás.
- lSpeed (int): Factor de velocidad para la rueda izquierda. El rango de valores permitidos está entre -100 y 100. El valor absoluto de 100 representa la máxima velocidad que la rueda puede alcanzar, mientras que 0 representa que la rueda no se mueve. Los valores positivos mueven la rueda hacia delante y los valores negativos hacia atrás.
- duration (float): Duración del movimiento en segundos. Se permiten valores positivos.
- wait (boolean): Indica si este método se ejecuta en modo bloqueante o no (True: modo bloqueante, False: modo no bloqueante). Si no se especifica nada, será bloqueante por defecto.
Las siguientes imágenes representan el efecto que se logra al aplicar valores positivos y/o negativos a cada rueda con respecto al movimiento total del robot:
|
|
|
|
Para probar este primer método, debes tener abierto RoboboSim y un mundo cargado, por ejemplo, "Four Walls". Cuando lo hayas hecho, ejecuta el siguiente bloque de código, que importa las librerías necesarias (fíjate que para poder mover las ruedas en tus programas, debes importar un módulo específico de la librería robobopy, denominado Wheels), crea el objeto "rob" de la clase Robobo y se conecta al simulador:
#Importamos las librerías, creamos el objeto de la clase Robobo y nos conectamos al simulador
from robobopy.Robobo import Robobo
from robobopy.utils.Wheels import Wheels
rob = Robobo("localhost")
rob.connect()
Una vez preparado todo, ya podemos mover al robot. Ejecuta ahora esta instrucción y observa lo que ocurre en RoboboSim:
rob.moveWheelsByTime(50, 50, 2)
El robot se ha movido hacia delante durante 2 segundos, ¿verdad?. Prueba ahora la siguiente:
rob.moveWheelsByTime(-50, -50, 2)
Como ves, ahora se ha movido hacia atrás. Finalmente, puedes probar otras combinaciones de velocidad en las ruedas y tiempo, para que veas lo que ocurre, por ejemplo:
rob.moveWheelsByTime(60,40,3)
En todas estas instrucciones no hemos especificado nada en el cuarto parámetro, por lo que se asume wait=True, y la ejecución es bloqueante, lo que quiere decir que el robot no puede hacer nada más hasta que termine el movimiento.
moveWheelsByDegrees (wheel, degrees, speed)
Mueve las ruedas de Robobo en función de los grados de giro especificados. Permite establecer la velocidad y los grados de giro de la rueda derecha, la rueda izquierda o ambas.
Parámetros:
- wheel (Wheels): Rueda o ruedas a mover.
- degrees (int): Ángulo de giro de la rueda medido en grados. Toma valores positivos. Hay que tener en cuenta que una vuelta completa de la rueda son 360 grados.
- speed (int): Factor de velocidad de giro que se aplica al motor de la rueda seleccionada. El rango de valores permitidos para la velocidad está entre -100 y 100. El valor absoluto de 100 representa la máxima velocidad que la rueda puede alcanzar, mientras que 0 representa que la rueda no se mueve. Los valores positivos mueven la rueda hacia delante y los valores negativos hacia atrás.
En el mismo mundo "Four Walls", reinicia la posición de Robobo, y ejecuta la siguiente instrucción que mueve ambas ruedas 360 grados a una velocidad de 30:
rob.moveWheelsByDegrees(Wheels.BOTH, 360, 30)
Si es necesario, ejecuta de nuevo la instrucción anterior y observa que realmente las ruedas dan una única vuelta. A continuación prueba de nuevo el método con esta combinación de valores que girará 180 grados solo la rueda izquierda a una velocidad de -30:
rob.moveWheelsByDegrees(Wheels.L, 180, -30)
Y por último, prueba esta combinación que girará 180º la rueda derecha a una velocidad de 50:
rob.moveWheelsByDegrees(Wheels.R, 180, 50)
El método moveWheelsByDegrees se ejecuta siempre en modo bloqueante, por lo que el robot nunca podrá hacer otra cosa a la vez.
moveWheels (rSpeed, lSpeed)
Función: Mueve las ruedas de Robobo. Este método permite establecer la velocidad de cada rueda. El movimiento se realizará de forma indefinida hasta que sea detenido con el método stopMotors o con otra instrucción de las anteriores que envíe un nuevo comando de movimiento.
Parámetros:
- rSpeed (int): Factor de velocidad de giro del motor de la rueda derecha. El rango de valores permitidos está entre -100 y 100. El valor absoluto de 100 representa la máxima velocidad que la rueda puede alcanzar, mientras que 0 representa que la rueda no se mueve. Los valores positivos mueven la rueda hacia delante y los valores negativos hacia atrás.
- lSpeed (int): Factor de velocidad de giro del motor de la rueda izquierda. El rango de valores permitidos está entre -100 y 100. El valor absoluto de 100 representa la máxima velocidad que la rueda puede alcanzar, mientras que 0 representa que la rueda no se mueve. Los valores positivos mueven la rueda hacia delante y los valores negativos hacia atrás.
El método moveWheels se ejecuta siempre en modo no bloqueante, por lo que este movimiento arranca y el robot ejecutaría de manera inmediata la siguiente instrucción hasta que se vuelva a enviar un comando a las ruedas. Si esto no se hace, el movimiento sería infinito. Por este motivo, para mostrar un ejemplo de este método que se ejecute en un tiempo controlado, debemos explicar dos métodos previamente, stopMotors y wait:
stopMotors()
Función: Detiene el movimiento de ambas ruedas.
wait(time)
Este método no es exclusivo de los motores de las ruedas, pero nos hará falta para probar el método moveWheels adecuadamente, por lo que aprenderemos a usarlo aquí.
Función: Es un retardo para la ejecución del código. El tiempo time está en segundos
Usando el mismo mundo "Four Walls", reinicia la posición de Robobo y prueba las siguientes instrucciones, que hacen que ambas ruedas avancen a una velocidad de 15, la ejecución del programa se pause durante 2 segundos, y después se paren los motores:
rob.moveWheels(15,15)
rob.wait(2)
rob.stopMotors()
Como ves, estas 3 instrucciones tienen el mismo efecto que el método moveWheelsByTime, pero ya iremos viendo que moveWheels nos permite programar el movimiento del robot de una forma más autónoma, dependiendo de lo que ocurre en el entorno (sensores) y no solo del tiempo, por lo que es un método muy importante.
readWheelPosition(wheel)
Función: Lee la posición actual de la rueda especificada (en grados)
Parámetros:
- wheel (Wheels): La rueda de la que se lee la posición. Se puede escoger entre Wheels.L (rueda izquierda) o Wheels.R (rueda derecha).
Devuelve:
- La posición de la rueda en grados (int).
Podemos probar este método ejecuntando estas 3 instrucciones, en las que se crean 2 variables, se almacena en ellas el valor devuelto por el sensor, y se imprimen por pantalla:
Grados_L=rob.readWheelPosition(Wheels.L)
Grados_R=rob.readWheelPosition(Wheels.R)
print(f"Los grados de las ruedas L y R son {Grados_L} y {Grados_R}")
resetWheelEncoders()
Función: Reinicia los sensores que miden la posición de la rueda (en grados). Estos sensores se suelen denominar codificadores de eje o "encoders".
A continuación, podemos observar el efecto que tiene reiniciar el encoder de las ruedas:
rob.resetWheelEncoders()
print("Enconders reiniciados")
Grados_L=rob.readWheelPosition(Wheels.L)
Grados_R=rob.readWheelPosition(Wheels.R)
print(f"Los grados de las ruedas L y R tras el reinicio son {Grados_L} y {Grados_R}")
Y por último, una vez finalizada la ejecución paso a paso en este cuaderno, se recomienda desconectar el robot:
rob.disconnect()
EJERCICIO 1-a
Cargar el mundo AVOID FALLING del programa RoboboSim y escribir un código que haga que el robot llegue a la línea de meta (la sección amarilla) sin chocar con los obstáculos utilizando cualquiera de las funciones para mover las ruedas que hemos visto antes.
Hay muchas combinaciones de movimientos que resuelven esta tarea, pero te recomendamos hacerlo con el menor número de movimientos posibles.
(*)Antes de abrir el mundo, hay que desmarcar la opción "Comportamiento aleatorio de Mundos" en Opciones.
#INSERTAR CÓDIGO AQUÍ
EJERCICIO 1-b
Ahora realiza el mismo ejercicio pero en el mapa SIMPLE MAZE, de forma que Robobo se acerque al cilindro rojo con el menor número de movimientos posibles.
#INSERTAR CÓDIGO AQUÍ
EJERCICIO 2
En el mundo FOUR WALLS, utiliza únicamente las funciones moveWheels() y wait() para que el robot se mueva como si estuviera trazando un número en formato BCD (segmentos en rojo). Selecciona el número que prefieras y haz el programa teniendo en cuenta que debes hacer movimientos rectos y giros de 90º.
#INSERTAR CÓDIGO AQUÍ
EJERCICIO 3
Carga el mundo FOUR WALLS, y mediante el método moveWheelsByDegrees(), recrea el siguiente recorrido. Trata de que los giros sean sigan trayectorias curvas, no hagas giros de 90º. Trata de utilizar el menor número de movimientos posible.
#INSERTAR CÓDIGO AQUÍ
EJERCICIO 4
Carga el mundo FOUR WALLS y , mediante los comandos moveWheelsByTime o moveWheelsByDegres, realiza un recorrido que haga que el robot se mueva "dibujando" un polígono de los siguientes:
#INSERTAR CÓDIGO AQUÍ