Controla al corredor con el mouse, mantente sobre la pista y completa una vuelta en el menor tiempo posible. En las rectas podrás acelerar, pero tendrás que reducir la velocidad para controlar mejor las curvas.
Completa una vuelta a la pista en el menor tiempo posible. El mouse es tu volante y tu acelerador: aléjalo para ir más rápido y acércalo para tener control en las curvas. Si tocas el césped recibirás una penalización; si tocas la meta azul, la carrera termina.
Así funciona el juego: controla al corredor con el mouse y completa la vuelta.
Antes de comenzar a programar, organiza los elementos que necesitarás para construir el juego.
Agrega el escenario: Selecciona el fondo Racetrack Layout, donde estará la pista que recorrerá el personaje durante el juego.
Prepara el sprite: Añade el sprite Tatiana y cambia su tamaño a 35, para que pueda desplazarse por la pista sin tocar las zonas verdes.
Crea la variable: Crea la variable tiempo, que utilizaremos como cronómetro para medir cuánto tarda el jugador en completar la pista.
Crea un nuevo sprite que funcionará como la meta de llegada. Este objeto indicará el punto que el corredor debe alcanzar después de completar todo el recorrido de la pista.
Para hacerlo, ve a la opción Pintar un sprite y crea un cuadrado azul. Este nuevo objeto será la meta de llegada que el corredor deberá alcanzar al finalizar el recorrido.
Luego, ajusta el tamaño del sprite para que coincida con el ancho de la pista y quede bien alineado, sin sobresalir de sus límites. Después, ubícalo en el punto dentro de la pista donde quieras establecer la llegada, asegurándote de que el corredor pueda tocarlo al completar todo el recorrido.
Al presionar la bandera verde, fijamos la variable tiempo a 0, para que el cronómetro siempre comience desde el inicio en cada partida.
Ubica el sprite: Luego, el sprite debe ir a una posición inicial en x: -159 y: 123 cada vez que comienza el juego.
Después, hacemos que el sprite apunte siempre en la misma dirección al iniciar la partida, para que comience correctamente orientado sobre la pista.
Por último, agregamos una espera de 1 segundo antes de comenzar el movimiento, dando un pequeño tiempo de preparación antes de iniciar la carrera.
Prueba ahora: Mueve el mouse por el escenario y observa cómo el sprite gira para seguir la dirección del puntero. Por ahora, solo debe cambiar hacia dónde apunta, sin avanzar por la pista.
Siguiendo con la programación anterior, dentro del bloque por siempre, hacemos que el sprite apunte hacia el puntero del mouse. Así, el mouse funciona como un volante que indica constantemente la dirección que debe seguir el sprite mientras recorre la pista.
Luego, hacemos que el sprite avance según la distancia que existe entre él y el puntero del mouse. Para que el movimiento no sea demasiado rápido, dividimos esa distancia entre 10.
La distancia al puntero decide la velocidad: más lejos, más rápido; más cerca, mayor control.
De esta manera, el mouse también funciona como un acelerador: si el puntero está lejos, el sprite avanza más rápido; si está cerca, se mueve más despacio, logrando un control más suave durante el recorrido.
Siguiendo con la programación anterior, agregamos una condición para detectar si el sprite está tocando el pasto y se sale de la pista tocando la zona verde, cambiamos la variable tiempo en 0.5.
Nota: Salir de la pista genera una penalización y aumenta el tiempo total del recorrido.
Después, agregamos una espera de 0.1 segundos y hacemos que la variable tiempo cambie en 0.1. Así, mientras el sprite permanezca en movimiento, el cronómetro continúa avanzando de forma normal y registra el tiempo que tarda en completar la pista.
tiempo +0.1
penalización +0.5 + 0.1 → +0.6
El carro se controla con un joystick: mueves la palanca y Octabio muestra en su pantalla un punto (X, Y). El eje X indica hacia donde girar (izquierda o derecha) y el eje Y indica avanzar o retroceder.
Construirás un carro controlado por Octabio: un servomotor girará la parte delantera para variar el eje X (dirigir a la izquierda o a la derecha), y dos motores traseros harán avanzar o retroceder el carro.
En Octabio programarás cada motor: decidirás cuándo girar y cuándo avanzar o retroceder, y lo probarás moviendo el carro sobre la mesa.
Reto: ¿cómo logramos que el carro gire y avance usando los tres motores al mismo tiempo?
Así es el carro de Octabio.
Los carros robóticos giran de dos formas diferentes, según cómo estén colocadas y movidas sus ruedas.
Dos ruedas motrices, una a cada lado. Para girar, una rueda va más rápido (o en reversa) que la otra: el carro puede girar casi sin avanzar.
Las ruedas delanteras giran para dirigir, como un carro de verdad. Las traseras impulsan el carro hacia adelante o atrás.
Nuestro carro es ackerman: el servomotor delantero gira las ruedas para doblar (eje X) y los dos motores traseros lo empujan.
Tracción ackerman: las ruedas delanteras dirigen.
El carro funciona porque tres partes colaboran continuamente.
Sensor: recibe información del entorno. El sensor joystick entrega un punto (X, Y) cuando mueves la palanca.
Programa: decide si el carro avanza o retrocede y cuánto varía su ángulo de giro.
Actuador: un servomotor varía el giro de la parte delantera y dos motores traseros mueven las ruedas para avanzar o retroceder.
El sensor lee, el programa decide y el actuador actúa: mueves la palanca del joystick y el carro gira y avanza. ¡Compruébalo!
Lee el joystick (X, Y)
Decide giro y avance
Mueve el carro
Es como el joystick de tu consola de videojuegos: lo mueves hacia adelante, atrás, a la izquierda o a la derecha, y el carro sigue esa dirección.
Entrega dos valores: el eje X (izquierda o derecha) y el eje Y (adelante o atrás). Con esa posición, el programa decide cuánto girar y si avanzar o retroceder.
En Octabio Blocks se lee con el bloque del sensor joystick, y el punto (X, Y) se muestra en la pantalla de Octabio.
Es como un punto en una cuadrícula: mueves la palanca y el punto se desplaza en X o en Y.
Un servomotor permite controlar con precisión la posición angular de su eje y mantenerla estable.
Para conectarlo, usa el módulo de extensión: cable marrón a GND, rojo a +5V y naranja a P1. Luego conecta el módulo a Octabio con un cable Grove.
Los bloques de la categoría Motor permiten elegir el puerto, el ángulo, el tiempo y la forma del movimiento.
0° = ruedas rectas: el carro va derecho. 90° = ruedas giradas: el carro dobla. Es como la bicicleta: el manubrio recto te lleva derecho, y lo giras para doblar. Si tu carro dobla al revés, intercambia estos ángulos después de probar.
El servomotor se mueve hasta posiciones específicas indicando un ángulo, con un recorrido de 0° a 180°, como se muestra en la imagen.
0°: posición inicial del brazo. 90°: gira un cuarto de vuelta y levanta la tapa. 180°: posición más alejada del recorrido.
En nuestro proyecto usaremos principalmente 0° y 90°: al detectar un objeto, el servomotor va a 90° y abre la tapa; después de unos segundos regresa a 0° y la cierra.
Idea clave: el ángulo programado determina cuánto se mueve la tapa de la caneca.
Ya aprendiste lo necesario. Ahora vas a construir tu carro controlado por Octabio en 4 pasos.
Conecta primero el sensor joystick al puerto A de Octabio con un cable Grove de 4 pines. Luego, el servomotor se conecta a 3 pines del módulo de extensión, y este módulo se conecta al puerto B de Octabio con un cable Grove de 4 pines. Por último, conecta los dos motoreductores a los puertos M1 y M2 con cables Grove de 2 pines.
Tanto sensores como actuadores se conectan con cables Grove de 4 pines: alinea las guías del conector con las ranuras del módulo y de Octabio, y presiona suavemente cada extremo hasta que quede asegurado, como se muestra en las imágenes.
Verifica las conexiones: sensor joystick → puerto A, servomotor → módulo de extensión → puerto B y motoreductores → M1 y M2.
Marrón: tierra (GND) · Rojo: +5V · Naranja: señal (P1).
Antes de probar el programa, revisa la posición inicial de los engranajes.
Durante el montaje, al programar y al ejecutar, el engranaje de abajo permanece desalineado: así compruebas el buen funcionamiento observando la rotación de los engranajes.
Cuando los dos engranajes ya estén girando en direcciones contrarias con respecto al sentido de giro, ya puedes alinearlos y poner el carro en marcha. Antes no: podrías forzar la posición inicial y dañar el servomotor.
Idea clave: el movimiento óptimo de los engranajes determina el ángulo de giro correcto de las ruedas delanteras (eje X): si van desalineados, el carro no dobla bien.
Antes de comprobar la programación: engranajes desalineados.
Al ejecutar el código en Octabio: engranajes alineados.
El movimiento de la tapa depende de la rotación del engranaje pequeño:
Giro hacia la derecha, en dirección al sensor: la tapa se abre hasta 90°. Giro hacia la izquierda: la tapa regresa y se cierra.
El servomotor transmite el movimiento a los engranajes: la tapa cambia de posición según la instrucción de Octabio.
Advertencias
Programa a Octabio para que revise continuamente si hay un obstáculo cerca de la caneca.
Dentro de un bloque por siempre, lee el sensor de obstáculos conectado al puerto C: el valor lógico que lea (1 ó 0) se mostrará en el centro de la pantalla. Si el sensor detecta un objeto y su valor es igual a 1, activa el servomotor conectado al puerto B para mover la tapa hasta un ángulo de 90° durante 1 segundo.
Después, espera durante 3 segundos para permitir que la persona deposite el residuo. Al finalizar ese tiempo, mueve nuevamente el servomotor hasta 0° en 0,5 segundos, para que la tapa vuelva a cerrarse.
Antes de iniciar el ciclo, Octabio limpia la pantalla y luego repite este proceso de detección, apertura, espera y cierre de manera continua.
Puede ser una conexión floja en el módulo de extensión o que el programa controle un puerto distinto al que usaste.
Solución: revisa la conexión del servo y verifica el puerto; vuelve a subir el código.
El sensor de obstáculos debe estar conectado al puerto C; puede estar mal conectado o estar leyendo el puerto incorrecto.
Solución: verifica el puerto y observa los valores en pantalla; ajusta el umbral si hace falta.
Los ángulos están invertidos dentro del si / si no: la tapa abre cuando debe cerrar.
Solución: intercambia los ángulos de abrir y cerrar en los bloques del servo.
Terminaste la Guía 5. Ya puedes usar variables y listas para contar, recordar y organizar información en tiempo real, y construiste tu caneca.
