Glossary

Edge computing

Edge computing – definition

Edge computing is a system architecture in which data processing is performed close to the data source, on the robot or near the robot, instead of sending all raw data to a remote server or cloud. In mobile robotics, this usually means running perception, sensor fusion, control, and navigation workloads on an onboard computer such as a Raspberry Pi, NVIDIA Jetson, or x86 IPC mounted on the UGV.

For a ROS 2-based unmanned ground vehicle, edge computing reduces end-to-end latency, lowers bandwidth usage, and improves availability when wireless connectivity is unstable or absent. This matters in field robotics, where a robot may operate in a greenhouse, tunnel, construction site, outdoor test track, or planetary analog environment with intermittent network access. In that context, edge computing is not a generic IT term. It is a practical design choice that determines whether a robot can localize, avoid obstacles, and keep moving when the network link drops.

On platforms such as Leo Rover and Raph Rover, edge computing typically covers the full onboard execution chain: sensor drivers, ROS 2 nodes, transforms defined according to REP 103 and REP 105, local mapping, state estimation, path planning, and low-level motor control. Cloud or remote systems can still be used for logging, fleet supervision, model training, or post-processing, but the safety-critical and time-sensitive loop stays on the robot.

Why edge computing matters on UGV platforms

A mobile robot produces continuous streams of data. LiDAR scans may arrive at 5-20 Hz, IMU messages at 100-400 Hz, wheel odometry at tens of Hz, and depth cameras at 15-90 fps depending on configuration. Transmitting all raw streams over Wi-Fi or LTE is often inefficient and may not be reliable enough for closed-loop autonomy.

In a UGV, the main reasons to move computation to the edge are the following.

  • Low latency – obstacle detection and velocity command generation must happen within tens of milliseconds, not after a round trip to a remote server.
  • Determinism – local execution avoids variable network jitter that degrades control and sensor fusion.
  • Bandwidth reduction – local nodes can publish compact outputs such as nav_msgs/msg/Odometry, obstacle data derived from sensor_msgs/msg/LaserScan, or compressed maps instead of raw sensor streams.
  • Resilience – autonomy can continue during packet loss, roaming between access points, or complete network outage.
  • Privacy and data governance – some deployments cannot stream full camera feeds off the robot.

For Leo Rover, edge computing is especially relevant because the platform uses an onboard Raspberry Pi as the default compute unit and supports ROS 2. That hardware can handle drivers, teleoperation, diagnostics, basic SLAM, and lightweight autonomy, but compute budgets must be planned carefully. Raph Rover, being a larger payload-capable platform, is a better fit for heavier edge workloads such as multi-sensor fusion, GPU vision pipelines, or larger local maps.

How edge computing works in ROS 2

ROS 2 is well suited for edge deployments because it commonly uses DDS as its communication middleware and supports distributed execution across multiple processes and machines. A robot can run all critical nodes onboard and expose only selected topics, services, or logs to external systems.

In practice, an edge-oriented ROS 2 stack on a UGV often includes these layers.

  • Hardware interface – camera, LiDAR, IMU, GNSS, motor driver, and battery telemetry nodes.
  • State estimation – typically robot_localization publishing odom-frame estimates and optionally map-aligned estimates via the map -> odom transform.
  • Perception – point cloud filtering, obstacle extraction, image inference, terrain classification, or fiducial detection.
  • Navigation – Nav2, local costmap generation, controller server, behavior tree execution.
  • Diagnostics and lifecycle management – health monitoring, startup ordering, and fault recovery.

ROS frame conventions should remain consistent with REP 103 for units and coordinate conventions and REP 105 for standard mobile platform frames such as base_link, odom, and map. These conventions are important in edge systems because many onboard components exchange time-sensitive transforms.

ros2 topic hz /imu/data
ros2 topic hz /scan
ros2 run tf2_ros tf2_echo odom base_link
ros2 lifecycle set /controller_server activate

An edge deployment also depends on QoS settings. For example, LiDAR and camera topics may use best-effort transport to reduce blocking, while control and state topics often require reliable delivery. In ROS 2, these choices materially affect CPU load, memory pressure, and behavior under weak wireless links.

Key parameters and metrics

Edge computing on a robot should be evaluated with measurable system-level metrics, not only with CPU utilization. The most useful metrics are listed below.

Metric Typical range on UGV Why it matters
Control loop latency 5-50 ms Affects stability and collision avoidance response
IMU rate 100-400 Hz Supports state estimation and motion compensation
LiDAR scan rate 5-20 Hz Sets obstacle update frequency
Depth camera frame rate 15-60 fps Impacts visual perception and VIO pipelines
CPU utilization < 80% sustained target Leaves margin for bursts and recovery
Memory headroom 20-30% free target Reduces swap risk and node instability
Dropped messages As low as possible Indicates overload or QoS mismatch

A useful engineering simplification is to treat the onboard compute budget as a real-time resource balance:

available compute margin = total compute capacity - sum(node runtime demand) - peak burst reserve

If the margin approaches zero, navigation performance becomes unstable under sensor bursts, map updates, or logging spikes.

Hardware support and deployment patterns

The hardware selected for edge computing depends on the payload, perception stack, and power budget. A Raspberry Pi-class computer is suitable for lightweight ROS 2 nodes, teleoperation, simple autonomy, and educational setups. GPU-enabled modules are preferred when the robot runs neural inference, dense depth processing, or multi-camera perception.

On Leo Rover, a common pattern is to keep core ROS 2 services onboard and attach selected sensors such as LiDAR, IMU, or camera via USB or Ethernet. Because Leo Rover is not autonomous out of the box, full autonomy requires integration of a navigation stack, transforms, and sensor calibration. On Raph Rover, the larger payload envelope allows more capable compute hardware, additional power conversion, and thermal management for sustained field workloads.

/**:
  ros__parameters:
    use_sim_time: false
    publish_rate: 30.0
    transform_timeout: 0.2

Use cases with Leo Rover and Raph Rover

Edge computing is easiest to understand through concrete UGV tasks. On Leo Rover, the onboard computer can run teleoperation, camera streaming, wheel odometry, IMU fusion, and 2D LiDAR-based local obstacle avoidance. This is enough for lab navigation experiments, student projects, and compact inspection scenarios where power and mass are constrained.

On Raph Rover, edge computing can scale to heavier field robotics workloads. Examples include fused GNSS/RTK plus IMU localization, local 3D elevation mapping, multisensor inspection, and semantic perception for rough outdoor terrain. The larger platform is better suited to carrying the compute, storage, and cooling needed for those pipelines.

In both cases, the edge device should execute the autonomy-critical path locally. Remote operators may still use SSH, VPN, ROS 2 bridges, or recorded bags for supervision and analysis.

Limitations and trade-offs

Edge computing is not free of constraints. The main trade-off is between onboard autonomy and onboard resource limits. More local processing improves independence from the network, but it increases power draw, thermal load, and integration complexity.

Typical failure modes include CPU throttling, USB bus saturation, timestamp drift, DDS discovery issues across mixed networks, and overloaded storage during rosbag recording. On smaller robots such as Leo Rover, these issues appear earlier because the compute and power budget are tighter. For this reason, edge deployments should be profiled with realistic sensor rates and tested under degraded connectivity, not only on the bench.

Normative references and standards

The term edge computing itself is broader than robotics, but in ROS-based UGV systems the implementation should align with official ROS conventions and vendor specifications for the selected hardware.

  • REP 103 – Standard Units of Measure and Coordinate Conventions
  • REP 105 – Coordinate Frames for Mobile Platforms
  • ROS 2 documentation on nodes, QoS, DDS, lifecycle, and launch systems – source: docs.ros.org
  • IEEE usage of edge computing in distributed cyber-physical and IoT systems – source: IEEE publications and standards ecosystem
  • Vendor specifications for onboard compute modules such as Raspberry Pi and NVIDIA Jetson, and for sensors such as Intel RealSense, Slamtec LiDAR, and GNSS/RTK receivers

See also

  • ROS 2
  • SLAM
  • LiDAR
  • Sensor fusion