LeoOS
LeoOS – definition
LeoOS is the software environment used with Leo Rover for mobile robotics work on a small outdoor UGV platform. In practice, the term refers to the operating system image, device configuration, ROS 2 middleware setup, hardware interfaces, and support packages that make the rover usable as a research and education platform. It is not a separate real-time operating system in the narrow academic sense. It is a platform software stack built around Linux on Raspberry Pi-class compute hardware, with ROS 2 as the main robotics middleware layer.
In the context of mobile robotics, LeoOS provides the baseline needed to access drivetrain control, telemetry, sensors, networking, and remote development workflows on Leo Rover. It sits between the hardware and higher-level autonomy software. This means LeoOS does not by itself provide full autonomy, SLAM, or navigation. Those functions are added as ROS 2 packages and application-level nodes. This distinction matters because Leo Rover supports ROS 2 natively, but it is not an autonomous rover out of the box.
For engineers, LeoOS is best understood as a reproducible system image and integration layer for a differential-drive UGV. It reduces bring-up time and standardizes access to hardware resources. On Leo Rover, that includes wheel motion control, robot state reporting, camera and sensor integration paths, and compatibility with standard ROS 2 workflows such as topics, services, actions, TF, URDF, and launch files.
How LeoOS fits into the ROS 2 software stack
LeoOS is relevant because ROS 2 systems depend on a correct base layer. A UGV needs kernel support, user-space drivers, network services, time synchronization, and device naming before autonomy software can work reliably. LeoOS addresses that lower layer and exposes the rover to ROS 2 in a structured way.
On a typical Leo Rover deployment, the software layers can be described as follows.
- Base OS – Linux running on the onboard Raspberry Pi compute unit.
- Hardware interface layer – drivers and services for motor control, battery telemetry, embedded controller communication, and connected peripherals.
- ROS 2 integration layer – nodes, launch files, message interfaces, TF tree, URDF model, diagnostics, and topic naming.
- Application layer – SLAM, Nav2, teleoperation, perception, logging, custom autonomy, and experiment code.
In ROS 2 terms, LeoOS should expose interfaces that are familiar to any mobile robot engineer. These usually include velocity command input, odometry output, transform publication, diagnostic data, and optional camera or IMU streams. For a differential-drive robot, the most important interfaces are listed below.
| Function | Typical ROS 2 interface | Common message type |
|---|---|---|
| Velocity command | /cmd_vel | geometry_msgs/msg/Twist |
| Odometry | /odom | nav_msgs/msg/Odometry |
| TF transform | /tf, /tf_static | tf2_msgs/msg/TFMessage |
| Joint states | /joint_states | sensor_msgs/msg/JointState |
| Battery / diagnostics | /diagnostics | diagnostic_msgs/msg/DiagnosticArray |
| IMU | /imu/data | sensor_msgs/msg/Imu |
| Laser scan | /scan | sensor_msgs/msg/LaserScan |
The message types above are standard ROS interfaces documented in the ROS ecosystem. Their exact availability on a given Leo Rover depends on the installed hardware and enabled packages.
Core functions on a Leo Rover platform
LeoOS matters because a mobile rover must solve several low-level integration problems before high-level robotics code can run. The software environment on Leo Rover is expected to provide stable defaults for these tasks.
- Drivetrain access – translation of ROS 2 velocity commands into wheel actuation for a 4-wheel differential-drive chassis.
- Odometry pipeline – wheel encoder or controller-derived motion estimation published to the ROS graph.
- Robot model support – URDF description for visualization, TF consistency, and simulation alignment.
- Networked operation – remote SSH access, ROS 2 communication over LAN or Wi-Fi, and developer-friendly deployment.
- Sensor onboarding – integration path for LiDAR, IMU, RGB or depth cameras, and GNSS/RTK modules when used.
- Diagnostics – battery state, communication health, and device status monitoring.
For Leo Rover, these functions are especially important because the rover is often used in labs, classrooms, and field experiments where repeatable setup is more important than raw compute performance. The onboard Raspberry Pi is sufficient for many ROS 2 tasks, but demanding SLAM or vision pipelines may require optimization or offloading.
LeoOS in autonomous navigation workflows
LeoOS is not equivalent to a navigation stack. It provides the foundation required by navigation software. On ROS 2, the most common autonomous navigation framework is Nav2. To use Nav2 on Leo Rover, the system must supply at least a robot model, TF tree, odometry, velocity control, and one or more perception inputs such as a 2D LiDAR or depth sensor.
A minimal Nav2-oriented setup typically expects the following frame relationships in line with ROS conventions and REP guidance.
- map – global frame produced by localization or SLAM.
- odom – locally continuous frame for odometry.
- base_link – robot body reference frame.
- sensor frames – for example
laser_frame,imu_link, or camera optical frames.
When LeoOS is configured correctly, a user can add SLAM or localization packages without rewriting the low-level rover interface. This is the main architectural benefit. It separates platform support from autonomy logic.
ros2 topic list
ros2 topic echo /odom
ros2 run tf2_tools view_frames
ros2 launch nav2_bringup navigation_launch.py
Hardware support and integration boundaries
LeoOS is tightly associated with Leo Rover, but the same engineering idea can be extended to larger UGVs such as Raptor Rover. The difference is scale, payload, and compute budget. Leo Rover is a compact outdoor differential-drive platform with a Raspberry Pi-based onboard computer. Raptor Rover is a larger platform designed for higher payload applications. That changes the preferred sensor set, power architecture, and often the compute stack, but not the general role of the system software.
In practice, the integration boundaries are these.
- Leo Rover – suitable for ROS 2 education, algorithm prototyping, teleoperation, lightweight SLAM, and moderate perception pipelines.
- Raptor Rover – better suited when payload mass, larger LiDARs, more cameras, or more powerful compute are required.
LeoOS should therefore be read as a platform-specific environment for Leo Rover first, not as a generic robotics distribution for all Fictionlab platforms.
Example ROS 2 configuration pattern
Most users interact with LeoOS through launch files and parameter files rather than direct driver calls. A simple configuration pattern for differential-drive control and sensor use may look like this.
leo_base:
ros__parameters:
publish_odom: true
odom_frame: odom
base_frame: base_link
cmd_vel_timeout: 0.5
imu_filter:
ros__parameters:
use_mag: false
world_frame: enu
lidar_node:
ros__parameters:
frame_id: laser_frame
scan_rate: 10.0
The exact parameter names depend on the packages used, but the pattern is standard: base interface, TF naming, sensor frame IDs, and safety timeouts.
Limitations and engineering trade-offs
LeoOS simplifies access to the rover, but it does not remove the normal constraints of embedded robotics. The Raspberry Pi compute unit limits CPU headroom for heavy perception. Wireless networking can introduce latency or packet loss. Outdoor odometry on differential-drive platforms degrades on loose terrain, wet grass, gravel, or slopes. These are platform-level realities, not LeoOS defects.
There is also an important software trade-off between convenience and determinism. A Linux plus ROS 2 stack is flexible and well supported, but it is not a hard real-time control environment by default. For most research and education use cases on Leo Rover this is acceptable. For tight control loops, the architecture should keep fast motor control on embedded controllers and use ROS 2 at the supervisory layer.
Normative references and standards context
The technical interpretation of LeoOS depends on ROS standards and common robotics conventions rather than a single formal standard. Relevant references include ROS 2 core documentation on nodes, topics, services, actions, QoS, TF2, URDF, and launch. ROS REPs are also important for naming and coordinate conventions, especially frame semantics used in mobile robots. In addition, hardware behavior must follow the specifications of the installed devices, such as LiDAR scan rate, IMU update rate, or camera transport requirements from the vendor documentation.
When moving from ROS 1 to ROS 2, users should note differences in middleware, launch system, parameter handling, and QoS behavior. Leo Rover is described here in the ROS 2 context, specifically Humble or newer, because that is the native support path. Any ROS 1-oriented description of LeoOS should therefore be treated as legacy unless explicitly documented for a maintained bridge or older image.
See also
- ROS 2
- Nav2
- URDF
- Differential drive robot