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í.
Tu recorrido
- 01ROS 2 en 2 minutosNodos, tópicos, servicios y acciones, con dibujos que se mueven.
- 02El reto paso a pasoEl robot recibe a los invitados y ves qué mensajes usa en cada momento.
- 03El mapa del robotTodos los nodos de los cinco equipos y cómo se conectan.
- 04Cómo se mueveDe "anda a la puerta" a girar las ruedas.
- 05MILO y MARTHAEl mismo código para dos robots distintos.
- 06SimularTrabajar en Gazebo mientras se arma el robot.
- 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 listTó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/scanServicio
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/TwistFrame 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_framesLaunch
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.pyEl 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 listAnimació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.
Fuera de la arena: un laboratorio, una visita o una feria, sin mapa de competencia ni guion. Tú eres el punto verde frente al robot y hay dos visitantes cerca. Cuando le hablas, el LLM elige una habilidad básica de interacción, el orquestador la valida y el robot mira, se acerca, saluda o cambia sus luces; abajo viajan los mensajes por el grafo.
Háblale al robot
asr_nodepasa tu voz a texto por/hri/speech_text.dialogue_manager_nodese la entrega allm_agent_nodecon la acción/hri/llm_chat, junto al estado del mundo (/hri/world_context).- Si hay que hacer algo (mirar, acercarse, saludar, cambiar luces, recordar un nombre), el LLM pide una habilidad de la lista permitida por
/hri/skill_request;task_orchestrator_nodela valida y llama a Navegación, Visión, Brazo o Estructura. - La respuesta vuelve a
dialogue_manager_node, que la publica en/hri/sayparatts_node.
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.
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.
- Interacción · task_orchestrator_node
"Ve a la puerta": pide la acción
/nav/navigate_to_posecon una pose en el framemap. No dice cómo llegar. - 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.
- 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. - 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 enbase_footprint. - Frontera del contrato
Hasta aquí llega Navegación. Lo único que cruza es
/cmd_velhacia abajo y/base/odomhacia arriba. - 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).
- 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.
- Estructura · odometría (ruedas + IMU)
Cinemática directa: con lo que giraron las ruedas calcula cuánto se movió el robot (
/base/wheel_odom), yodom_ekf_nodelo junta con la IMU, que mide mejor el giro. Publica/base/odomy la TFodom → base_footprint. - 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
| Equipo | Qué hace | Con qué interfaz |
|---|---|---|
| Interacción | Decide 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 · ve | Detecta 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 · mueve | person_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 |
| Estructura | Mueve 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.
| MILO | MARTHA | |
|---|---|---|
| Base | Hoverboard, 2 ruedas, diferencial | 4 ruedas omnidireccionales, holonómica |
Qué usa de /cmd_vel | linear.x, angular.z | linear.x, linear.y, angular.z |
| Controlador (Estructura) | diff_drive_controller (ya en el repo) | Omnidireccional, por definir |
| Nav2 (Navegación) | Modelo de movimiento DiffDrive | Modelo de movimiento Omni |
| Mirar a una persona | Girar toda la base | Girar la base; puede seguir moviéndose de lado mientras mira |
| Cámara de la cabeza | Simple (RGB, sin profundidad) | RGB-D |
| Cámara de la garra | RGB-D (la única con profundidad) | RGB-D |
| Distancia a las personas | Pendiente no hay profundidad en la cabeza | Con la RGB-D de la cabeza |
| Ascensor del brazo | Sí (vertical_lift_joint) | Sí |
| LiDAR | RPLIDAR C1 | Por confirmar |
| URDF, yaml y mapa | Propios de MILO | Propios 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.
| Equipo | Qué | MILO | MARTHA |
|---|---|---|---|
| Estructura y Electrónica | Hardware interface | Hoverboard por serie (hoverboard_hardware_interface, ya en el repo) | 4 drivers de motor, uno por rueda; interface propia |
| Controlador | diff_drive_controller | Omnidireccional (mecanum u omni según las ruedas) | |
| Encoders y odometría | 2 encoders; /base/odom sin velocidad lateral | 4 encoders; /base/odom con twist.linear.y | |
| IMU y fusión | IMU + EKF (robot_localization) en modo 2D | Lo mismo, y el EKF también estima la velocidad lateral | |
| Calibración | Radio 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 dos | Botón de inicio, emergencia, luces, robot_state_publisher, /cmd_vel → /base/odom | ||
| Navegación | Nav2 | Modelo DiffDrive; controladores como DWB, MPPI o Regulated Pure Pursuit | Modelo Omni; DWB o MPPI con velocidad lateral (Regulated Pure Pursuit no sirve para ir de lado) |
| Footprint | El de MILO (repo: −0,12 a 0,44 m × ±0,25 m) | El de MARTHA | |
| Filtro de seguridad | Revisa adelante y atrás | También a los lados: si MARTHA se mueve de lado, el filtro actual no mira esa dirección | |
| Mirar a la persona | Girar la base, quieto | Puede girar mientras se desplaza de lado | |
| LiDAR, mapa y zona base | RPLIDAR C1, mapa y base_zone de MILO | LiDAR por confirmar, mapa y base_zone propios | |
| Igual en los dos | Todas las acciones y servicios (/nav/navigate_to_pose, /nav/follow_person, /nav/look…), el mux y la localización | ||
| Visión Computacional | Cámaras | Cabeza: RGB simple. Garra: RGB-D | Cabeza: RGB-D. Garra: RGB-D |
| Distancia a personas y asientos | Pendiente sin profundidad en la cabeza: ver la tarjeta "Pendiente en MILO" | Profundidad de la cabeza | |
| Calibración | Intrínsecos de las dos cámaras y su posición en el URDF | Lo mismo, para dos cámaras de profundidad | |
| Igual en los dos | Detección, caras, gestos, tracker, /vision/persons y todos los servicios | ||
| Brazo y Garra | Brazo y ascensor | Brazo con ascensor; altura de montaje según el URDF de MILO | Brazo con ascensor; altura de montaje según el URDF de MARTHA |
| Cámara de la garra | Ademá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 dos | Acciones /arm/*, handover y apertura de puerta | ||
| Interacción Humano-Robot | Audio | Micrófono y parlante de MILO (ajustar ganancia y volumen) | Los de MARTHA |
| Configuración | ROS_DOMAIN_ID de MILO, nombre en los rosbag | ROS_DOMAIN_ID de MARTHA | |
| Igual en los dos | Orquestador, 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.
| Pieza | Equipo | En simulación (Gazebo) | En el robot real | Tópicos (iguales en los dos) |
|---|---|---|---|---|
| LiDAR | Navegación | Plugin libgazebo_ros_ray_sensor (ya en el repo) | RPLIDAR C1 con sllidar_node (MILO) | /nav/scan |
| Ruedas y odometría | Estructura | Plugin libgazebo_ros_diff_drive en MILO (ya en el repo); para MARTHA, uno omnidireccional | Hoverboard con ros2_control (MILO); 4 motores (MARTHA) | /cmd_vel → /base/wheel_odom |
| IMU | Estructura | Plugin libgazebo_ros_imu_sensor (ya en el repo) | IMU real con su driver | /base/imu |
| Fusión de odometría | Estructura | odom_ekf_node, el mismo yaml | odom_ekf_node, el mismo yaml | /base/odom |
| Cámaras | Visión | Plugins de cámara y profundidad (falta agregarlos al URDF) | Cámaras reales de cada robot | /vision/camera/*, /vision/gripper_camera/* |
| Brazo, garra y ascensor | Brazo y Garra | Hoy: 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 parlante | Interacción | Los del computador, o audios grabados | Los del robot | /hri/audio, /hri/play_sound |
| Botones de inicio y emergencia | Estructura | Se publican a mano (ros2 topic pub) o con un botón en RViz | Botones físicos | /base/start_sound, /base/start_button, /base/emergency_stop |
| Personas | Visión | Modelos de personas en Gazebo, o probar Visión aparte con videos y rosbags | Personas reales | /vision/persons |
| Todo lo demás | Todos | Idéntico | Idéntico | Orquestador, 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
- 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.
- 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.
- 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.
- 04
Grabar el robot real cuanto antes
Apenas Estructura tenga ruedas y sensores:
ros2 bag recordde/nav/scan,/base/odom,/base/imuy las cámaras. Navegación y Visión prueban con datos reales sin el robot. - 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. - 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.
| Interfaz | Tipo ROS 2 | Campos principales | Publica u ofrece | La usa | Estado |
|---|