🌐 English · Korean

Every road. Every delivery.
4-Wheel Independent Swerve Drive Platform by ROBOTIS AI



Get Started »  ·  Packages »  ·  Architecture »

---

📌 Table of Contents

1. About
2. Packages
3. Architecture
4. Directory Structure
5. Getting Started
   • Prerequisites
   • Installation
6. Usage
   • Full Robot Bringup
   • Visualization
   • Teleoperation
   • Manual Velocity Commands
   • Navigation
   • Gazebo Simulation
7. Hardware Specifications
8. ROS 2 Topics & Interfaces
9. License
10. Contact
11. Contributors

---

🤖 About

AntBot is a production-ready, open-source software stack for the ROBOTIS AI AntBot autonomous delivery robot, a 4-Wheel Independent Swerve Drive platform built for last-mile delivery.

Go anywhere. Open everywhere. — Read the full story →

This repository provides a complete, modular software stack to operate the robot:

• Swerve-drive controller — inverse kinematics, motion profiling, and odometry
• Hardware interface — ANT-RCU board via Dynamixel Protocol 2.0
• Multi-camera driver — V4L2, USB, and RGB-D
• Sensor integration — 2D/3D LiDAR, IMU, and GNSS
• Complete URDF model — sensor frames and visual meshes
• One-command bringup — launch the entire robot system

(back to top)

---

📦 Packages

Package	Description
antbot	Meta-package for the AntBot project
antbot_bringup	Launch files for all hardware drivers, controllers, and sensors
antbot_description	URDF / Xacro robot model with sensor frames and meshes
antbot_swerve_controller	ros2_control swerve-drive controller with IK, motion profiling, and odometry
antbot_hw_interface	ros2_control SystemInterface plugin for the RCU board
antbot_libs	Shared C++ library for Dynamixel Protocol 2.0 communication
antbot_interfaces	Custom ROS 2 message and service definitions
antbot_camera	Multi-driver camera package (V4L2 / USB / RGB-D)
antbot_imu	IMU driver with complementary filter and auto-calibration
antbot_teleop	Keyboard/joystick teleoperation with holonomic velocity control
antbot_navigation	Nav2 navigation stack with SLAM, localization (EKF), and path planning
antbot_gazebo	Ignition Gazebo simulation environment with ros2_control integration

External sensor drivers included: vanjee_lidar_sdk (3D LiDAR) and vanjee_lidar_msg (LiDAR message definitions).

(back to top)

---

🏛️ Architecture

System Block Diagram (click to expand)

  antbot_bringup                    antbot_description
  (launch files)                    (URDF / Xacro, meshes)
       │                                   │
       │  launches                         │  robot_description
       ▼                                   ▼
┌──────────────────────────────────────────────────────┐
│               ros2_control Framework                 │
│             (Controller Manager)                     │
│                                                      │
│   antbot_swerve_controller  ◄──── /cmd_vel           │
│   (IK, motion profiling, odometry)                   │
│             ├── /odom                                │
│             └── /tf                                  │
└───────────────────────┬──────────────────────────────┘
                 read() │ write()
                        ▼
          ┌───────────────────────────────┐
          │   antbot_hw_interface         │
          │   (BoardInterface plugin)     │
          │                               │
          │   Wheel ─ Steering            │
          │   Encoder ─ Motor             │
          │   Battery ─ Ultrasound        │
          │   Cargo ─ Headlight ─ Wiper   │
          └──────────────┬────────────────┘
                         │
          ┌──────────────▼────────────────┐
          │   antbot_libs                 │      ┌─────────────────────┐
          │   Communicator                │      │   antbot_imu        │
          │   ControlTableParser          │      │   (ImuNode)         │
          └──────────────┬────────────────┘      └──────────┬──────────┘
                         │                                  │
          ┌──────────────▼──────────────────────────────────▼───┐
          │            Serial (Dynamixel Protocol 2.0)          │
          └──────────────┬──────────────────────────────────┬───┘
                         │                                  │
                  ┌──────▼──────┐                    ┌──────▼──────┐
                  │  ANT-RCU    │                    │  IMU Board  │
                  │  Motors x4  │                    │  Accel/Gyro │
                  │  Steering x4│                    └─────────────┘
                  │  Encoders   │
                  │  Battery    │
                  └─────────────┘

          ┌───────────────────────────────┐
          │   antbot_camera               │
          │   V4L2 / USB / RGB-D          │──── /sensor/camera/*/image_raw
          └───────────────────────────────┘

          ┌───────────────────────────────┐
          │   vanjee_lidar_sdk            │
          │   3D LiDAR                    │──── /sensor/lidar_3d/point_cloud
          │   2D LiDAR × 2                │──── /sensor/lidar_2d_{front,back}/scan
          └───────────────────────────────┘

Launch Dependency Graph

bringup.launch.py
 ├── robot_state_publisher.launch.py    →  URDF → /tf, /tf_static
 ├── controller.launch.py              →  ros2_control + swerve controller
 ├── imu.launch.py                     →  6-axis IMU
 ├── lidar_2d.launch.py                →  2× 2D LiDAR (USB serial)
 ├── lidar_3d.launch.py                →  3D LiDAR (Ethernet)
 ├── ublox_gps_node-launch.py          →  u-blox GNSS
 ├── camera.launch.py                  →  V4L2 + USB + RGB-D cameras
 └── teleop_joy.launch.py             →  DualSense joystick teleop

(back to top)

---

📂 Directory Structure

antbot/
├── antbot/                        # Meta-package
├── antbot_bringup/                # Launch files (bringup, view, controller, sensors)
├── antbot_description/            # URDF / Xacro model, meshes, RViz config
├── antbot_swerve_controller/      # Swerve-drive controller (IK, odometry, profiling)
├── antbot_hw_interface/           # ros2_control hardware plugin for ANT-RCU
├── antbot_libs/                   # Shared C++ library (Dynamixel comms, XML parsing)
├── antbot_interfaces/             # Custom ROS 2 message and service definitions
├── antbot_camera/                 # Multi-driver camera node (V4L2, USB, RGB-D)
├── antbot_imu/                    # IMU driver with complementary filter
├── antbot_teleop/                 # Keyboard/joystick teleoperation (Python)
├── antbot_navigation/             # Nav2 navigation (SLAM, EKF localization, path planning)
├── antbot_gazebo/                 # Ignition Gazebo simulation (worlds, URDF, controllers)
├── vanjee_lidar_sdk/              # Vanjee 3D LiDAR driver
├── vanjee_lidar_msg/              # Vanjee LiDAR message definitions
├── docs/                          # Documentation and images
├── scripts/                       # Utility scripts
│   └── setting.sh                 # Dependency installation script
└── additional_repos.repos         # External repository list for vcs import

(back to top)

---

🚀 Getting Started

Quick Start — Already have ROS 2 Humble installed?

mkdir -p ~/antbot_ws/src && cd ~/antbot_ws/src
git clone https://github.com/ROBOTIS-move/antbot.git
cd ~/antbot_ws/src/antbot && bash scripts/setting.sh
cd ~/antbot_ws && colcon build --symlink-install && source install/setup.bash
ros2 launch antbot_bringup bringup.launch.py

Prerequisites

• 
• 
• 

Installation

1. Create a workspace and clone the repository:

mkdir -p ~/antbot_ws/src && cd ~/antbot_ws/src
git clone https://github.com/ROBOTIS-move/antbot.git

2. Run the setup script to install dependencies (system tools, external repos, and ROS dependencies via rosdep):

cd ~/antbot_ws/src/antbot
bash scripts/setting.sh

3. Build the workspace:

cd ~/antbot_ws
colcon build --symlink-install

4. Source the workspace:

source ~/antbot_ws/install/setup.bash

💡 Tip: Add source ~/antbot_ws/install/setup.bash to your ~/.bashrc for automatic sourcing on every new terminal.

(back to top)

---

🎮 Usage

Full Robot Bringup

Launch the complete system — ros2_control, swerve controller, IMU, LiDAR, GPS, and cameras:

ros2 launch antbot_bringup bringup.launch.py

Visualization

Monitor all sensors with RViz (run on a separate PC):

ros2 launch antbot_bringup view.launch.py

Preview the URDF model (no hardware required):

ros2 launch antbot_description description.launch.py

Teleoperation

Drive the robot with your keyboard/joystick:

# Keyboard teleop (run in terminal)
ros2 run antbot_teleop teleop_keyboard

# Joystick teleop (DualSense, USB)
ros2 launch antbot_teleop teleop_joy.launch.py

Key bindings:

Key	Action
W / X	Forward / Backward
A / D	Strafe Left / Right
Q / E	Rotate CCW / CW
1 ~ 9	Speed Level
ESC	Quit

Joystick button bindings (DualSense):

Manual Velocity Commands

# Drive forward at 0.5 m/s
ros2 topic pub /cmd_vel geometry_msgs/msg/Twist \
  "{linear: {x: 0.5, y: 0.0, z: 0.0}, angular: {x: 0.0, y: 0.0, z: 0.0}}"

# Strafe right at 0.3 m/s
ros2 topic pub /cmd_vel geometry_msgs/msg/Twist \
  "{linear: {x: 0.0, y: -0.3, z: 0.0}, angular: {x: 0.0, y: 0.0, z: 0.0}}"

# Rotate in place at 1.0 rad/s
ros2 topic pub /cmd_vel geometry_msgs/msg/Twist \
  "{linear: {x: 0.0, y: 0.0, z: 0.0}, angular: {x: 0.0, y: 0.0, z: 1.0}}"

Navigation

SLAM mapping — build a map while driving:

ros2 launch antbot_navigation slam.launch.py

Autonomous navigation — navigate using a saved map:

ros2 launch antbot_navigation navigation.launch.py

EKF localization only:

ros2 launch antbot_navigation localization.launch.py

Gazebo Simulation

Run the full simulation without physical hardware:

ros2 launch antbot_gazebo gazebo.launch.py

Teleoperate in simulation:

ros2 run antbot_teleop teleop_keyboard

(back to top)

---

🔧 Hardware Specifications

Component	Specification
Drive Type	4-Wheel Independent Swerve Drive
Control Board	ANT-RCU (Dynamixel Protocol 2.0, ID 200)
Communication	USB Serial @ 4 Mbps
Wheel Motors	4× (M1–M4), range: −185 ~ 185 RPM
Steering Motors	4× (S1–S4), range: −56.2° ~ 56.2°
Cameras	1× Stereo RGB-D + 4× Mono (V4L2)
3D LiDAR	3D LiDAR (Ethernet)
2D LiDAR	2× 2D LiDAR (USB Serial)
IMU	6-axis (3-axis accelerometer + 3-axis gyroscope)
GNSS	u-blox GPS receiver
Battery	BMS monitored (voltage, current, SoC, temperature)

(back to top)

---

📡 ROS 2 Topics & Interfaces

Published Topics

Topic	Type	Description
/odom		Robot odometry from swerve controller
/tf		Transform tree
/imu/accel_gyro		IMU data (quaternion, angular velocity, linear acceleration)
/sensor/camera/*/image_raw		Camera image streams
/sensor/camera/*/camera_info		Camera calibration data
/sensor/lidar_3d/point_cloud		3D point cloud
/sensor/lidar_2d_front/scan		Front 2D laser scan
/sensor/lidar_2d_back/scan		Rear 2D laser scan
/scan_0		Front 2D laser scan (simulation)
/scan_1		Rear 2D laser scan (simulation)
/imu/data		IMU data (simulation)

Subscribed Topics

Topic	Type	Description
/cmd_vel		Velocity commands (linear x/y + angular z)

Services

Service	Type	Description
/cargo/command		Lock / unlock the cargo door
/headlight/operation		Turn headlight on / off
/wiper/operation		Set wiper mode (OFF / ONCE / REPEAT)

Key Dependencies

Package	Purpose
	Dynamixel Protocol 2.0 communication
	Controller manager framework
	Declarative parameter generation
	ROS ↔ OpenCV image conversion
	Control table XML parsing
	IMU visualization in RViz
	Autonomous navigation framework
	Online/offline SLAM for map building
	EKF/UKF sensor fusion for localization
	Ignition Gazebo ↔ ROS 2 bridge
	Gazebo hardware interface for ros2_control

(back to top)

---

📄 License

Distributed under the Apache License 2.0. See LICENSE for more information.

Copyright 2026 ROBOTIS AI CO., LTD.

(back to top)

---

👥 Contributors

(back to top)

---

📬 Contact

ROBOTIS AI CO., LTD.

• 🌐 Website: www.robotis.com
• 📧 Contact: peter@robotis.com

(back to top)

---

_{Made with 💚 by ROBOTIS AI}