How to integrate with the actual Magni robot

[JGUO006]

Hi,

I have one actual Magni robot running on Ubuntu 16.04 with ROS kinetic. I have own laptop running on Ubuntu 20.04 with ROS 2 Foxy and ROS noetic installed. I have tried the office demo world and wonder whether I can run the actual Magni robot and complete a simple delivery request instead of the simulated robot in office demo environment. May I know how I can integrate RMF (rmf_core, fleet manager, fleet adapter, etc) so that the actual robot can do the same as shown in the demo?

[mxgrey]

I think @cnboonhan is the most experienced with using RMF on real life Magnis, so he might have some advice.

[cnboonhan]

Hello 👋 I currently use free_fleet for the integration magic, so if you use that as well, I can better help with doing this.

Assuming you have following initial set up:

• rmf_demos built according to these instructions, but checked out to use release-21.01.
• Magni running the Ubiquity Robotics Raspberry Pi image

You should do the following:

Magni Robot

• Use some sort of mapping to create a navigation map of your physical system. Perhaps cartographer_ros?
• Build CMake 3.18 or later from source and install it. This is necessary because the Ubiquity image has an older CMake version, which is not compatible with the CycloneDDS necessary for free_fleet. If any important dependencies were uninstalled during the install step here, you will need to restore them.
• Build the free fleet client on the Magni ( on a new workspace) following these steps.

Computer

• On a development computer, build the free_fleet server as specified here.
• You should modify / extend the rmf_demos office scenario to be unique to your own real world physical environment. This is because the office scenario may not make sense in the real world you will be operating in. You can refer to these materials for more information.
• In particular, modify the fleet adapter fleet_name parameter based on your free fleet fleet_name as seen here
• Do a colcon build.

Configuration
You will then have to configure launch files for both client and server, by modifying these examples: client, server.

In particular, you will need to compute the 2d coordinate transformation between your Magni navigation map, and your modified rmf_demos scenario. This code could be useful to reference when doing this computation. These coordinate transformation values will be put into these fields.

Assuming everything is working ( 👍 ) , you should now be able to connect both devices to the same network, and launch the server and client nodes. Ideally, we will see some logs on the server along the lines of "new robot found". Your robot should now appear on the Rviz screen similar to what you see in rmf_demos.

Feel free to use this script to install CMake on your Magni:

#!/bin/bash
set -e

version=3.18
build=1

if [[ `cmake --version | grep $version.$build` ]]; then
  echo "Correct cmake version $version:$build found."
  exit 0
fi

echo "Target cmake version not found. Installing.."
sudo apt remove --purge --auto-remove cmake -y || true
mkdir ~/temp
cd ~/temp
wget https://cmake.org/files/v$version/cmake-$version.$build.tar.gz
tar -xzvf cmake-$version.$build.tar.gz
cd cmake-$version.$build/
./bootstrap
make
sudo make install

rm -rf ~/temp

I definitely missed out on some steps that i forgot, so do check back with any issues that you might encounter and hopefully i'll have encountered them before.

[JGUO006]

Thank you for your quite prompt and detailed answers! @mxgrey @cnboonhan And yes, I am also using the free_fleet for this physical system integration. I have followed all these instructions and there is one thing I'd like to point out. For the CMake update for Magni, from what I observed, running the sudo apt remove --purge --auto-remove cmake -y || true command will remove the current CMake version and will also remove parts of the ROS distribution, resulting in a lot of missing ROS dependencies and broken Raspberry Pi image. Magni will fail to start ROS nodes or even bring up essential nodes on boot. I restored the whole system by downloading a fresh new Raspberry Pi image into the micro-SD card and restarted everything. In case someone else may follow the same instructions in future, the remove CMake step can be omitted. The latest CMake version can be built and installed without any issue. The older version will be replaced and this worked for me. Currently, I have successfully installed free_fleet serve and client nodes but now I stuck at creating a navigation map for Magni and also the coordinate transform between the RMF frame and free fleet robot frame. Can you give some further instructions and help?

[cnboonhan]

Sorry the cmake script caused some damage, i blindly copied and pasted. In any case, glad you got it to work!

For the magni, we should first find out what sort of navigation stack your robot is using for autonomous navigation. I myself used a LiDAR based system, but you might use fiducials. We will need a way for the robot to move to a given location autonomously.

That is, if i provide some (x, y, theta) that represents some 2D robot pose, your robot should autonomously arrive there from its current position.

The next step is to find some sort of floor plan of your operational space. Ideally it would be drawn to scale, like an architectural diagram. We will be annotating this floor plan using traffic_editor.

At this point, you would have to create some ROS2 packages, which you might have to analyse rmf_demos. In particular, rmf_demo_maps, which holds the annotated floor plans, such as for the office scenario.

One option at this point could be to modify the office scenario instead of creating a new set of packages. We could do this by replacing the office map with your floor plan, and editing the office annotations by opening this file in traffic_editor.

The coordinate transformation step can now be done. By picking 3 or 4 corresponding points from your robot navigation map, and the annotated traffic map, you can compute the 2d rigid transform between the two maps.

The idea is that rmf_core sends out waypoints out to your robot based on the "global" coordinates from the traffic editor, which needs some additional processing based on the 2d rigid transformation in order to be correct on the "local" robot navigation map.

[JGUO006]

Finally I have done the integration and now I can use RMF to control my Magni robot and make it navigate in office automatically (RPLIDAR A2 based navigation). Thanks for your reply and help!

In case someone else may also need it, I summarized my integration steps here.

1. Magni robot installation, configuration and setup (with RPLIDAR A1/A2).
2. rmf_demos installation on your own workstation computer (Ubuntu 20.04).
3. For Magni robot, upgrade (not remove and install, just upgrade) its built-in Cmake version to 3.18 or later as discussed above.
4. Install free_fleet client node on Magni robot.
5. Install free_fleet server node on your own workstation computer (Ubuntu 20.04).
6. Configure launch files for both free_fleet client and server nodes (e.g. fleet_name, robot_name). For free_fleet client, enable only the free_fleet_client_ros1 node, then do a colcon build for free_fleet workspace.
7. On workstation computer, modify fleet adapter fleet_name parameter based on free_fleet fleet_name.
8. For Magni robot, install magni_lidar, then manually control to move Magni robot around, create and save a LIDAR based navigation map (.pgm and .yaml files). Copy them to magni_lidar maps folder, and then modify map_yaml parameter of magni_lidar_maprunner_amcl.launch file. Do a catkin_make for the workspace.
9. On workstation computer, use traffic_editor to create a floor plan (with at least 1 accurate measurement, for both length and width).
10. Find out the coordinate transformation values between the Magni navigation map and floor plan map, and put those values into free_fleet server launch file. Do a colcon build for free_fleet workspace.
11. Modify the rmf_demos office.launch.xml or create a new one, change parameters accordingly (e.g. config_file, map_name, fleet_name, nav_graph_file, robot_prefix). Do a colcon build for rmf_demos workspace.
12. On Magni robot, launch magni_lidar_maprunner_amcl node, move_basic node and free_fleet client node.
13. On workstation computer, launch free_fleet server node, rmf_demos node. Then, there will be some logs shown “new fleet found” and robot will appear on the Rviz screen.

[cnboonhan]

Thats awesome! Congratulations on your feat ! Its no small task