Robotic Application (ROS) Deployments from AWS RoboMaker

Deploying to Qualcomm® Robotics RB3 Platform to drive the Turtlebot 3 Burger

AWS Robomaker is a cloud service that provides a development environment for robotics applications. Developers can use RoboMaker to create and deploy ROS applications on physical robots, then simulate and test applications without the need for a real robot.

Step-by-step instructions for deploying RoboMaker applications are given in the AWS article Deploy Robotic Applications Using AWS RoboMaker. However, the cross-compilation and bundling instructions in that article are specific to armhf architectures. The procedure below modifies those instructions for the ARM64 architecture of the Qualcomm Robotics RB3. It also includes a shortcut designed to help make the final step of application deployment hassle-free.


Follow these steps before deploying a RoboMaker application:

  1. Set up the Qualcomm Robotics RB3 with a Docker container with ROS Kinetic installed, as described in “How to Install Docker on the Qualcomm Robotics RB3 development platform.”
  2. Connect the Turtlebot 3 Burger to the Qualcomm Robotics RB3.
  3. Sign into the Amazon S3 console. Create and name an Amazon S3 bucket.
  4. Install Java 8 to the Docker container. See Install Java to a Docker container on the Qualcomm Robotics RB3 for instructions.
  5. Install ARM64-based AWS Greengrass to the Docker container. See Install AWS Greengrass to a Docker container on the Qualcomm Robotics RB3 for instructions.

Then, follow the steps given in the AWS article Deploy Robotic Applications Using AWS RoboMaker. (The Qualcomm Robotics RB3 fulfills the stated prerequisite of “a physical robot that is already set up and configured with ROS Kinetic/Melodic, SSH, SFTP/SCP and internet access.”)

Cross-compilation and bundling for the Qualcomm Robotics RB3

In that article, the subheading “Build a robot application with AWS RoboMaker” contains a Step 14. The step shows a sequence of commands (from cd /opt/robomaker/cross-compilation-dockerfile/ to exit) for bundling a robot application through a cross-compilation Docker container.

Instead, follow the procedure below to install packages for bundling applications (colcon) on the Qualcomm Robotics RB3, an ARM64-based single-board computer (SBC). (For more details, refer to AWS RoboMaker Cross-compilation for ARM64.)

  1. Run these commands (Ubuntu host):

    $ sudo apt-get update
    $ sudo apt-get install qemu-user
    $ sudo apt install qemu-user-static
    $ sudo cp /usr/bin/qemu-aarch64-static /opt/robomaker/cross-compilation-dockerfile/
    $ cd /opt/robomaker/cross-compilation-dockerfile/
    $ mv Dockerfile Dockerfile.armhf
  2. Create a modified version of the original armhf Dockerfile for ARM64. Use the following code to create a new file and save it as Dockerfile.

    ARG ROS_VERSION=kinetic
    FROM arm64v8/ros:kinetic-ros-base-xenial

    ENV PATH="/root/.local/bin:${PATH}"

    # Copy qemu from the host machine
    COPY qemu-aarch64-static /usr/bin

    RUN echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections

    # Installed for convenience
    RUN apt-get update && apt-get install -y vim

    # Add raspicam_node sources to apt

    RUN apt-get update && apt-get install -y apt-transport-https \
    && echo "deb xenial main" > /etc/apt/sources.list.d/ubiquity-latest.list \
    && apt-key adv --keyserver hkp:// --recv-key C3032ED8

    # Install Python and colcon
    RUN apt-get update && apt-get install -y \
    python \
    python3-apt \
    curl \
    && curl -O \
    && python3 \
    && python2 \
    && python3 -m pip install -U colcon-ros-bundle

    # Add custom rosdep rules
    COPY custom-rosdep-rules/raspicam-node.yaml /etc/ros/rosdep/custom-rules/raspicam-node.yaml
    #RUN echo "yaml file:/etc/ros/rosdep/custom-rules/raspicam-node.yaml" > /etc/ros/rosdep/sources.list.d/22-raspicam-node.list \
    RUN echo "yaml" > /etc/ros/rosdep/sources.list.d/18-aws-python.list \
    && rosdep update

    # Add custom pip rules
    COPY custom-pip-rules.conf /etc/pip.conf

    # Add custom apt sources for bundling
    COPY xenial-sources-arm64.yaml /opt/cross/apt-sources.yaml

  3. Save the following code into a file called xenial-sources-arm64.yaml. It lists ARM64 packages for bundling the robot application.

    # ARM Support

    deb [arch=arm64] xenial main restricted universe multiverse
    deb [arch=arm64] xenial-updates main restricted universe multiverse
    deb [arch=arm64] xenial-backports main restricted
    deb [arch=arm64] xenial-security main restricted universe multiverse

    # ROS
    deb [arch=arm64] xenial main

  4. Once Dockerfile is saved, run the following commands:

    $ sudo docker build -t ros-cross-compile:arm64.
    $ cd ~/environment/HelloWorld/robot_ws
    $ sudo docker run -v $(pwd):/ws -it ros-cross-compile:arm64
    $ cd ws
    $ apt update
    $ rosdep install -–from-paths src -–ignore-src -r -y
    $ colcon build
    $ colcon bundle --apt-sources-list /opt/cross/apt-sources.yaml
    $ exit
  5. Resume the instructions in “Build a robot application with AWS RoboMaker” at Step 15.

Final step: Application deployment

The last section of that same AWS article is titled “Create and deploy the robot application with AWS RoboMaker.” It contains 16 steps.

To deploy the robot application successfully on the Qualcomm Robotics RB3, AWS Greengrass group settings need to be toggled every time after a deployment is created (Step 16). That involves changing the AWS Greengrass group setting (Default Lambda function containerization) first to “Greengrass Container,” then back to “No Container” and “Redeploy.”

Follow the procedure in the video “AWS RoboMaker onto RB3” to change the AWS Greengrass group settings. It shows how to deploy to the Qualcomm Robotics RB3 instead of to Raspberry Pi to drive a Turtlebot Burger.

Qualcomm Robotics RB3 is a product of Qualcomm Technologies, Inc. and/or its subsidiaries.