Lab E: Robot Arm Programming

Today's Lab

Becoming more familiar with the MoveIt ROS2 package to control the Turtlebot4 OpenMANIPULATOR
Implementing TrafficBot and learning the basics of ROS2 msg files

Physical Robot Arm Control

This section details how to get the physical turtlebot's OpenManipulator arm up and running. Please refer back to the class meeting 9 page for helpful tips on how to program the arm using the OpenManipulatorX GUI and Python code.

Position the Arm: Position the arm as shown in the picture below to enable the arm to initialize properly. If you fail to do this, you may find that any movement command you send to the arm will fail.

Then, run the following commands, which start Bringup and MoveIT! on the Pi, and the OpenManipulator c++ interface on the PC.

[Terminal #1] SSH into the robot (password: turtlebot4), check USB port number, and run bringup:
```
$ set_robot_num [robot_num]
$ ssh ubuntu@$ROBOT_IP
$ sudo dmesg | grep ttyUSB
```
After running sudo dmesg | grep ttyUSB look for which USB port the FTDI USB Serial Device is connected to, it should be either ttyUSB0 or ttyUSB1. Now run the bringup command for the arm by specifying the USB port you identified in the prior step.
```
$ bringup_arm port_name:=/dev/ttyUSB1 
```
Note: bringup_arm is an alias for the command ros2 launch open_manipulator_x_bringup hardware.launch.py.
[Terminal #2] SSH into the robot and start MoveIt!: In a separate second terminal, ssh into the robot and start MoveIt!.
```
$ ssh ubuntu@$ROBOT_IP
$ start_moveit 
```
Note: start_moveit is an alias for the command ros2 launch open_manipulator_x_moveit_config move_group.launch.py.
[Terminal #3] Control the robot from your PC: You have a couple options here:
- For the OpenManipulatorX GUI:
```
$ ros2 launch open_manipulator_x_gui open_manipulator_x_gui.launch.py
```
- For running code: This is the option we'll be using today
```
$ ros2 run [package-name] [file-name]
```

Lab Exercise: TrafficBot

In this exercise, we will use the arm of the Turtlebot to guide imaginary traffic. You should not use the robot's wheels for this exercise. You will be working the same groups.

Getting Started

To get started on this exercise, you'll need to clone three packages:

Lab E starter code package: starter code to complete the traffic bot
The c++ OpenManipulator interface package: an interface required to control the arm using python (we will not be editing this)
The common interfaces package: the package that we'll be able to create and store custom messages in

Run the following commands:

$ cd ~/intro_robo_ws/src/
$ git clone https://github.com/Intro-Robotics-UChicago-Fall-2025/lab_e_traffic_bot.git
$ git clone https://github.com/Intro-Robotics-UChicago-Fall-2025/custom_interfaces.git
$ cd ~/intro_robo_ws
$ colcon build --symlink-install --packages-select lab_e_traffic_bot custom_interfaces
$ source install/setup.bash

Your Goal

Your goal in this exercise will be to have the robot arm move in a distinct manner based on the direction it receives via the traffic_status topic. Here is an example using the Turtlebot3.

Running Your Code

Terminal 1: SSH into the robot and run bringup.

$ set_robot_num [robot_num]
$ ssh ubuntu@$ROBOT_IP
$ bringup_arm port_name:=/dev/[USB port]

Note: Refer to instructions above or in Operating the OpenManipulatorX Arm to learn how to find which USB port the arm is connected to.

Terminal 2: SSH into the robot and start MoveIt!.

$ ssh ubuntu@$ROBOT_IP
$ start_moveit

Terminal 3 : Run the OpenManipulator c++ interface on the PC.

$ ros2 run omx_cpp_interface arm_cmd

Terminal 4: Run the traffic node, which will send the continuous "traffic signals" to your Turtlebot.

$ ros2 run lab_e_traffic_bot traffic

Terminal 5: Run the node that moves your robot arm.

$ ros2 run lab_e_traffic_bot move

Steps to Take & Starter Code

There are few steps you would need to take to complete this exercise.

traffic msg: if you look into custom_interfaces/msg/Traffic.msg, you will see that it is an empty msg file. Update the msg file such that you can encode at least 3 directions with that message. Here is a helpful resource for configuring messages: official wiki .
traffic controller node: Update the lab_e_traffic_bot/traffic.py file such that it publishes a traffic message with a different direction every 10 seconds. After this step, make sure that your traffic controller is publishing traffic messages appropriately via ros2 topic echo /tbXX/traffic_status.
turtlebot traffic controller node: Update the lab_e_traffic_bot/move.py file such that the turtlebot arm performs something different per msg received in the traffic_status callback function. Once done, run the move.py file and make sure your robot arm moves as it receives different messages.

Tips & Hints about the Arm & Gripper

The arm joints have limited movements. Their limits in degrees are listed below.
- Joint 1: -162 to 162
- Joint 2: -103 to 90
- Joint 3: -53 to 79
- Joint 4: -100 to 117
The gripper has limited movement as well; it can only move between -0.010 and 0.010 meters.
Make sure your arm's end goal does not collide with any objects (or the robot itself).
The position of the arm shifts the robot's center of mass and may cause your robot to tilt in some direction if the the arm is pushed too far.
The omx_cpp_interface will need to get launched every time you wish to control the robot through code using the MoveIt interface.

Lab E Deliverables

For your Lab E Deliverables, submit the following via Canvas/Gradescope by 2:00pm on Thursday, October 30th:

A video that features both:
1. A view of your computer screen, showing an echo of your traffic_status message
2. A view of the robot following reacting to traffic_status

Acknowledgments

I want to thank former Intro Robotics TAs Pouya Mahdi Gholami and Yves Shum for developing the traffic box exercise and Lauren Wright for adapting it to ROS2.