AndesRobot

AndesRobot · RoboCup@Home 2027 · Human Robot Interaction Challenge

Así funciona nuestro robot, nodo por nodo

Una guía para quien está empezando en robótica. El robot recibe a dos invitados en una casa, los lleva al living, les ofrece asiento, los presenta y lleva un bolso hasta donde le indiquen. Aquí ves cómo cinco equipos construyen ese robot con ROS 2 y cómo sus programas se hablan entre sí.

Interacción Visión Navegación Brazo y Garra Estructura ruedas, sensores y botones
Plataforma común Ubuntu 22.04ROS 2 HumbleWorkspace MILO / MARTHADocker · repositorio en GitHub

Tu recorrido

  1. 01ROS 2 en 2 minutosNodos, tópicos, servicios y acciones, con dibujos que se mueven.
  2. 02El reto paso a pasoEl robot recibe a los invitados y ves qué mensajes usa en cada momento.
  3. 03El mapa del robotTodos los nodos de los cinco equipos y cómo se conectan.
  4. 04Cómo se mueveDe "anda a la puerta" a girar las ruedas.
  5. 05MILO y MARTHAEl mismo código para dos robots distintos.
  6. 06SimularTrabajar en Gazebo mientras se arma el robot.
  7. 07El contratoLa tabla con todas las interfaces: nombres, tipos y campos.

Para empezar

ROS 2 en 2 minutos

Lo mínimo para leer esta página. Cada tarjeta trae el comando de terminal para verlo en el robot o en la simulación.

Nodo

Un programa que hace una sola cosa: por ejemplo asr_node convierte voz en texto. Cada equipo escribe sus nodos en Python o C++.

ros2 node list

Tópico

Un canal por el que un nodo publica datos todo el rato y otros los escuchan. Es como una radio: el que publica no sabe quién escucha. Ej: /nav/scan.

ros2 topic echo /nav/scan

Servicio

Una pregunta con respuesta rápida: un nodo pide y otro responde una vez. Ej: /vision/detect_handle → "¿dónde está la chapa?".

ros2 service call …

Acción

Una tarea larga: se pide, va avisando el progreso y al final dice si lo logró. Se puede cancelar. Ej: /nav/navigate_to_pose.

ros2 action send_goal …

Mensaje (tipo)

La forma de los datos: qué campos lleva y en qué unidades. Ej: geometry_msgs/Twist tiene linear.x y angular.z. Los dos lados deben usar el mismo tipo.

ros2 interface show geometry_msgs/msg/Twist

Frame y TF

Un sistema de coordenadas (map, odom, base_footprint, la cámara…). TF2 sabe cómo pasar una posición de un frame a otro. Cada posición publicada dice en qué frame está.

ros2 run tf2_tools view_frames

Launch

Un archivo que arranca muchos nodos juntos con su configuración. Ej: sim.launch.py y robot.launch.py del repo.

ros2 launch paquete archivo.launch.py

El contrato

La lista de tópicos, servicios y acciones con sus tipos (sección "Contrato"). Si cada equipo respeta esos nombres y tipos, los nodos se conectan solos al integrarlos.

ros2 topic list

Animación del reto

El reto en vivo: el robot en la casa y los mensajes en el grafo

Cada paso del reto, en orden. A la izquierda se mueve el robot; abajo se encienden los nodos y viajan los mensajes de ese paso.

1 / 37
Llegada del invitado:

Todos los equipos juntos

El mapa del robot

Cada caja es un nodo y cada línea un mensaje. Arriba está Interacción, que decide; al medio Visión, Navegación y Brazo y Garra, que ejecutan; abajo Estructura y el hardware. Toca un nodo para ver qué publica y qué escucha, y usa los botones para cambiar de robot o ver la simulación.

Grafo ROS 2 completo · MILO

Tópico Servicio Acción Interno del equipo Hardware

Cada equipo implementa internamente sus nodos y expone únicamente las interfaces definidas en el contrato de integración. HRI es el orquestador de alto nivel: decide qué necesita el robot y lo solicita; Navegación, Visión y Brazo ejecutan su propia función, y solo Estructura y Electrónica (más los motores del brazo) toca el hardware. Toca un nodo para ver todo lo que publica, escucha, ofrece y llama.

Navegación decide, Estructura mueve

Cómo se mueve el robot

Navegación nunca toca un motor. Le entrega a Estructura una sola cosa: cuánto avanzar y cuánto girar por segundo (/cmd_vel). Estructura sabe convertir eso en vueltas de cada rueda y le devuelve cuánto se movió de verdad (/base/odom). Así cada equipo trabaja por separado y se conectan con solo esos dos tópicos.

  1. Interacción · task_orchestrator_node

    "Ve a la puerta": pide la acción /nav/navigate_to_pose con una pose en el frame map. No dice cómo llegar.

  2. Navegación · planificador global (Nav2)

    Calcula la ruta en el mapa, una línea de puntos desde donde está el robot hasta la meta. Se recalcula si algo la bloquea.

  3. Navegación · controlador local (Nav2)

    20 veces por segundo mira dónde está el robot y la ruta, y calcula la velocidad para seguirla: /nav/cmd_vel_planner.

  4. Navegación · cmd_vel_mux y safety_filter_node

    El mux elige la fuente (navegar o mirar) y el filtro frena si hay algo a menos de 30 cm. Sale /cmd_vel: una velocidad del cuerpo del robot en base_footprint.

  5. Frontera del contrato

    Hasta aquí llega Navegación. Lo único que cruza es /cmd_vel hacia abajo y /base/odom hacia arriba.

  6. Estructura · base_driver_node (ros2_control)

    Cinemática inversa: convierte la velocidad del cuerpo en la velocidad de cada rueda (rad/s). La fórmula depende del robot (abajo).

  7. Estructura · hardware interface

    Manda esas velocidades a los motores: por serie al hoverboard en MILO, a los drivers de los 4 motores en MARTHA. Y lee los encoders.

  8. Estructura · odometría (ruedas + IMU)

    Cinemática directa: con lo que giraron las ruedas calcula cuánto se movió el robot (/base/wheel_odom), y odom_ekf_node lo junta con la IMU, que mide mejor el giro. Publica /base/odom y la TF odom → base_footprint.

  9. Navegación · localización

    Compara el LiDAR con el mapa y corrige el error que acumula la odometría (TF map → odom). En la siguiente vuelta el controlador ya usa la posición corregida.

MILO · base diferencial (hoverboard)

Dos ruedas: avanza y gira

Con v = linear.x, ω = angular.z, separación L = 0,3604 m y radio r = 0,08255 m (del milo_controllers.yaml del repo):

vizq = v − ω·L/2    vder = v + ω·L/2    ωrueda = vrueda / r

Ejemplo: avanzar a 0,2 m/s → cada rueda a 2,42 rad/s. Girar en el lugar a 1 rad/s → una rueda a −2,18 rad/s y la otra a +2,18 rad/s. linear.y se ignora: MILO no puede ir de lado. Esto ya lo hace diff_drive_controller.

MARTHA · 4 ruedas omnidireccionales

Avanza, gira y se mueve de lado

Usa también linear.y. Si las ruedas son mecanum, con lx y ly la mitad del largo y del ancho entre ruedas:

ωDI = (vx − vy − (lx+ly)ω)/r   ωDD = (vx + vy + (lx+ly)ω)/r
ωTI = (vx + vy − (lx+ly)ω)/r   ωTD = (vx − vy + (lx+ly)ω)/r

Si son ruedas omni (con rodillos a 90°, en cruz o a 45°) la matriz cambia, y los signos dependen de cómo estén montadas. La define Estructura. Navegación solo necesita saber que el robot es holonómico (en Nav2, el modelo de movimiento "Omni"). Revisen si su versión de ros2_controllers trae un controlador mecanum u omni; si no, toca escribir uno propio.

Prueba de Estructura, sin Navegación

Mover con un comando

ros2 topic pub -r 20 /cmd_vel geometry_msgs/msg/Twist "{linear: {x: 0.2}}" durante 5 s: el robot avanza 1 m y /base/odom marca cerca de 1 m. Con angular.z: 0.5 durante 12,6 s da una vuelta completa. Si la odometría no coincide, calibrar radio y separación.

Prueba de Navegación, sin Estructura

En Gazebo

El simulador hace de Estructura: recibe el mismo /cmd_vel y publica /base/odom. Cuando la prueba de Estructura pase en el robot real, se conectan sin cambiar nada de Navegación.

Importante

Velocidad, no destino

Navegación no le dice a Estructura "anda a (x, y)": eso es la acción /nav/navigate_to_pose, y es de Navegación. A Estructura le llega solo velocidad, en el frame del robot (linear.x es hacia adelante del robot, no hacia el norte del mapa), en m/s y rad/s, nunca en porcentaje de PWM. Si deja de llegar por 0,5 s, el robot se detiene: eso es bueno.

Seguir a una persona: ¿Navegación o Visión? Las dos

EquipoQué haceCon qué interfaz
InteracciónDecide a quién seguir (el anfitrión), avisa "Listo, te sigo" y pide la acción con su person_id./nav/follow_person (cliente)
Visión · veDetecta al anfitrión y mantiene su mismo person_id cuadro a cuadro (tracker); si se pierde un momento, lo reconoce de nuevo./vision/persons
Navegación · mueveperson_follower_node toma la posición de esa persona, pone metas a 0,8–1 m detrás, evita obstáculos y termina si no la ve por 5 s.Dueña de /nav/follow_person; metas internas a path_planner_node → /cmd_vel
EstructuraMueve las ruedas como siempre. No sabe que está siguiendo a alguien./cmd_vel → /base/odom

La acción es de Navegación porque su resultado es movimiento. Lo más crítico es el tracker de Visión: si le cambia el id al anfitrión, Navegación sigue a otra persona y eso cuesta hasta −150.

Mismo contrato, distinto hardware

Dos robots: MILO y MARTHA

Cada robot graba el mismo reto por separado. Los nodos, tópicos, servicios y acciones son los mismos; cambian el URDF, los drivers y la configuración. En el grafo, el botón MILO / MARTHA muestra el hardware de cada uno.

MILOMARTHA
BaseHoverboard, 2 ruedas, diferencial4 ruedas omnidireccionales, holonómica
Qué usa de /cmd_vellinear.x, angular.zlinear.x, linear.y, angular.z
Controlador (Estructura)diff_drive_controller (ya en el repo)Omnidireccional, por definir
Nav2 (Navegación)Modelo de movimiento DiffDriveModelo de movimiento Omni
Mirar a una personaGirar toda la baseGirar la base; puede seguir moviéndose de lado mientras mira
Cámara de la cabezaSimple (RGB, sin profundidad)RGB-D
Cámara de la garraRGB-D (la única con profundidad)RGB-D
Distancia a las personasPendiente no hay profundidad en la cabezaCon la RGB-D de la cabeza
Ascensor del brazoSí (vertical_lift_joint)Sí
LiDARRPLIDAR C1Por confirmar
URDF, yaml y mapaPropios de MILOPropios de MARTHA

Pendiente en MILO

¿A qué distancia está la persona?

Sin profundidad en la cabeza, Visión ve a la persona pero no sabe a cuántos metros está. Opciones: (1) un modelo de profundidad monocular en la GPU, (2) usar el LiDAR para medir la distancia a las piernas en la dirección de la persona, (3) subir el brazo con el ascensor y usar la RGB-D de la garra como "cabeza". Hay que elegir antes de programar person_detector_node.

Si están los dos encendidos

Que no se escuchen entre ellos

Con los mismos nombres de tópicos en la misma red, MILO podría obedecer el /cmd_vel de MARTHA. Cada robot usa un ROS_DOMAIN_ID distinto (por ejemplo MILO = 11 y MARTHA = 12) y cada computador de desarrollo se pone en el del robot con el que trabaja.

Un solo código

Elegir el robot al lanzar

Un argumento robot:=milo o robot:=martha en el launch elige el URDF, el yaml del controlador, la configuración de Nav2 y la zona base. Los rosbag y videos de cada intento van con el nombre del robot.

Qué cambia en cada equipo

En general es lo mismo: cada equipo escribe su código una vez y solo cambia la configuración. Las filas grises son lo que no cambia.

EquipoQuéMILOMARTHA
Estructura y ElectrónicaHardware interfaceHoverboard por serie (hoverboard_hardware_interface, ya en el repo)4 drivers de motor, uno por rueda; interface propia
Controladordiff_drive_controllerOmnidireccional (mecanum u omni según las ruedas)
Encoders y odometría2 encoders; /base/odom sin velocidad lateral4 encoders; /base/odom con twist.linear.y
IMU y fusiónIMU + EKF (robot_localization) en modo 2DLo mismo, y el EKF también estima la velocidad lateral
CalibraciónRadio y separación de ruedas (giro de 360°)Radio, lx, ly y signo de cada rueda; probar avanzar, ir de lado y girar
Igual en los dosBotón de inicio, emergencia, luces, robot_state_publisher, /cmd_vel → /base/odom
NavegaciónNav2Modelo DiffDrive; controladores como DWB, MPPI o Regulated Pure PursuitModelo Omni; DWB o MPPI con velocidad lateral (Regulated Pure Pursuit no sirve para ir de lado)
FootprintEl de MILO (repo: −0,12 a 0,44 m × ±0,25 m)El de MARTHA
Filtro de seguridadRevisa adelante y atrásTambién a los lados: si MARTHA se mueve de lado, el filtro actual no mira esa dirección
Mirar a la personaGirar la base, quietoPuede girar mientras se desplaza de lado
LiDAR, mapa y zona baseRPLIDAR C1, mapa y base_zone de MILOLiDAR por confirmar, mapa y base_zone propios
Igual en los dosTodas las acciones y servicios (/nav/navigate_to_pose, /nav/follow_person, /nav/look…), el mux y la localización
Visión ComputacionalCámarasCabeza: RGB simple. Garra: RGB-DCabeza: RGB-D. Garra: RGB-D
Distancia a personas y asientosPendiente sin profundidad en la cabeza: ver la tarjeta "Pendiente en MILO"Profundidad de la cabeza
CalibraciónIntrínsecos de las dos cámaras y su posición en el URDFLo mismo, para dos cámaras de profundidad
Igual en los dosDetección, caras, gestos, tracker, /vision/persons y todos los servicios
Brazo y GarraBrazo y ascensorBrazo con ascensor; altura de montaje según el URDF de MILOBrazo con ascensor; altura de montaje según el URDF de MARTHA
Cámara de la garraAdemás del agarre, puede servir de "cabeza con profundidad" si se sube el brazo (choca con señalar o llevar el bolso)Solo agarre, puerta y handover
Igual en los dosAcciones /arm/*, handover y apertura de puerta
Interacción Humano-RobotAudioMicrófono y parlante de MILO (ajustar ganancia y volumen)Los de MARTHA
ConfiguraciónROS_DOMAIN_ID de MILO, nombre en los rosbagROS_DOMAIN_ID de MARTHA
Igual en los dosOrquestador, diálogo, timbre, LLM, todos los pasos del reto

Mismo código, dos mundos

Simulación y robot real

La idea es que el robot se pueda simular y que después el mismo código corra en el robot. Lo único que cambia es la capa de abajo: en simulación, Gazebo reemplaza los drivers y el hardware y publica los mismos tópicos. Todo lo de arriba (orquestador, Nav2, Visión, Brazo) no sabe si está en Gazebo o en el robot. En el grafo, el botón "Robot real / Simulación" muestra qué nodo reemplaza cada plugin.

PiezaEquipoEn simulación (Gazebo)En el robot realTópicos (iguales en los dos)
LiDARNavegaciónPlugin libgazebo_ros_ray_sensor (ya en el repo)RPLIDAR C1 con sllidar_node (MILO)/nav/scan
Ruedas y odometríaEstructuraPlugin libgazebo_ros_diff_drive en MILO (ya en el repo); para MARTHA, uno omnidireccionalHoverboard con ros2_control (MILO); 4 motores (MARTHA)/cmd_vel → /base/wheel_odom
IMUEstructuraPlugin libgazebo_ros_imu_sensor (ya en el repo)IMU real con su driver/base/imu
Fusión de odometríaEstructuraodom_ekf_node, el mismo yamlodom_ekf_node, el mismo yaml/base/odom
CámarasVisiónPlugins de cámara y profundidad (falta agregarlos al URDF)Cámaras reales de cada robot/vision/camera/*, /vision/gripper_camera/*
Brazo, garra y ascensorBrazo y GarraHoy: un stub de acciones que responde como el brazo real (tiempos y fallas configurables). Después: gazebo_ros2_control con el mismo URDF (hoy el repo lo deja fijo)Motores reales/arm/*
Micrófono y parlanteInteracciónLos del computador, o audios grabadosLos del robot/hri/audio, /hri/play_sound
Botones de inicio y emergenciaEstructuraSe publican a mano (ros2 topic pub) o con un botón en RVizBotones físicos/base/start_sound, /base/start_button, /base/emergency_stop
PersonasVisiónModelos de personas en Gazebo, o probar Visión aparte con videos y rosbagsPersonas reales/vision/persons
Todo lo demásTodosIdénticoIdénticoOrquestador, diálogo, Nav2, localización, mux, filtro, Visión, Brazo

Un launch para cada mundo

sim.launch.py y robot.launch.py

Ya existen en el repo. Los dos lanzan lo mismo de arriba; solo cambia la capa de abajo: Gazebo con sus plugins o los drivers reales. Con el argumento robot:=milo o robot:=martha se elige además el URDF y la configuración.

Importante

use_sim_time

En simulación el reloj lo da Gazebo (/clock) y todos los nodos van con use_sim_time: true; en el robot, false. Si uno solo queda mal, las TF "llegan del futuro" o "del pasado" y Nav2 y SLAM fallan sin un error claro. El repo ya lo pasa como argumento.

Lo que la simulación no prueba bien

Audio, gente y contacto

El timbre, la voz, el reconocimiento de caras, el handover y abrir la puerta se prueban mejor por separado (audios grabados, videos, el brazo en la mesa) y después en el robot. Gazebo sirve sobre todo para navegación, mapas y la lógica del orquestador.

Reglas para que el paso a real no duela

  1. 01

    Mismos nombres, tipos y frames

    Lo que cambia entre simulación y robot es quién publica, no qué se publica. Un solo argumento del launch elige Gazebo y los stubs o los drivers reales. Nadie cambia su código.

  2. 02

    Simular las limitaciones reales

    MILO simulado también va sin profundidad en la cabeza; el LiDAR con ruido y la columna que lo tapa (el repo ya lo hace); las ruedas con los límites de velocidad y aceleración reales. Si la simulación es más fácil que el robot, el tiempo ganado se pierde después.

  3. 03

    Stubs que tardan y fallan

    Los nodos de prueba de Brazo y Estructura tienen parámetros de tiempo y de falla. Así Interacción prueba los planes B del orquestador antes de que exista el brazo.

  4. 04

    Grabar el robot real cuanto antes

    Apenas Estructura tenga ruedas y sensores: ros2 bag record de /nav/scan, /base/odom, /base/imu y las cámaras. Navegación y Visión prueban con datos reales sin el robot.

  5. 05

    Un ROS_DOMAIN_ID por persona

    Si varios simulan en la misma red, se mezclan sus robots simulados. Cada persona usa su propio ROS_DOMAIN_ID.

  6. 06

    Probar el reto completo en simulación

    Gazebo de Navegación + stubs de Brazo y Estructura + Interacción en un computador = el reto de punta a punta, paso a paso como en la animación, antes de tener el robot.

¿Qué es odom_ekf_node?

Juntar ruedas e IMU

Las ruedas dicen cuánto avanzó el robot, pero patinan, sobre todo al girar. La IMU mide bien el giro pero se desvía con el tiempo. Un filtro de Kalman extendido (EKF) junta las dos y da una odometría mejor que cada una por separado. No hay que programarlo: es el ekf_node del paquete robot_localization con un yaml. Corre igual en simulación (con la IMU de Gazebo) y en el robot. Mientras no esté, la odometría de las ruedas sale directo como /base/odom.

Ya hoy

Quién puede avanzar sin robot

Navegación: el repo ya simula MILO; falta remapear, localización, Nav2, el mux y la puerta en el mundo. Interacción: todo en un computador, con los stubs. Visión: webcam y rosbags con gente real, en la misma resolución y ángulo que tendrá el robot.

Mientras tanto

Estructura y Brazo y Garra

Arman MILO y MARTHA en físico y escriben sus drivers contra el mismo contrato. Cuando un driver real funciona, reemplaza a su plugin o stub y los demás no cambian nada. La primera prueba siempre es la misma: ros2 topic list y ros2 topic echo con los nombres del contrato.

Contrato de integración

Todas las interfaces, con tipo y campos

Una fila por tópico, servicio o acción. El estado dice de dónde sale: del contrato de la propuesta, de la trazabilidad (con tipo propuesto aquí) o nuevo para cerrar un hueco. Un único responsable por interfaz es una regla de este proyecto, no una limitación de ROS 2.

InterfazTipo ROS 2Campos principalesPublica u ofreceLa usaEstado