Estrategia y patrones para WRO RoboMission

Las reglas específicas del año vigente están en: https://wro-association.org/competition/wro-international/rulebook/

La decisión arquitectónica más grande: single-run vs multi-run

Single-run

Un programa que arranca, recorre todas las missions, y vuelve al home. Sin tocar el robot.

Pros: maximiza time bonus si funciona, menos manipulación humana.

Contras: si falla mission #3, perdés #4-#N. Error acumulado de gyro/odometría sobre 2 min puede ser >10 cm. Difícil de debuggear.

Conviene: equipos avanzados, robot muy bien calibrado, missions cercanas, mat con pocas misiones grandes.

Multi-run

El mat se divide en zonas. N programas distintos, uno por zona. Entre programas, vuelve al home, equipo cambia attachment, arranca el siguiente.

Pros: resiliente, fácil de iterar, permite squareo entre programas (resetea drift).

Contras: pierde time bonus, presión operativa para el equipo.

Conviene: equipos principiantes/intermedios, missions distribuidas.

Recomendación general para IITA: multi-run con 3-5 programas es el sweet spot. Solo equipos top con >6 meses de práctica deberían intentar single-run.

Selector de programa en el hub

hub = PrimeHub()

programs = [
    ('1', mission_north),
    ('2', mission_east),
    ('3', mission_south),
    ('4', mission_west),
    ('5', mission_center),
]

selected = 0

def show_selection():
    hub.display.text(programs[selected][0])

def program_selector():
    global selected
    show_selection()
    while True:
        pressed = hub.buttons.pressed()
        if Button.LEFT in pressed:
            selected = (selected - 1) % len(programs)
            show_selection()
            while Button.LEFT in hub.buttons.pressed(): wait(10)
        elif Button.RIGHT in pressed:
            selected = (selected + 1) % len(programs)
            show_selection()
            while Button.RIGHT in hub.buttons.pressed(): wait(10)
        elif Button.CENTER in pressed:
            while Button.CENTER in hub.buttons.pressed(): wait(10)
            hub.light.on(Color.GREEN)
            programs[selected][1]()
            hub.light.on(Color.BLUE)
            selected = (selected + 1) % len(programs)  # auto-avanzar
            show_selection()
        wait(50)

program_selector()

Ventajas: el equipo no tiene que pensar qué programa subir entre runs — el robot avanza solo.

Patrón de inicio de cada run

def start_run():
    """Llamar al inicio de cada función de mission."""
    drive.stop()
    drive.reset()
    hub.imu.reset_heading(0)
    
    # Squareo contra la pared trasera del home
    drive.use_gyro(False)
    left_motor.run(-80)
    right_motor.run(-80)
    wait(700)
    left_motor.stop()
    right_motor.stop()
    
    drive.use_gyro(True)
    hub.imu.reset_heading(0)
    drive.reset()
    drive.straight(20)  # despegar de la pared

Por qué: garantiza que el robot siempre arranca con el mismo heading absoluto sin importar cómo el equipo lo posicionó. Elimina la principal fuente de variabilidad.

Gestión de attachments

Principios de diseño

1. Mounting rápido y reproducible. Pins LEGO con tope, no encaje libre.
2. Driven por motor central (Port C). Reservar exclusivamente para attachments.
3. Auto-calibración al inicio. Cada attachment debe encontrar su zero con run_until_stalled().
4. Sin colisión con la geometría base (no mover IMU ni ruedas).

Auto-calibración con run_until_stalled()

attachment = Motor(Port.C)

def calibrate_attachment():
    """Busca su tope mecánico y resetea ángulo a cero."""
    attachment.run_until_stalled(speed=-200, then=Stop.HOLD, duty_limit=50)
    attachment.reset_angle(0)
    wait(100)

def raise_arm():
    attachment.run_target(speed=400, target_angle=90, then=Stop.HOLD)

def lower_arm():
    attachment.run_target(speed=400, target_angle=0, then=Stop.HOLD)

duty_limit=50 evita que el motor empuje con full torque contra el tope (puede romper mecánica o frenar el robot entero).

Detección de objetos de mission con ColorSensor

def detect_cube_color():
    """Avanza, detecta color del cubo, vuelve."""
    drive.straight(150)
    
    # Promediar 5 lecturas
    readings = []
    for _ in range(5):
        readings.append(color_front.color())
        wait(20)
    
    counts = {}
    for c in readings:
        counts[c] = counts.get(c, 0) + 1
    return max(counts, key=counts.get)

Tips:

• Restringir colores: color_front.detectable_colors([Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW]).
• Distancia al objeto: 5-10 mm. A 20+ mm la lectura se degrada.
• Probar contra los colores reales del set WRO, no papel impreso.

Recovery patterns

Timeout en attachment

def close_gripper_with_timeout():
    sw = StopWatch()
    sw.reset()
    attachment.run(-300)
    while attachment.speed() > -50 or sw.time() < 200:
        if sw.time() > 2000:
            attachment.stop()
            hub.light.on(Color.RED)
            return False
        wait(20)
    attachment.hold()
    return True

Verificación con sensor antes de actuar

def pickup_only_if_present():
    if us_front.distance() < 80:
        close_gripper_with_timeout()
        return True
    else:
        hub.light.on(Color.YELLOW)  # marcador visual de skip
        return False

Abort y volver al home

def return_home():
    """Volver por la ruta más directa, ignorando obstáculos.
    Mejor perder 1 mission que perder TODAS por touch penalty."""
    drive.use_gyro(True)
    drive.settings(straight_speed=400)
    drive.turn(-hub.imu.heading())
    drive.straight(-2000)  # hasta golpear pared trasera

Time management durante una ronda

Distribución óptima en 2 minutos:

Cada programa tiene ~20 segundos máximo de tiempo útil. CRÍTICO para diseñar las missions.

Pre-round checklist programático

def pre_round_check():
    errors = []
    if hub.battery.voltage() < 7500:
        errors.append('BAT')
    try:
        left_motor.angle()
        right_motor.angle()
        attachment.angle()
    except:
        errors.append('MOT')
    try:
        r = color_main.reflection()
        if r < 5 or r > 95:
            errors.append('COL')
    except:
        errors.append('COL')
    
    if errors:
        hub.light.on(Color.RED)
        hub.display.text(' '.join(errors))
        hub.speaker.beep(frequency=200, duration=500)
    else:
        hub.light.on(Color.GREEN)
        hub.speaker.beep(frequency=880, duration=100)

Errores típicos en competición

Filosofía general

1. Reliability > speed. Un robot que completa 7 missions confiables puntúa más que uno que intenta 12 y completa 4.
2. Test 10 veces antes de declarar que funciona. Si funciona 8 de 10 veces, NO funciona.
3. Documentar las calibraciones en el código.
4. Iterar el robot, no el código. Si una mission requiere código heroico, el problema es el dise del attachment.
5. Practicar handoffs. Cambio + reposicionamiento + selección debe tomar <8 segundos.
6. Llevar dos hubs cargados a competición. Si uno falla, el segundo entra. Reflashear Pybricks toma 30 seg.

Recursos

• Rulebook oficial WRO: https://wro-association.org/competition/wro-international/rulebook/
• Repos de WRO 2026 de IITA: gviollaz/wro2026-robomission-junior, gviollaz/wro2026-robomission-elementary
• Workshop Pybricks: IITA-Proyectos/iita-vibe-robotics-martes-SL
• Pybricks docs: https://docs.pybricks.com/