ROS Index
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/PRBonn/rko_slam.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2026-09-29 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| rko_slam | 0.0.1 |
README
rko_slam
ROS2 LiDAR-inertial SLAM and multi-session alignment
A drive that returns to where it started, with rko_lio, and with rko_slam running on top of it
Quick start
rko_slam runs on rko_lio, my LiDAR-inertial odometry, or on your own odometry. Build it with rko_lio:
cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam
What it needs
- A LiDAR (
sensor_msgs/PointCloud2with per-point timestamps) and an IMU (sensor_msgs/Imu). - The LiDAR and IMU frames linked to your base frame on TF, e.g. by your URDF.
Run
odometry_and_slam.launch.py starts rko_lio and rko_slam together and finds the LiDAR and IMU topics and your base
frame by itself. Start your robot, then:
ros2 launch rko_slam odometry_and_slam.launch.py rviz:=true
From a bag, in two terminals, bag first:
ros2 bag play <bag> --clock
ros2 launch rko_slam odometry_and_slam.launch.py use_sim_time:=true rviz:=true
If your setup differs:
| Your setup | Do this |
|---|---|
Base frame named other than base_link, base_footprint or base
|
base_frame:=<yours> |
| Several LiDAR or IMU topics, e.g. the LiDAR driver’s own IMU | an rko_lio config file naming yours and your base frame, below |
LiDAR and IMU messages share one frame_id and no TF links it to a base frame, e.g. a Livox with its built-in IMU |
an rko_lio config file with identity extrinsics, below |
| Topics or TF take over 10 s to appear | autodetect_timeout:=<seconds> |
Something else already publishes odom <- <your base frame>, e.g. robot_localization or the bag’s /tf
|
turn it off, or run with your own odometry, below |
An rko_lio config file, passed with rko_lio_config_file:=<file>, replaces the autodetection
(all keys):
lidar_topic: /livox/lidar
imu_topic: /livox/imu
# LiDAR and IMU in one frame, no TF
base_frame: livox_frame
extrinsic_lidar2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
extrinsic_imu2base_quat_xyzw_xyz: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
With your own odometry
slam.launch.py starts rko_slam alone, on any locally consistent odometry that publishes odom <- base_link on TF:
```bash
File truncated at 100 lines see the full file