Attention

You are viewing an older version of the documentation. The latest version is 2.2.

Create Your Own Robot Kit

This tutorial describes how to create an autonomous mobile robot capable of exploring and mapping an area by adding the an Intel® compute system, adding a Intel® RealSense™ camera on top of any robot base, and using the Intel® Robotics SDK software.

You can use the Robot Teleop Using a Keyboard ROS 2 node to validate that the robot kit hardware setup was done correctly.

Requirements

Hardware Requirements

The robot base should contain:

  • Intel® compute system with Intel® Robotics SDK installed

  • Intel® RealSense™ camera

  • Robot base support (chassis) for the Intel® compute system and the Intel® RealSense™ camera

  • Wheels

  • Motor

  • Motor controller

  • Batteries for all components

Software Requirements

The robot base should have a ROS 2 node capable of:

  • Publishing information from the motor controller firmware into ROS 2 topics like wheel odometry

  • Getting information from other ROS 2 nodes and transmitting this data to the motor controller firmware, for example, receiving movement commands from ROS 2 Navigation 2 stack on the cmd_vel topic

  • Providing robot specific information like the tf tree data with correct tf transformations, for example, odom and base_link and their transformations

  • When using multiple robots, it is useful to be able to change these names for each robot like robot1_odom and robot1_base_link (more information can be found here)

Note

This ROS 2 node runs on the compute system and gets information from the motor robot controller via a wire connection, usually a USB connection.

Steps To Create Your Own Robot Kit

Step 1: Prerequisites

To achieve a working autonomous mobile robot, follow the instructions of the manufacturer.

The typical assembly consists of the following steps:

  1. Mount the the motors, to the lower chassis board and assemble the wheels

  2. Fix the motor controller on the chassis board and connect it with the motors

  3. Attach the Intel® RealSense™ camera and the SSD drive to the upper chassis board

  4. Mount the Intel® compute system to the the upper chassis board

  5. Connect the two chassis boards

  6. Establish a connection between the Intel® compute system and both Intel® RealSense™ camera and motor controller via USB

  7. Attach the the Intel® compute system and the motor controller to a power source

  8. Power the Intel® compute system using a power source

  9. Switch on the motor controller power switch

Step 2: Integration into Intel® Robotics SDK

A robot base ROS 2 node can be started on the native system OS or inside a Docker* container. To ensure proper functionality, ensure that both the robot base node and the rest of the Intel® Robotics SDK pipeline are configured with the same ROS_DOMAIN_ID.

Step 3: Robot Base Node ROS 2 Node

Introduction to Robotic Base Node

The Intel® Robotics SDK pipeline assumes that the robot base ROS 2 node:

  • Publishes odom and base_link

    • odom is used by the Navigation 2 package and others to get information from sensors, especially the wheel encoders. See this Navigation 2 tutorial on odometry for more information.

    • base_link represents the center of the robot to which all other links are connected.

  • Creates the transform between odom and base_link

  • Is subscribed to cmd_vel which is used by the Navigation 2 package to give instructions to the robot like spin in place or move forward

The Intel® Robotics SDK provides the following examples with the ros-humble-aaeon-ros2-amr-interface Deb package:

  • /opt/ros/humble/share/ros2_amr_interface/params/aaeon_node_params_uncalibrated_imu.yaml

  • /opt/ros/humble/share/ros2_amr_interface/params/aaeon_node_params.yaml

These samples are for the AAEON UP Xtreme* i11 Robotic Development Kit.

Robotic Base Node Deep Dive

This section details the commands that are needed for starting up the motor controller of an AAEON UP Xtreme* i11 Robotic Development Kit.

Using the AAEON UP Xtreme* i11 Robotic Development Kit as a reference and starting it’s node like this:

  • Ensure that the ros-humble-aaeon-ros2-amr-interface Deb package is installed.

    sudo apt update
sudo apt install ros-humble-aaeon-ros2-amr-interface
    Copy to clipboard

  • Check the device name of the motor controller.

    sudo dmesg | grep ttyUSB
    Copy to clipboard

  • The Output should contain the ch341-uart device providing the interface to the motor controller board.

    [1452443.462213] usb 1-9: ch341-uart converter now attached to ttyUSB0
[1452444.061111] ch341-uart ttyUSB0: ch341-uart converter now disconnected from ttyUSB0
    Copy to clipboard

  • Ensure the AAEON UP Xtreme* i11 Robotic Development Kit node configuration file has the proper USB device configured as value of port_name.

    vi /opt/ros/humble/share/ros2_amr_interface/params/aaeon_node_params.yaml
    Copy to clipboard

  • Start the motor control node.

    AAEON_NODE_CONFIG_FILE=/opt/ros/humble/share/ros2_amr_interface/params/aaeon_node_params.yaml

# Launch the AAEON Robot Motor Board Interface
ros2 run ros2_amr_interface amr_interface_node --ros-args \
   --params-file $AAEON_NODE_CONFIG_FILE \
   --remap /amr/cmd_vel:=/cmd_vel \
   --remap /amr/battery:=/sensors/battery_state
    Copy to clipboard

You can check the following:

  • ROS 2 topics

    ros2 topic list
# The result for UP Xtreme i11 Robotic Kit is similar to:
# /amr/cmd_vel
# /amr/imu/raw
# /amr/initial_pose
# /amr/odometry
# /parameter_events
# /rosout
# /sensors/battery_state
# /tf
# The result for the Pengo robot contains multiple topics but the crucial to this pipeline are:
# /cmd_vel
# /joint_states
# /rosout
# /odom
# /parameter_events
# /tf
    Copy to clipboard

  • odom and base_link frames

    ros2 run tf2_tools view_frames.py
cp frames.pdf /home/<user>
# Open the pdf through file explorer, it should look similar to:
    Copy to clipboard
    ../../../_images/frames.png

Step 4: Robot Base Node ROS 2 Navigation Parameter File

Introduction to the ROS 2 Navigation Parameter File

The Intel® Robotics SDK pipeline for AMRs uses the Navigation 2 package from ROS 2.

The Navigation 2 package requires several parameters specific to the robot and the area it is mapping to be set.

Robot Navigation Parameter File

To help understand the options in this parameter file, see ROS 2 Navigation 2 packages:

There are a lot of parameters to set, and Intel® recommends reading this Navigation 2 documentation to get the better picture.

The most important parameters to set are:

  • use_sim_time:

    Ignore all differences. It is used in simulations. Set it to False when running in a real environment.

  • base_frame_id: robot frame ID being published by the robot base node

    The default is base_footprint, but base_link is another option. Use the one you choose to publish in the robot base node.

  • robot_model_type: robot type

    The options are omnidirectional, differential, or a custom motion model that you provide.

  • tf_broadcast: turns transform broadcast on or off

    Set this to False to prevent amcl from publishing the transform between the global frame and the odometry frame.

  • odom_topic: source of instantaneous speed measurement

  • max_vel_x, max_vel_theta: maximum speed on the X axis or angular (theta)

  • robot_radius: radius of the robot

  • inflation_radius: radius to inflate costmap around lethal obstacles

  • min_obstacle_height: minimum height to add return to occupancy grid

  • max_obstacle_height: maximum height to add return to occupancy grid

  • obstacle_range: determines the maximum range sensor reading that results in an obstacle being put into the costmap

  • max_rotational_vel, min_rotational_vel, rotational_acc_lim: configure the rotational velocity allowed for the base in radians/second

Step 5: Navigation Full Stack

Introduction to the Navigation Full Stack

The Intel® Robotics SDK navigation full stack contains a lot of components that help the robot navigate, avoid obstacles, and map an area. For example:

  • Intel® RealSense™ camera node: receives input from the camera and publishes topics used by the vSLAM algorithm

  • Robot base node: receives input from the motor controller (for example, from wheel encoders) and sends commands to the motor controller to move the robot

  • ros-base-camera-tf: Uses static_transform_publisher to create transforms between base_link and camera_link

    static_transform_publisher publishes a static coordinate transform to tf using an x/y/z offset in meters and yaw/pitch/roll in radians. The period, in milliseconds, specifies how often to send a transform.

    • yaw = rotation on the x axis

    • pitch = rotation on the y axis

    • roll = rotation on the z axis

  • collab-slam: A Collaborative Visual SLAM Framework for Service Robots paper

  • FastMapping: an algorithm to create a 3D voxelmap of a robot’s surroundings, based on Intel® RealSense™ camera’s depth sensor data and provide the 2D map needed by the Navigation 2 stack

  • nav2: the navigation package

  • Wandering: demonstrates the combination of middleware, algorithms, and the ROS 2 navigation stack to move a robot around a room without hitting obstacles

Create a Parameter File for Your Robotic Kit

The Wandering Application with Intel® RealSense™ Camera and Rtabmap Application in Aaeon Robot tutorial provides a parameter file for the AAEON UP Xtreme* i11 Robotic Development Kit, that file can be used as a template to create a parameter file for your robotic kit.

First install the tutorial.

sudo apt update
sudo apt install ros-humble-wandering-aaeon-tutorial
Copy to clipboard

Use the AAEON UP Xtreme* i11 Robotic Development Kit navigation parameter file as a template, make a copy of it, and adapt the content to match your robot.

# Replace <your_robot>_robot_nav to a name that makes sense to your robotic kit.
cp /opt/ros/humble/share/wandering_aaeon_tutorial/params/aaeon_nav.param.yaml /opt/ros/humble/share/wandering_aaeon_tutorial/params/<your_robot>_nav.param.yaml
Copy to clipboard

Make all of the changes that are specific to your robotic kit:

vi /opt/ros/humble/share/wandering_aaeon_tutorial/params/<your_robot>_nav.param.yaml
Copy to clipboard

  1. Replace the aaeon-amr-interface target with the generic robot node you created in “Step 3: Robot Base Node ROS 2 Node”.

  2. In the ROS 2 command file, change the Navigation 2 target so that params_file targets the parameter file you created in “Step 4: Robot Base Node ROS 2 Navigation Parameter File”.

    from: params_file:=/opt/ros/humble/share/ros2_amr_interface/params/<your_robot>_node_params.yaml

    to: params_file:=/opt/ros/humble/share/wandering_aaeon_tutorial/params/<your_robot>_nav.param.yaml

  3. In the ros-base-camera-tf target, change the transform values from static_transform_publisher. The values for x, y, and z depend on where your Intel® RealSense™ camera is set.

Start Mapping an Area with Your Robot

  1. Place the robot in an area with multiple objects in it.

  2. Check that Robotics SDK environment is set:

    Run the following script to create a map by using the Wandering Application with Intel® RealSense™ Camera and Rtabmap Application in Aaeon Robot.

    source /opt/ros/humble/setup.bash
export ROS_DOMAIN_ID=<value>
/opt/ros/humble/share/wandering_aaeon_tutorial/scripts/wandering_aaeon.sh
    Copy to clipboard

  3. Follow the Wandering Application with Intel® RealSense™ Camera and Rtabmap Application in Aaeon Robot tutorial

Troubleshooting

You can stop the demo anytime by pressing ctrl-C.

For general robot issues, go to: Troubleshooting for Robot Tutorials.