Adquiriendo señal…
Adquiriendo señal…
Lección 1 de 12· Control y estimación
0 de 12 lecciones · 0 %
En Sistemas APT (sistemas-apt) el apuntamiento se explica como un diagrama de bloques: un propagador produce la referencia az/el, un controlador compara con el encoder, un motor mueve la montura y el error se realimenta. Ese diagrama es correcto y es engañosamente simple, porque en un programa de un solo archivo los bloques son funciones que se llaman en orden. La Estación ATP (el repositorio ros2-workspace) nació de ese curso y corre el mismo modelo como un sistema real: cada bloque es un proceso distinto, los procesos no se llaman entre sí sino que se publican mensajes, y nadie garantiza a priori en qué orden llegan. Esta lección enseña a ver ese sistema: qué es ROS 2, cómo se construye el espacio de trabajo, qué nodos levanta el lanzamiento atp_loop y cuánto tráfico mueve.
Si vienes de Sistemas distribuidos espaciales (sistemas-distribuidos-espaciales), reconocerás el patrón: un bus de publicación/suscripción con descubrimiento automático, sin coordinador central. Y si vienes de Python para ingeniería espacial (python-ingenieria-espacial), los nodos de la Estación te resultarán familiares: son clases de Python de cien a trescientas líneas.
ROS 2 no es un sistema operativo: es un middleware más un ecosistema de herramientas. El middleware es DDS (Data Distribution Service), un estándar de la OMG para publicación/suscripción con calidad de servicio configurable. Tres ideas lo distinguen de ROS 1:
roscore llevaba la agenda de quién publica qué. En ROS 2 cada participante se anuncia por multidifusión y los demás lo descubren; si un nodo muere, el resto sigue funcionando.ROS_DOMAIN_ID parte la red en universos que no se ven entre sí. La Estación depende de ello para correr varias simulaciones a la vez.Jazzy Jalisco es la distribución LTS de mayo de 2024, con soporte hasta 2029, sobre Ubuntu 24.04. La Estación parte de la imagen osrf/ros:jazzy-desktop (docker/Dockerfile).
colconUn espacio de trabajo de ROS 2 es una carpeta con un src/ lleno de paquetes. Cada paquete declara en package.xml su tipo de construcción:
ament_python: un paquete de Python con setup.py, cuyos ejecutables son entry points. Así son hello_ros, atp_ros, atp_sdr o atp_mision.ament_cmake: un paquete con CMakeLists.txt. Así son atp_interfaces (mensajes propios, lección 2), atp_description (URDF, lección 4) y atp_control (C++ para ros2_control, lección 7).colcon build recorre src/, ordena los paquetes por dependencias y deja el resultado en install/. Después, source install/setup.bash añade ese árbol al entorno. La imagen de la Estación lo hace sola: su .bashrc carga /opt/ros/jazzy/setup.bash y, si existe, /ws/install/setup.bash.
docker compose build # imagen ros2-jazzy-dev (una vez)
./run.sh # shell dentro del contenedor (docker compose run --rm ros)
colcon build # dentro de /ws
source install/setup.bash
ros2 run hello_ros talker # escalón N0
El servicio ros de docker-compose.yml monta el repositorio en /ws, usa network_mode: host (para que DDS descubra entre contenedor y anfitrión), ipc: host (memoria compartida) y fija ROS_DOMAIN_ID=42. También impone topes de CPU y memoria (cpus 5, mem_limit 7g) desde que seis contactos en paralelo dejaron la máquina sin responder, según el propio comentario del archivo.
hello_rosLa escalera de validación de la Estación (README.md) empieza en N0: «pub/sub hello_ros: DDS y colcon funcionando». Es el nodo mínimo, y conviene leerlo entero porque todo nodo de la Estación tiene la misma forma:
# src/hello_ros/hello_ros/talker.py
import rclpy
from rclpy.node import Node
from std_msgs.msg import String
class Talker(Node):
def __init__(self):
super().__init__('talker')
self.pub = self.create_publisher(String, 'chatter', 10)
self.n = 0
self.create_timer(0.5, self.tick)
def tick(self):
msg = String(data=f'hola ROS 2 #{self.n}')
self.n += 1
self.pub.publish(msg)
def main():
rclpy.init()
rclpy.spin(Talker())
Un nodo es un participante con nombre (talker). Un tópico es un canal con nombre y tipo (chatter, std_msgs/String). El 10 es la profundidad de la cola. rclpy.spin entrega el control a un ejecutor que despierta los temporizadores y las retrollamadas. El listener simétrico hace create_subscription(String, 'chatter', self.cb, 10). Los nodos de la Estación usan atp_ros.nodo.correr(Clase) en vez de rclpy.spin directo: añade el saludo de arranque en /atp/listo (lección 3) y un cierre limpio.
atp_loopEl grafo es el conjunto de nodos y tópicos con sus aristas publicador → tópico → suscriptor. src/atp_ros/launch/atp_loop.launch.py levanta el lazo completo en tiempo simulado:
| Nodo | Publica | Se suscribe a |
|---|---|---|
sim_clock | /clock | /atp/step_ack |
mount_sim | /joint_states, /atp/step_ack | /clock, /atp/torque, /atp/reference |
reference_generator | /atp/reference, /atp/sat_state, /atp/pass_done | /atp/listo, /atp/torque |
pid_controller | /atp/torque | /atp/reference, /joint_states |
error_monitor | /atp/error_deg, /atp/pointing_error | /atp/reference, /joint_states, /atp/sat_state |
link_budget | /atp/link | /atp/sat_state, /atp/pointing_error |
recorder (si record_dir) | archivos telemetry.jsonl, metrics.json | /atp/reference, /joint_states, /atp/pointing_error, /atp/sat_state, /atp/link |
Los argumentos del lanzamiento cambian el grafo, no solo los parámetros. controller:=lqr sustituye pid_controller por lqr_controller y controller:=mpc por mpc_controller, gracias a una IfCondition por nodo; record_dir:=<carpeta> añade recorder; od:=true añade od_estimator. Otros argumentos solo ajustan números: el_max y mask fijan la geometría del pase sintético (por defecto 85° y 70°), time_scale la velocidad del reloj (1 = tiempo real, 0 = lo más rápido posible).
# src/atp_ros/launch/atp_loop.launch.py (recortado)
pid = Node(package='atp_ros', executable='pid_controller',
condition=IfCondition(PythonExpression(["'", LC('controller'), "' == 'pid'"])),
parameters=[sim, {'kp': LC('kp'), 'kd': LC('kd'), 'u_max': LC('u_max')}, estim])
lqr = Node(package='atp_ros', executable='lqr_controller',
condition=IfCondition(PythonExpression(["'", LC('controller'), "' == 'lqr'"])),
parameters=[sim, {'u_max': LC('u_max'), 'q_theta': LC('q_theta'), ...}, estim])
El mismo archivo calcula wait_nodes para el generador de referencia, la lista de nodos que deben anunciarse antes de que arranque el pase: sim_clock,mount_sim,link_budget,error_monitor más el controlador elegido, más recorder y od_estimator si están. Es el grafo descrito en texto.
Con el lazo corriendo en un terminal, otro terminal en el mismo dominio ve todo:
./run.sh ros2 launch atp_ros atp_loop.launch.py el_max:=85 mask:=70 time_scale:=1
# en otro terminal del mismo dominio:
ros2 node list # /sim_clock /mount_sim /reference_generator /pid_controller ...
ros2 topic list -t # tópicos con su tipo
ros2 topic info -v /joint_states # publicadores, suscriptores y su QoS
ros2 topic hz /joint_states # unos 20 Hz con time_scale:=1
ros2 topic bw /joint_states # bytes por segundo
rqt_graph # el grafo dibujado
ros2 topic hz mide en tiempo de pared: con time_scale:=0 el lazo corre tan deprisa como puede y verás cientos de hercios, aunque en tiempo simulado sigan siendo 20.
/joint_statessim_clock.py declara step_s = 0.05 s, así que todo el lazo publica a Hz. ¿Cuánto ocupa un sensor_msgs/JointState con dos juntas? DDS lo serializa en CDR, que alinea cada campo a su tamaño (un float64 empieza en múltiplo de 8). Contando sobre lo que publica mount_sim (nombres, posición, velocidad y par):
| Campo | Bytes | Desplazamiento final |
|---|---|---|
stamp.sec, stamp.nanosec | 4 + 4 | 8 |
frame_id vacío (longitud + nulo) | 4 + 1 | 13 |
name (alinear a 4, longitud, "az", "el") | 3 + 4 + 7 + 1 + 7 | 35 |
position (alinear, longitud, alinear a 8, 2 × 8) | 1 + 4 + 0 + 16 | 56 |
velocity (longitud, alinear a 8, 2 × 8) | 4 + 4 + 16 | 80 |
effort (longitud, alinear a 8, 2 × 8) | 4 + 4 + 16 | 104 |
Con la cabecera de encapsulación de 4 bytes, el mensaje ocupa bytes, y el ancho de banda útil es
Cada paquete añade unos 84 bytes de cabeceras (RTPS 56, UDP 8, IPv4 20), lo que lleva el total en la red a kB/s. Sumando todos los tópicos del lazo, la carga útil ronda los 10 kB/s: el lazo de la Estación no está limitado por la red, sino por la latencia y el orden de los mensajes. Esa es la pregunta de la lección 3.
ROS_DOMAIN_ID aísla, y por qué el máximo es 232La especificación DDS-RTPS asigna los puertos UDP a partir del dominio con constantes fijas: base , salto por dominio , salto por participante y desplazamientos , , , . El puerto de descubrimiento por multidifusión es
y el unidifusión del participante es .
Aislamiento. Dos procesos con dominios escuchan el descubrimiento en puertos que difieren en ; como los puertos de un dominio ocupan como mucho 250 posiciones consecutivas (los y son menores que 250 mientras haya menos de 120 participantes), los rangos no se solapan. Un participante del dominio 100 nunca recibe el anuncio de uno del dominio 101: no hay mensajes cruzados, porque ni siquiera llegan al mismo puerto.
Límite. Un puerto UDP es un entero de 16 bits, . Exigiendo que quepa el puerto de descubrimiento:
Para el puerto es 65400; para sería 65650, que no existe.
La Estación usa esta propiedad a diario. El contenedor interactivo trabaja en el dominio 42 (puerto 17900), el servicio gz en el 82, y el backend de la app lanza cada corrida con su propio dominio del pool 100–199 (station/backend/station/config.py, STATION_DOMAIN_MIN y STATION_DOMAIN_MAX); la misión de un día usa el pool 200–229. Como todo corre con red host, el aislamiento por dominio es, dice el propio código, «obligatorio»: sin él, dos pases simultáneos se mezclarían y cada controlador recibiría la referencia del otro.
El programa serializa en CDR los mensajes del lazo campo a campo, calcula el ancho de banda de cada tópico a 20 Hz y tabula los puertos de descubrimiento de los dominios que usa la Estación.
Lanzas dos corridas de atp_loop a la vez en la misma máquina, ambas con ROS_DOMAIN_ID=42. ¿Qué ocurre?
El laboratorio arranca en el escenario «atp_loop (PID)» con step_s en 0.05 s, time_scale en 1 y 2 juntas: la tabla de la derecha debe mostrar 20 Hz en el lazo y un tamaño estimado de /joint_states del orden de los 108 bytes del ejemplo. Haz clic en el nodo pid_controller: se resaltan /joint_states y /atp/reference como entradas y /atp/torque como salida. Cambia al escenario «atp_loop (LQR + Kalman)» y mira cómo la caja del controlador cambia de nombre sin que cambie ningún tópico: eso es la IfCondition del lanzamiento. Baja step_s a 0.01 s y la tasa sube a 100 Hz y el ancho de banda se multiplica por cinco. Por último, elige «Dos corridas, mismo dominio»: la lectura de diafonía se pone en rojo con los mensajes ajenos recibidos; pasa a «Dos corridas, dominios 100 y 101» y la diafonía cae a cero.
ipc: host), que cambian la latencia real pero no la estructura del grafo./atp/torque. En una estación real se cifraría y autenticaría con SROS2.El grafo ya tiene forma. La lección 2 se pregunta qué garantías da cada arista: si un mensaje puede perderse, si un suscriptor que llega tarde ve el pasado, y cuándo un tópico no basta y hace falta un servicio o una acción.
Cierre de la lección
Sigue el recorrido de la lección paso a paso.
Con una cuenta desbloqueas el cuestionario, el foro de dudas y el tutor con IA de esta lección, además del registro de progreso y el certificado verificable al terminar «ROS 2 aplicado: la Estación ATP de punta a punta».