R1 Pro Autonomous Navigation System Tutorial¶

1. Product Overview¶

This system includes mapping, localization, navigation, and control modules. The robot can build a point cloud map of its environment and, based on that map, perform global localization along with autonomous movement to target points and obstacle avoidance.

The autonomous navigation system is a paid feature. To learn more or purchase a trial, contact a sales representative at product@galaxea-dynamics.com or call 4008780980.

Your browser does not support the video tag.

2. Hardware Overview¶

2.1 Performance Specifications¶

Localization	Description
Localization method	Laser SLAM
Localization frequency	100 Hz
Localization accuracy	＜0.05 m

Motion Control	Description
Control method	Autonomous navigation (path tracking)
Maximum travel speed	0.6 m/s
Obstacle avoidance method	Obstacle bypassing
Obstacle avoidance frequency	10-20 Hz

Network	Description
Wired network	Supported
WiFi	Supported

2.2 Sensor Configuration¶

The Galaxea R1Pro 2026 model chassis has no vision sensors and is equipped with a LiDAR only.

LiDAR	Description
Quantity	1
Field of view	360°H x 59°V
Laser wavelength	905 nm
Detection range	40 m @10% reflectivity 70 m @80% reflectivity
Near-range blind zone	0.1 m
Data port	100 BASE-TX Ethernet
IMU	Built-in IMU
Operating temperature range	-20 ~ +55°C
Dimensions	65L x 65W x 60H mm
Weight	265 g

3. Software Overview¶

Make sure your environment meets the following software dependency requirements.

Hardware dependency: R1 Pro compute unit
Operating system dependency: Ubuntu 22.04 LTS
Middleware dependency: ROS Humble

Mapping is the foundational step for autonomous navigation. You teleoperate the robot to record mapping data (an mcap file), process the data and build the map on a local computer, and finally upload the map to the designated directory on the robot to complete map deployment. Following the tutorial below, set the target pose, modify the target file, and run the script to achieve point-to-point navigation.

4.1 Build a Map¶

4.1.1 Start R1 Pro¶

Log in to R1 Pro over SSH.

ssh nvidia@robot_ip
# Enter the password  (default: nvidia)

Run the following commands to start the R1 nodes.

cd ~/galaxea/install/startup_config/share/startup_config/script/
./robot_startup.sh boot ../sessions.d/ATCNavigation/R1PROVRTeleopNAV.d/

4.1.2 Record a Data Bag¶

Run the following commands to start recording a bag file.

# Check that the topics are complete and publishing at a normal frame rate
ros2 topic hz /hdas/imu_chassis 
ros2 topic hz /hdas/lidar_chassis_left # 10hz
ros2 topic hz /hdas/feedback_chassis
cd ~
ros2 bag record /hdas/imu_chassis /hdas/lidar_chassis_left /hdas/feedback_chassis -s mcap

Use the remote controller to drive the robot through the space you want to map, making sure to cover all areas that will require navigation. For how to operate the R1 Pro chassis with the remote controller, click here. When you have finished recording the mapping data, press Ctrl + C to stop recording.

Note:

Move the robot to the area you plan to map. Currently only indoor environments are supported, with an area no larger than 100 square meters and a ceiling height no greater than 5 meters.
At the start of recording, keep the robot stationary for at least 5 seconds to ensure data quality.
While recording data, make sure there are no dynamic targets in the environment (such as moving people or objects), and avoid moving near the robot, so as not to interfere with map building.
After mapping is complete, make sure the environment does not change during subsequent use (such as adding tables or partitions); otherwise you will need to remap.
The robot should cover the navigation area twice, that is, drive the robot along the same route twice, as shown in the figure below, completing two loops from 1 to 8.

4.1.3 Get the Mapping Runtime Environment (Docker)¶

Download and install the Docker image. Contact your sales representative to obtain the file.

After obtaining the file, we recommend following the Docker installation tutorial to install it.

Load the Docker file. Run the following command on your local computer to load the Docker file.

sudo docker load -i galaxea_main_mapping_image_ros2.tar.gz

Docker mounts to the root directory by default. Reserve at least 20 GB of storage space. To change the mount path, refer to the following:

# 1. Create a new daemon.json file in the /etc/docker/ directory:
sudo vim /etc/docker/daemon.json

# 2. In the opened file, add the following content to change the Docker storage directory to the path you want to mount:
{
"data-root": "/path/to/target_dir"
}

# 3. Save and exit. Press 'shift' + ':', type 'w' + 'q', and then press Enter.
# 4. After changing the configuration, restart the Docker service to apply it:
sudo systemctl restart docker

4.1.4 Build the Map in the Environment¶

On your local computer terminal, run the following command to pull the recorded bag file from R1 Pro to your local machine.

scp nvidia@{robot_ip}:~/{xxx.bag} .

# [robot_ip] is the IP address of R1;
# [xxx.bag] is the name of the recorded bag file.

Prepare the bag file and the calibration parameter file.

mkdir -p ~/mapping_data
cp /path/to/xxx.bag ~/mapping_data
cp /path/to/robot_calibration.json ~/mapping_data

Start Docker and begin mapping.

sudo docker run --rm  -v ~/mapping_data:/mapping_data galaxea-mapping:v2.0.x bash -c "./root/run_mapping_app.sh /mapping_data" 

# If you encounter a permission denied error, use chmod to grant permissions. Be sure to confirm the correct image version number.

sudo docker run --rm -v ~/mapping_data:/mapping_data \
    galaxea-mapping:v2.0.1 \
    bash -c "chmod +x /root/run_mapping_app.sh && /root/run_mapping_app.sh /mapping_data"

(Fill in mapping_data and galaxea-mapping:v2.0.x with the actual names.)

View the mapping result.

cd ~/mapping_data/map

# The map.obj file is the mapping result. You can use meshlab to open and view the point cloud.
# sudo apt-get install meshlab

meshlab map.obj

4.1.5 Import the Map and Calibration Files¶

Run the following commands to import the map and calibration files into R1 Pro.

ssh nvidia@{rorbot_ip} "mkdir -p ~/galaxea/calib ~/galaxea/maps"
scp -r ~/mapping_data/map/* nvidia@{robot_ip}:~/galaxea/maps/
scp -r ~/mapping_data/robot_calibration.json nvidia@{robot_ip}:~/galaxea/calib/

4.2 Start the Localization Feature¶

When starting the localization feature, make sure the robot is within a known map.

Start the software

On R1 Pro, run the following commands to start the relevant nodes.

cd ~/galaxea/install/startup_config/share/startup_config/script/
./robot_startup.sh boot ../sessions.d/ATCNavigation/R1PROVRTeleopNAV.d/

Obtain localization

2.1 Automatic localization

Switch the remote controller to chassis control mode and drive the robot in slow loops within a 2 m range of the known map environment for 10 to 30 seconds to initialize localization, then observe the output of the following command.

On R1 Pro, run the following command to check the localization status:
```
source ~/galaxea/install/setup.bash
ros2 run tf2_ros tf2_echo map body
```
If it returns data similar to the following, localization succeeded:
```
- Translation: [3.280, -0.743, 0.008]
- Rotation: in Quaternion [0.000, -0.004, -0.147, 0.989] # xx y z w
```
2.2 Manual localization

When the robot has not localized successfully (or after restarting the node), teleoperate the robot to the mapping start point with the same orientation as at the start of mapping, and send the following command.
```
ros2 topic pub --times 10 /localization/prior_localization_pose geometry_msgs/msg/TransformStamped "header:
stamp:
    sec: 0
    nanosec: 0
frame_id: ''
child_frame_id: ''
transform:
translation:
    x: 0.0
    y: 0.0
    z: 0.0
rotation:
    x: 0.0
    y: 0.0
    z: 0.0
    w: 1.0" 
```

4.3 Set the Target Pose¶

Teleoperate the robot to the target point
After localization starts successfully, teleoperate the robot to the target point you want to set, making sure the center of R1 is at least 45 cm away from any obstacle.

Record the pose information
Each time you drive to a target point, record the pose information for that location:

- Translation: [3.280, -0.743, 0.008]
- Rotation: in Quaternion [0.000, -0.004, -0.147, 0.989] # x y z w

Update the navigation target-point script
Repeat the process above, and after recording the pose information for all target points, update all target-point pose information in the navigation target-point script.

An example script is shown below. Modify the position and orientation in pose with the target-point information.

ros2 action send_goal /system_manager/navi/action system_manager_msg/action/NavigationTask -f --feedback 
    "{
    header: {
        stamp: {sec: 0, nanosec: 0},
        frame_id: 'map'
    },
    pose: {
        position: {x: -2.6662282943725586, y: 3.4633750915527344, z: 0.0},
        orientation: {x: 0.0, y: 0.0, z: 0.3263046490397236, w: 0.945264659243676}
    },
    frame_id: 'map',
    target_point_type: 1
    }"

5. Software Interfaces¶

5.1 Driver Interfaces¶

See R1 Pro Driver Interfaces for information on the chassis, LiDAR, and IMU driver interfaces, and how to use these interfaces to control the robot.

5.2 Motion Control Interfaces¶

See R1 Pro Motion Control Interfaces for information on the chassis control interfaces and how to use these interfaces to control the robot.

5.3 Localization Interfaces¶

The localization interfaces are a core component through which the R1 Pro robot achieves autonomous navigation and environmental perception. Through these interfaces, the robot receives data from various sensors, such as the IMU (inertial measurement unit) and LiDAR, enabling accurate multi-sensor fusion localization. These interfaces ensure that the robot can accurately perceive its own position and orientation in complex environments, providing reliable data support for subsequent path planning and navigation. This section describes each topic of the localization interfaces in detail, including the types and purposes of the input and output data.

Topic Name	I/O	Description	Message Type
/hdas/imu_chassis	Input	IMU data, used for multi-sensor fusion localization	sensor_msgs::msg::Imu
/hdas/lidar_chassis_left	Input	Multi-line LiDAR point cloud, used for localization	sensor_msgs::msg::PointCloud2
/localization/localization_results	Output	SLAM localization status	localization_msg::msg::LocLocalization
/fault_code/localization	Output	SLAM localization status error code	localization_msg::msg::LocLocalization

The navigation interfaces are a key part of how the R1 Pro robot achieves autonomous path planning and motion control. These interfaces allow the robot to perform global and local path planning based on input sensor data (such as LiDAR point clouds and SLAM localization status), and output control commands to drive the robot chassis. The navigation interfaces not only support obstacle avoidance but also update the robot's motion trajectory and task status in real time, ensuring that the robot can complete navigation tasks efficiently and safely. This section describes each topic of the navigation interfaces in detail, including the types and purposes of the input and output data.

Topic Name	I/O	Description	Message Type
/hdas/lidar_chassis_left	Input	Multi-line LiDAR point cloud, used for obstacle avoidance	sensor_msgs::msg::PointCloud2
/localization/localization_results	Input	SLAM localization status	localization_msg::msg::LocLocalization
/nav/local_path	Output	Local path planned by the local path planner	sensor_msgs::msg::PointCloud2
/nav/global_path	Output	Global path planned by the global path planner	sensor_msgs::msg::PointCloud2
/nav/robot_global_traj	Output	Global trajectory traveled by the robot	nav_msgs::msg::Path
/nav/global_map	Output	Navigation global cost map, used for global path planning	nav_msgs::msg::OccupancyGrid
/nav/local_map	Output	Navigation local cost map, used for local path planning	nav_msgs::msg::OccupancyGrid
/nav/global_goal	Output	Target point received by navigation, used for visualization	geometry_msgs::msg::PoseStamped
/motion_target/target_speed_chassis	Output	Control velocity output by navigation	geometry_msgs::msg::Twist