# Husky UAL LiDAR-Inertial Dataset, sequence 2026-11-16: wheel odometry + IMUs + RTK GNSS

A 38 minute, 1.46 km drive of a Clearpath Husky A200 around the University of Almería
campus (Spain), recorded on 2026-11-16 with ROS 2 Jazzy. This release contains only the
proprioceptive and GNSS sensors (no LiDAR, no cameras): it is the dataset of the MOLA
tutorial on fusing wheel odometry, IMUs and RTK GNSS with the MOLA state estimation
smoother.

- Dataset page (all sequences): https://w3.ual.es/~jlblanco/datasets/husky-ual-lidar-inertial-dataset/
- Tutorial: https://docs.mola-slam.org/latest/tutorial-wheels-imu-gnss-fusion.html
- MOLA: https://github.com/MOLAorg/mola

## License

This dataset is released under the
[Creative Commons Attribution 4.0 International license (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/).
You may share and adapt it for any purpose, including commercially, as long as you give
appropriate credit. Please cite it as:

> J.L. Blanco-Claraco, "Husky UAL LiDAR-Inertial Dataset", University of Almería, 2026.
> https://w3.ual.es/~jlblanco/datasets/husky-ual-lidar-inertial-dataset/

The scripts in `tutorial/` are released under the BSD 3-Clause license, like MOLA.

## Contents

| Path | Description |
|---|---|
| `husky_2026-11-16_campus_wheels_imu_gnss/` | ROS 2 bag (MCAP, uncompressed, 330 MB) |
| `husky_2026-11-16_campus_wheels_imu_gnss.zip` | The same bag, as a single zip file (70 MB) |
| `tutorial/run_fusion.sh` | Replays the bag through the MOLA smoother (see the tutorial) |
| `tutorial/gnss_outage_relay.py` | Simulates GNSS outages (drops the fixes 30 s of every 60 s) |
| `tutorial/evaluate.py` | Error against the RTK fixes, and comparison with dead reckoning |
| `SHA256SUMS` | Checksums |

## Sensors and topics

All topics are under the robot namespace `/a200_0812`.

| Topic | Type | Rate | Sensor |
|---|---|---|---|
| `platform/odom` | `nav_msgs/Odometry` | 20 Hz | Wheel odometry (Clearpath base driver, skid steering, planar) |
| `platform/joint_states` | `sensor_msgs/JointState` | 20 Hz | Wheel encoders |
| `taobotics/imu` | `sensor_msgs/Imu` | 150 Hz | HandsFree (Taobotics) 9-axis IMU, aligned with `base_link` |
| `taobotics/imu/mag` | `sensor_msgs/MagneticField` | 150 Hz | Its magnetometer (not calibrated: its azimuth is not reliable) |
| `ouster/imu` | `sensor_msgs/Imu` | 100 Hz | IMU inside the Ouster OS0-32 LiDAR (LiDAR data not included) |
| `gnss/f9p` | `sensor_msgs/NavSatFix` | 1 Hz | u-blox ZED-F9P (EVK-F9P-01), RTK corrections from an NTRIP caster |
| `gnss/f9p/weighted` | `sensor_msgs/NavSatFix` | 1 Hz | The same fixes, with realistic covariances (see below) |
| `gnss/ublox` | `sensor_msgs/NavSatFix` | 1 Hz | Low-cost u-blox 7 receiver (meter-level) |
| `tf` | `tf2_msgs/TFMessage` | 50 Hz | `odom -> base_link` from the robot's own EKF (not needed by the tutorial) |
| `tf_static` | `tf2_msgs/TFMessage` | | Sensor poses (`base_link -> gps_f9p`, `os_sensor`, `os_imu`, `imu`, ...) |

Notes:

- **GNSS antenna**: `gps_f9p` is at (-0.05, 0.19, 0.90) m in `base_link`. The NavSatFix
  altitude is ellipsoidal (WGS84).
- **GNSS covariances**: the F9P driver reports ~1 cm sigmas both in RTK fixed and RTK float,
  while the real errors in float are 0.5-2 m. `gnss/f9p/weighted` replaces them by
  floors per carrier solution: 3 cm (RTK fixed), 0.5 m (float) and 3 m (no carrier
  solution). The RTK fixed fixes (3 cm sigma, 2135 of 2245) are the ground truth used by
  `tutorial/evaluate.py`.
- **GNSS time stamps**: the F9P fixes are stamped at their fix epoch (UTC of the receiver
  solution), not at the USB reception time (0.07-0.38 s later).
- **Clock**: the robot PC follows the F9P time pulse (chrony + PPS), so all stamps are UTC.
- **Wheel odometry**: the robot loses encoder counts at some point around 34 min (speed
  under-reported for ~20 s): a realistic failure the estimator must survive.
- The transforms published by the robot's own localization at recording time (`map`,
  `enu`, `utm` frames) were removed.

## Quick start

```bash
# MOLA (with mola_state_estimation_smoother) installed and sourced:
cd tutorial
./run_fusion.sh ../results/fusion          # replay (add RATE=4 for 4x real time)
python3 evaluate.py ../results/fusion      # errors and plots
```

See the tutorial for the explanation of each step and parameter.
