RoboCup Junior Rescue Line — robot de rescate

Setup hardware típico

• 2 ColorSensor apuntando al piso, separados ~3-4 cm para line following + detección lateral.
• 1 ColorSensor frontal ligeramente elevado para detectar el marcador plateado de la zona de evacuación.
• 1-2 UltrasonicSensor o ToF para detectar obstáculos y paredes en la zona de evacuación.
• 1 mecanismo de garra/cuchara (motor C) para levantar las víctimas.
• IMU del Prime Hub para mantener heading después de gaps y obstáculos.

Arquitectura de software

rescue/
├── main.py
├── line_follower.py        ← Edge follower con PID + detección de marcadores
├── junction_handler.py     ← Lógica de intersecciones por color
├── gap_recovery.py         ← Recuperación cuando se pierde la línea
├── obstacle_avoidance.py   ← Esquivar y volver
├── ramp_handler.py         ← Detección y manejo de rampas
└── evacuation/
    ├── victim_search.py    ← Búsqueda de víctimas en el cuarto
    ├── victim_classifier.py ← Plateada vs negra
    └── deposit.py          ← Llevar al triángulo de evacuación

Line following adaptado para RCJ

Diferencia clave con line following genérico: el robot tiene que detectar simultáneamente la línea, los marcadores verdes, los gaps, y los obstáculos. La función del loop principal no es solo "seguir la línea" sino "decidir qué hacer en cada tick".

from pybricks.parameters import Color

color_left = ColorSensor(Port.E)   # primary line follower
color_right = ColorSensor(Port.F)  # detecta marcadores verdes y gaps

KP = 0.8
KD = 4.0
BASE_SPEED = 200

WHITE = 90
BLACK = 8
GREEN_HUE_RANGE = (90, 150)  # rango HSV del verde del marcador

def is_green(sensor):
    """Detecta marcador verde por HSV (más robusto que color())."""
    h, s, v = sensor.hsv()
    return GREEN_HUE_RANGE[0] < h < GREEN_HUE_RANGE[1] and s > 40 and v > 30

def main_loop():
    last_error = 0
    while True:
        l_refl = color_left.reflection()
        r_refl = color_right.reflection()
        
        # 1. Check rampa
        pitch = hub.imu.tilt()[0]
        if abs(pitch) > 10:
            handle_ramp(pitch)
            continue
        
        # 2. Check obstáculo enfrente
        if us_front.distance() < 80:
            avoid_obstacle()
            continue
        
        # 3. Check marcador verde (intersección señalizada)
        if is_green(color_left) or is_green(color_right):
            handle_green_marker()
            continue
        
        # 4. Check intersección plateada (zona de evacuación)
        if is_silver(color_front):
            enter_evacuation_zone()
            return
        
        # 5. Check gap (todo blanco)
        if l_refl > 70 and r_refl > 70:
            recover_from_gap()
            continue
        
        # 6. Line following normal
        error = l_refl - SETPOINT
        derivative = error - last_error
        last_error = error
        turn_rate = KP * error + KD * derivative
        drive.drive(BASE_SPEED, turn_rate)
        wait(20)

Manejo de marcadores verdes

Los marcadores verdes preceden las intersecciones e indican qué dirección tomar:

• Verde a la izquierda → girar a la izquierda
• Verde a la derecha → girar a la derecha
• Verde a ambos lados → girar 180°

def handle_green_marker():
    """Detecta cuántos verdes hay y gira en consecuencia."""
    drive.straight(30)  # avanzar para confirmar la intersección
    
    left_green = is_green(color_left)
    right_green = is_green(color_right)
    
    drive.straight(50)  # avanzar al centro de la intersección
    
    if left_green and right_green:
        drive.turn(180)
    elif left_green:
        drive.turn(-90)
    elif right_green:
        drive.turn(90)
    
    # Después del giro, retomar line following
    # El robot está sobre o cerca de la nueva línea

Recuperación de gaps

Cuando los dos sensores ven blanco simultáneamente, hay un gap. El robot debe avanzar a ciegas en línea recta hasta encontrar la línea de nuevo.

def recover_from_gap():
    """Avanza recto hasta GAP_MAX_DISTANCE buscando la línea."""
    GAP_MAX_DISTANCE = 250  # mm
    drive.use_gyro(True)
    initial_heading = hub.imu.heading()
    drive.reset()
    
    while drive.distance() < GAP_MAX_DISTANCE:
        # Mantener heading absoluto
        error = hub.imu.heading() - initial_heading
        drive.drive(150, -error * 2)
        
        # Check si recuperamos la línea
        if color_left.reflection() < 30 or color_right.reflection() < 30:
            drive.stop()
            return True
        wait(20)
    
    # Gap demasiado largo o el camino se desvió → buscar con sweep
    drive.stop()
    return sweep_for_line()

def sweep_for_line():
    """Hace un barrido en abanico buscando la línea."""
    for angle in [30, -60, 90, -120]:
        drive.turn(angle)
        if color_left.reflection() < 30:
            return True
    return False

Esquivar obstáculos

Los obstáculos son cubos LEGO físicos sobre o cerca de la línea. El robot debe pasar al costado y volver.

def avoid_obstacle():
    """Patrón clásico: girar 90, avanzar, girar -90, avanzar, girar -90, avanzar, girar 90."""
    drive.turn(90)         # girar a la derecha
    drive.straight(150)    # avanzar lateralmente
    drive.turn(-90)        # apuntar hacia adelante
    
    # Avanzar hasta pasar el obstáculo, buscando la línea
    drive.reset()
    while drive.distance() < 400:
        drive.drive(150, 0)
        if color_left.reflection() < 30:
            # Encontramos la línea de nuevo
            drive.stop()
            return
        wait(20)
    
    drive.stop()
    drive.turn(-90)        # girar a la izquierda
    drive.straight(150)    # cerrar el rectángulo
    drive.turn(90)

Detección de rampa

from pybricks.parameters import Axis

def handle_ramp(pitch):
    """En la rampa, mantener line following pero con velocidad reducida."""
    while abs(hub.imu.tilt()[0]) > 5:
        # Mismo line following pero más lento (motores cargan más)
        error = color_left.reflection() - SETPOINT
        drive.drive(120, KP * 1.3 * error)  # más lento + más Kp
        wait(20)
    # Salimos de la rampa

Zona de evacuación — el endgame

El cuarto de evacuación es un cuarto cerrado con paredes. El robot debe:

1. Entrar.
2. Buscar las víctimas (bolas plateadas y negras).
3. Tomar cada víctima.
4. Llevarlas al triángulo de evacuación.
5. Depositarlas.

Búsqueda en espiral o en zigzag

def search_for_victims():
    """Recorre el cuarto en patrón de espiral hasta detectar una víctima."""
    while not victim_detected():
        drive.straight(200)
        if us_front.distance() < 100:
            drive.turn(90)  # esquivar pared
        if us_left.distance() < 100:
            drive.turn(45)
        wait(20)

def victim_detected():
    """Una víctima cerca dispara el ultrasonido frontal a una distancia específica."""
    return 30 < us_front.distance() < 80

Clasificación plateada vs negra

def classify_victim():
    """Después de detectar una víctima al frente, acercarse y clasificarla."""
    drive.straight(50)  # acercar
    
    refl = color_front.reflection()
    if refl > 60:
        return 'silver'  # más reflectante = víctima viva
    else:
        return 'black'   # menos reflectante = víctima muerta

Depositar en el triángulo

El triángulo de evacuación está en una esquina del cuarto. Identificarlo por la geometría: dos paredes formando 90°.

def find_evacuation_triangle():
    """Navega a la esquina del cuarto donde dos paredes se encuentran."""
    while True:
        front = us_front.distance()
        left = us_left.distance()
        if front < 100 and left < 100:
            # Esquina encontrada
            return
        if front > 100:
            drive.straight(50)
        elif left > 100:
            drive.turn(-90)
            drive.straight(50)
        wait(20)

Estrategia de scoring

El scoring de RCJ Rescue Line es complejo y privilegia completar la pista entera sobre completar tareas individuales. Lecciones tácticas:

1. Las víctimas plateadas valen más que las negras. Si solo hay tiempo para una, priorizar plateada.
2. Un robot que termina la pista sin víctimas vale más que uno que rescata todas pero queda atascado en la rampa.
3. Lack of progress (LoP): si el robot se queda atascado, el equipo puede pedir un LoP para reposicionarlo al último checkpoint, pagando una penalización menor. Es crítico saber cuándo pedir LoP vs seguir intentando.

Errores típicos

Recursos

• RCJ Rescue Line rulebook: https://junior.robocup.org/rcjrescue/
• Repo IITA: IITA-Proyectos/rcj-2026-rescue-line-iita-salta-robocup
• RoboCup 2026 Incheon: junio 30-julio 6.
• Comunidad: Discord oficial de RCJ.