Robot Sumo — combate robótico

Setup hardware típico para sumo con Spike Prime

• 2 motores de tracción con la mayor torque/velocidad posible (motores grandes de Spike).
• 2 ColorSensor apuntando al piso, uno adelante a cada lado, para detectar el borde blanco del dohyo.
• 2-4 sensores de oponente:
  • UltrasonicSensor al frente para detectar oponente directo enfrente.
  • 2 sensores IR proximity o ToF VL53L0X a los costados frontales para detectar oponente a 30-45° del frente.
• Pala/cuña frontal baja al ras del piso para meter debajo del oponente y elevarlo (ventaja de empuje).
• Peso máximo permitido distribuido bajo y centrado para mejor tracción y resistencia al volcado.

Decisión clave: agresivo vs defensivo

Agresivo (bull rush)

El robot va al centro del dohyo y embiste al primer contacto detectado. Apuesta por la potencia bruta.

Pros: 70% de los matches se ganan en los primeros 5 segundos por bull rush exitoso. Simple de programar.

Contras: si el oponente es más rápido o tiene mejor pala, perdés.

Defensivo / contraataque

El robot espera en el centro, gira buscando al oponente, ataca solo cuando el oponente está identificado y bien encarado.

Pros: aprovecha errores del oponente, mejor contra robots agresivos pero mal calibrados.

Contras: contra otro defensivo es un standoff aburrido que termina en empate.

Adaptativo (recomendado para escuela)

Empieza agresivo, si pierde una ronda cambia a defensivo, si pierde otra vuelve a agresivo con un patrón distinto.

Edge detection — la prioridad #1

Antes de pensar en empujar, el robot tiene que NO caer del dohyo. Los dos sensores de color al frente leen el piso constantemente:

color_left = ColorSensor(Port.E)
color_right = ColorSensor(Port.F)

# El dohyo es negro, el borde es blanco
EDGE_THRESHOLD = 50  # >50 = blanco = borde

def at_edge():
    """Devuelve qué borde detectado: 'left', 'right', 'both', None."""
    l = color_left.reflection() > EDGE_THRESHOLD
    r = color_right.reflection() > EDGE_THRESHOLD
    if l and r:
        return 'both'
    elif l:
        return 'left'
    elif r:
        return 'right'
    return None

Y la rutina de evasión cuando se detecta el borde interrumpe TODO:

def avoid_edge(edge):
    """Reacción inmediata al detectar borde. PRIORIDAD ABSOLUTA."""
    drive.stop()
    
    if edge == 'both':
        # Borde frontal directo → retroceder y girar
        drive.straight(-200)
        drive.turn(180)
    elif edge == 'left':
        # Borde a la izquierda → retroceder y girar a la derecha
        drive.straight(-100)
        drive.turn(45)
    elif edge == 'right':
        drive.straight(-100)
        drive.turn(-45)
    
    # Después de evadir, volver a buscar al oponente

Detección del oponente

El sensor frontal ultrasónico te dice si hay algo enfrente. Los sensores laterales te dicen si está a un costado.

us_front = UltrasonicSensor(Port.D)

def opponent_distance():
    """Distancia al oponente enfrente, en mm. None si no detectado."""
    d = us_front.distance()
    if d > 1500:
        return None  # nadie a la vista
    return d

def opponent_direction():
    """Devuelve 'front', 'left', 'right', None."""
    front = us_front.distance() < 800
    # Suponiendo que tenemos sensores IR a los lados
    left = ir_left.value() > IR_THRESHOLD
    right = ir_right.value() > IR_THRESHOLD
    
    if front:
        return 'front'
    elif left and not right:
        return 'left'
    elif right and not left:
        return 'right'
    return None

Loop principal del agresivo

SEARCH_SPEED = 200
ATTACK_SPEED = 800  # MÁXIMA velocidad cuando hay contacto inminente
DELAY_START = 5000  # ms

def main():
    # Delay inicial obligatorio
    sw = StopWatch()
    sw.reset()
    while sw.time() < DELAY_START:
        wait(50)
    
    # Combate
    while True:
        # PRIORIDAD 1: edge detection
        edge = at_edge()
        if edge:
            avoid_edge(edge)
            continue
        
        # PRIORIDAD 2: si hay oponente detectado, atacar
        direction = opponent_direction()
        if direction == 'front':
            # Bull rush
            drive.drive(ATTACK_SPEED, 0)
        elif direction == 'left':
            drive.drive(SEARCH_SPEED, -200)  # girar hacia él
        elif direction == 'right':
            drive.drive(SEARCH_SPEED, 200)
        else:
            # PRIORIDAD 3: buscar al oponente girando en el lugar
            drive.drive(0, 150)  # rotar
        
        wait(20)

Loop principal del defensivo

def main_defensive():
    sw = StopWatch()
    sw.reset()
    while sw.time() < DELAY_START:
        wait(50)
    
    while True:
        edge = at_edge()
        if edge:
            avoid_edge(edge)
            continue
        
        direction = opponent_direction()
        distance = opponent_distance()
        
        if direction == 'front' and distance and distance < 200:
            # Solo atacar cuando está MUY cerca y enfrente
            drive.drive(ATTACK_SPEED, 0)
        elif direction in ['left', 'right']:
            # Encararlo pero sin avanzar
            turn_rate = 200 if direction == 'right' else -200
            drive.drive(0, turn_rate)
        else:
            # Quedarse en el centro buscando
            drive.drive(0, 100)
        
        wait(20)

Patrones avanzados

"El esquive" (dodge)

Cuando detectás al oponente embistiendo de frente, moverte lateralmente en el último momento. Si el oponente va a 800 mm/s y vos te corrés 30 cm en 0.3 seg, le esquivás y queda con la inercia mirando hacia el borde.

def dodge_left():
    """Esquive lateral izquierdo de un ataque frontal."""
    drive.use_gyro(False)
    left_motor.run(-800)
    right_motor.run(800)  # rotar 90° rápido a la izquierda
    wait(150)
    drive.straight(150)  # avanzar lateralmente
    drive.turn(90)       # reorientar para contraatacar al oponente que pasó de largo

"El gancho" (hook)

Engañar al oponente acercándose y desviando en el último momento para tomarlo por el costado, donde su pala no protege.

"El empuje continuo"

Una vez que tu pala está debajo del oponente, NO PARES de empujar hasta que cruce el borde del dohyo. Mantener drive.drive(MAX_SPEED, 0) hasta detectar que el oponente desapareció (cayó) o que vos estás llegando al borde.

def push_until_win_or_edge():
    while True:
        edge = at_edge()
        if edge:
            # CUIDADO: sos vos el que está por caer
            avoid_edge(edge)
            return
        
        if us_front.distance() > 500:
            # El oponente desapareció = lo empujamos fuera
            drive.stop()
            hub.light.on(Color.GREEN)
            return
        
        # Seguir empujando
        drive.drive(MAX_SPEED, 0)
        wait(20)

Diseño mecánico crítico

Lo que más importa en sumo después del código es la mecánica:

1. Pala al ras del piso. Si la pala del oponente queda debajo de la tuya, perdés. La tuya tiene que ser más baja (a 1-2 mm del piso).
2. Centro de gravedad bajo. Robots altos se vuelcan con un golpe lateral.
3. Tracción máxima. Ruedas con el mejor grip + peso sobre el axle motriz.
4. Robustez frontal. El frente recibe todos los impactos, tiene que aguantar.

Errores típicos

Recursos

• All Japan Robot-Sumo Tournament: la competición de mini-sumo profesional.
• RoboCup Junior tiene categoría "On Stage" pero NO tiene sumo oficial.
• LEGO sumo educativo: cualquier club o escuela puede organizarlo, no hay rulebook oficial único.
• Tutorial mini-sumo Pololu: https://www.pololu.com/docs/0J11/0