Adquiriendo señal…
Adquiriendo señal…
Lección 3 de 12· Control y estimación
0 de 12 lecciones · 0 %
Un experimento que no se puede repetir no es un experimento. En Sistemas APT (sistemas-apt) el lazo PID del pase cenital se simulaba en un bucle for de Python: el paso siempre se calculaba después del y con los datos del mismo instante, y el resultado era idéntico cada vez. En la Estación ese bucle está repartido en cinco procesos que se hablan por DDS. Si cada uno corre a su ritmo, la referencia del instante puede llegar al controlador después de la medida del instante , y el controlador, con prisa, la empareja con la referencia anterior. El resultado depende entonces de cuánto cargaba la CPU en ese momento. En Sistemas distribuidos espaciales (sistemas-distribuidos-espaciales) esto se llama orden causal y se resuelve con relojes lógicos; la Estación lo resuelve con un reloj simulado en lockstep, definido en src/atp_ros/atp_ros/sim_clock.py y en el contrato docs/CONTRATO.md §8.
Todo nodo de ROS 2 tiene un reloj. Con el parámetro use_sim_time:=true, ese reloj deja de leer la hora del sistema y pasa a leer el último mensaje del tópico /clock (rosgraph_msgs/Clock). self.get_clock().now(), los sellos header.stamp y los temporizadores creados con create_timer avanzan entonces al ritmo que marque quien publique /clock. En atp_loop.launch.py todos los nodos del lazo reciben {'use_sim_time': True} y uno solo, sim_clock, publica el tiempo.
Lo que no basta es publicar /clock a un ritmo fijo de pared. Eso solo cambia la unidad de medida: si el controlador tarda más de un paso en responder porque la máquina está ocupada, el reloj sigue avanzando sin él.
La idea del lockstep es que el tiempo solo avanza cuando el lazo cerró el paso. sim_clock publica con = step_s = 0.05 s, y no publica hasta recibir en /atp/step_ack la confirmación del paso . La cadena de un paso, tal como la documenta el propio módulo:
/clock t_k -> mount_sim integra hasta t_k y publica /joint_states(t_k)
-> reference_generator publica /atp/reference(t_k)
-> pid_controller (estado y referencia con el MISMO sello) manda
-> mount_sim recibe el mando y confirma en /atp/step_ack(t_k)
-> /clock t_{k+1}
El núcleo del reloj cabe en dos métodos:
# src/atp_ros/atp_ros/sim_clock.py (recortado)
def on_ack(self, msg):
k = (msg.clock.sec * 1_000_000_000 + msg.clock.nanosec) // self.step_ns
self.acked = max(self.acked, int(k))
if not self.lockstep:
self.lockstep = True # primera confirmacion: el lazo esta cerrado
def tick(self): # temporizador de PARED cada 0.5 ms
now = time.monotonic()
if self.lockstep and self.acked < self.k:
if now - self.t_pub < self.timeout:
return # paso k sin confirmar: el tiempo NO avanza
if self.modo_lockstep and not self.lockstep and self.k >= 1:
return # compuerta de arranque
escala = self.scale if self.scale > 0 else (0.0 if self.lockstep else 1.0)
if escala > 0:
t_sig = (self.k + 1) * self.step_ns * 1e-9
if (now - self.wall0) * escala < t_sig:
return # time_scale solo LIMITA la velocidad
self.k += 1
self.publish()
Tres detalles valen oro. El temporizador es de pared (time.monotonic()): el reloj simulado no puede despertarse a sí mismo. time_scale solo frena: con time_scale:=1 el tiempo simulado no adelanta al de pared, y con time_scale:=0 el reloj avanza en cuanto llega la confirmación. Y hay un latido: mientras espera, sim_clock repite el instante actual cada 0.2 s de pared para el nodo que haya descubierto /clock tarde.
docs/CONTRATO.md §8 hace del lockstep una obligación para todo nodo nuevo:
header.stamp lleva el mismo now con que se calculó el valor; no se llama a now() dos veces./atp/pass_done.wait_nodes anuncian en /atp/listo (transient_local) que cada una de sus suscripciones ya tiene publicador. atp_ros.nodo.correr lo hace solo.time_scale (1 en el banco HIL) y el monitor empareja con lo último disponible, avisándolo en el registro.La regla 2 está escrita en pid_controller.py. El controlador guarda las referencias por sello en un diccionario y solo calcula cuando encuentra la pareja exacta; si no, deja la medida pendiente:
# src/atp_ros/atp_ros/pid_controller.py (recortado)
def on_meas(self, msg):
s, meas = _sello(msg), np.array(msg.position[:2])
if s in self.refs:
self.pares['exacto'] += 1
self.control(s, meas, self.refs[s])
elif self.ref_ultima is not None and self.refs and max(self.refs) > s:
self.pares['respaldo'] += 1 # la de este instante ya no llegara
self._avisar(s, 'referencia mas nueva que el estado')
self.control(s, meas, self.ref_ultima)
else:
self.meas_pend = (s, meas) # esperar a su referencia
Y responde siempre con el sello del estado al que responde, porque mount_sim solo confirma el paso si el mando es para su instante. El contador pares (exactos frente a respaldo) es el termómetro del lockstep: en una corrida sana, todos los emparejamientos son exactos.
Sea una referencia que avanza a velocidad constante , , y una montura que la sigue perfectamente, . El controlador debería ver error cero. Supón que en el paso la referencia de no ha llegado y empareja la medida de con la referencia de . El error que calcula es
Un error que no existe, de módulo , al que el controlador responde con par real. Con la velocidad de acimut del pase N2 (9 °/s, README.md) y el paso de la Estación:
Es veintiséis veces el error de seguimiento que la Estación mide en ese mismo pase (0.017° rms, escalón N2).
Cuando ocurre a veces. Si el emparejamiento falla al azar en una fracción de los pasos, el error espurio es una variable de Bernoulli que vale con probabilidad y con probabilidad . Su media y su valor cuadrático medio son
Con : sesgo medio y valor eficaz . Y como depende de la carga de la máquina en cada corrida, dos corridas iguales dan números distintos: se pierde el determinismo.
time_scale:=0 da lo mismo que time_scale:=1En lockstep, el estado en es una función de tres cosas: el estado en , el mando calculado con datos sellados en y la entrada exógena en (referencia y semillas fijas). Ninguna depende del tiempo de pared. Por inducción sobre , toda la trayectoria es la misma sea cual sea la velocidad a la que el reloj de pared deja avanzar los pasos: time_scale cambia cuándo se calcula cada paso, no qué se calcula. Por eso la escalera de validación corre a máxima velocidad (time_scale:=0) y su cifra vale para tiempo real.
scripts/validar.sh lo comprueba de la forma más brutal posible: lanza la misma corrida dos veces con grabador y compara los archivos byte a byte.
# scripts/validar.sh, nivel det (recortado)
lanzs=("atp_loop.launch.py el_max:=85 mask:=70 time_scale:=0" "atp_autotrack.launch.py autotrack:=true")
for caso in "${lanzs[@]}"; do
rm -rf /tmp/det; for i in 1 2; do
timeout 900 ros2 launch atp_ros $caso record_dir:=/tmp/det/$i > /tmp/det_$i.log 2>&1
done
if cmp -s /tmp/det/1/telemetry.jsonl /tmp/det/2/telemetry.jsonl && cmp -s /tmp/det/1/metrics.json /tmp/det/2/metrics.json; then
echo "DETERMINISTA ($caso): ..."
else echo "NO DETERMINISTA ($caso): difieren"; fi
done
cmp -s no tolera ni un bit de diferencia. Pasa solo si las cinco reglas se cumplen a la vez: un nodo que empareje por llegada, o un grabador que pierda el principio del pase, rompe la igualdad.
El programa simula un eje de la montura de la Estación ( kg·m², N·m·s/rad, tope de 8 N·m) con el PID de pid_controller.py (kp 25, ki 2, kd 8) siguiendo una rampa de 9 °/s durante 20 s, en lockstep y en modo libre con una carga de CPU del 60 % que hace que el 18 % de los pasos usen la referencia anterior. Repite cinco corridas con semillas distintas y compara.
En lockstep las cinco corridas dan el mismo valor eficaz hasta el último decimal, y la dispersión es exactamente cero. En modo libre cada corrida empareja mal entre 64 y 82 pasos de 400 y el valor eficaz se dispersa unas tres centésimas de grado: el lazo filtra parte del error espurio, por eso el valor queda algo por debajo de los 0.191° del modelo de Bernoulli.
En modo libre, el controlador usa en un paso la referencia de con la medida de , siguiendo una rampa de 9 °/s con pasos de 0.05 s. ¿Qué error espurio ve?
El laboratorio arranca con modo en lockstep, step_s 0.05 s, velocidad 9 °/s, carga de CPU 60 % y 5 corridas. La lectura de error teórico muestra , la de pasos emparejados mal marca cero y las cinco curvas de error de la derecha se superponen en una sola: dispersión 0. Cambia el modo a libre (escenario «Libre con CPU cargada»): en la cadena de la izquierda algunos mensajes se marcan en ámbar porque se emparejaron con el sello anterior, y las cinco curvas se separan. Sube la carga de CPU a 100 % y la dispersión crece; súbela con el step_s en 0.1 s y el error teórico se duplica a 0.9°. Vuelve a lockstep y prueba «Lockstep a máxima velocidad (time_scale 0)» frente a «Lockstep ×1»: cambia el tiempo de pared estimado, no la curva.
rclpy.spin; con un MultiThreadedExecutor las retrollamadas de un mismo nodo pueden entrelazarse y hay que proteger el estado compartido.Con el tiempo bajo control, ya se puede hablar de geometría sin miedo a que el número cambie con la carga. La lección 4 describe la montura como un árbol de marcos y calcula el error de apuntamiento como un ángulo entre dos vectores.
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».