ROS 2

Example 1 A 30 Hz camera and a hotspot detector that takes 50 ms

The thermal camera publishes at 30 Hz for 3 s. The hotspot detector processes each image in 50 ms (20 images per second). Compare keep last depth 1 with depth 10 (a simple queue model, ignoring network transfer time).

from collections import deque

PUB_HZ = 30          # camera publishes at 30 Hz
PROC = 0.050         # subscriber takes 50 ms per image
DURATION = 3.0

def run(depth):
    pubs = [k / PUB_HZ for k in range(int(DURATION * PUB_HZ))]
    q = deque()
    dropped, done, lat = 0, 0, []
    t_free = 0.0
    i = 0
    while i < len(pubs) or q:
        t_next = pubs[i] if i < len(pubs) else float("inf")
        if q and t_free <= t_next:
            stamp = q.popleft()
            start = max(t_free, stamp)
            lat.append(start + PROC - stamp)
            t_free = start + PROC
            done += 1
        else:
            if len(q) == depth:
                q.popleft()          # KEEP_LAST drops the oldest message
                dropped += 1
            q.append(t_next)
            i += 1
    lat.sort()
    return done, dropped, sum(lat) / len(lat), lat[len(lat) // 2]

for depth in [1, 10]:
    done, dropped, avg, med = run(depth)
    print(f"depth={depth:>2}  processed {done}  dropped {dropped}  "
          f"mean latency {avg*1000:.0f} ms  median {med*1000:.0f} ms")

depth= 1  processed 61  dropped 29  mean latency 66 ms  median 67 ms
depth=10  processed 70  dropped 20  mean latency 334 ms  median 367 ms

Because the subscriber is slower than the publisher, some images must be dropped whatever the depth. The difference is that depth 10 makes the processed image an old one that waited in the queue about $10/30$ s plus processing time, so latency is almost 0.4 s, while depth 1 always gets the latest image with latency around 67 ms. At 1 m/s, that difference puts the hotspot position about 30 cm off. Short queues suit real-time control and detection; data that must be complete, such as event logs, should use reliable delivery and long queues.

Example 2 A 15 Hz camera and a 10 Hz LiDAR

The camera publishes at 15 Hz with slight timing jitter; the LiDAR publishes at 10 Hz starting 7 ms later, over 2 s (simulated data).

import numpy as np

rng = np.random.default_rng(3)
cam = np.arange(0, 2.0, 1/15) + rng.normal(0, 0.004, 30)    # camera 15 Hz
lidar = np.arange(0.007, 2.0, 1/10)                          # LiDAR 10 Hz

def pair(slop):
    pairs = []
    for t in lidar:
        j = np.argmin(np.abs(cam - t))
        if abs(cam[j] - t) <= slop:
            pairs.append((t, cam[j]))
    return pairs

for slop in [0.005, 0.020, 0.040]:
    p = pair(slop)
    gaps = [abs(a - b) * 1000 for a, b in p]
    print(f"slop {slop*1000:>2.0f} ms  paired {len(p)}/{len(lidar)}  "
          f"largest gap {max(gaps):.1f} ms")

slop  5 ms  paired 3/20  largest gap 3.2 ms
slop 20 ms  paired 10/20  largest gap 15.1 ms
slop 40 ms  paired 20/20  largest gap 34.1 ms

Because 15 and 10 Hz do not divide evenly, half the LiDAR scans have no image within 20 ms. A small slop gives few but well-timed pairs; a large slop pairs everything, but some pairs are 34 ms apart. If the UGV is turning at 30 degrees per second, 34 ms equals about 1 degree of heading error. Better than widening the slop is to trigger the sensors together or choose rates that divide evenly.