Mastering Turtlesim: Publishing Pose in the Terminal

Introduction

Turtlesim is a versatile ROS (Robot Operating System) package that simulates a turtle swimming in a 2D environment. It provides a valuable learning platform for ROS beginners and helps developers understand and practice fundamental robotics concepts.

In this 1000-word blog post, we will explore the process of publishing the position and orientation (pose) of the turtle using terminal commands. This will equip your coding arsenal with the necessary skills to build more complex applications with Turtlesim and ROS.

Prerequisites

Before diving into the implementation details, make sure you have:

1. Installed and set up ROS, preferably [ROS Noetic](http://wiki.ros.org/noetic/Installation) on Ubuntu 20.04.

2. Familiarity with ROS concepts and basic ROS commands.

3. A running instance of the ROS master using the command `$ roscore`.

4. Turtlesim package installed. You can install it using: `$ sudo apt-get install ros-noetic-turtlesim`

Understanding Turtlesim Nodes

Turtlesim provides two main nodes that will help us publish turtle's pose:

1. `/turtlesim`: the primary node responsible for managing the turtle, its appearance, and behavior.

2. `/turtle1/pose`: the node that contains information about the turtle's pose (position and orientation).

To visualize the current pose of the turtle, execute the following command:

$ rosrun turtlesim turtlesim_node

This will open the Turtlesim window with the turtle's default pose, with (x, y) coordinates set to (5.5, 5.5) and a 0-degree orientation.

Subscribing to the Pose Topic

Now that we know the relevant nodes, let's subscribe to the `/turtle1/pose` topic to access the turtle's position. Run the following command:

$ rostopic echo /turtle1/pose

You will see the turtle's pose continuously updating in the terminal, even if the turtle remains stationary. This is because Turtlesim publishes the pose message on every simulation update.

Publishing Pose using a Custom ROS Node

In this next step, we will create a custom publisher to display turtle's pose in a more readable and customized format. This involves creating a new Python script, an environment for the script, and modifying the script according to our needs. Here are the steps:

1. Creating a ROS Workspace

To keep our work organized, create a directory for our workspace and initialize an empty Catkin workspace:

$ mkdir -p ~/turtlesim_pose_ws/src$ cd ~/turtlesim_pose_ws/src$ catkin_init_workspace

2. Creating a new Package

Generate a new package within our workspace containing our Python script:

$ cd ~/turtlesim_pose_ws/src$ catkin_create_pkg turtlesim_pose_publisher rospy

Here, `turtlesim_pose_publisher` is the package name and `rospy` is the dependency (ROS Python library).

3. Writing the Python Script

Now, create the Python script that will publish the pose:

$ cd ~/turtlesim_pose_ws/src/turtlesim_pose_publisher$ mkdir scripts$ cd scripts$ touch pose_publisher.py$ chmod +x pose_publisher.py

Edit the `pose_publisher.py` file and add the following code:

!/usr/bin/env pythonimport rospyfrom turtlesim.msg import Posedef pose_callback(msg): rospy.loginfo("Turtle Pose: x = %.2f, y = %.2f, theta = %.2f", msg.x, msg.y, msg.theta)def pose_publisher(): rospy.init_node('pose_publisher', anonymous=True) rospy.Subscriber('/turtle1/pose', Pose, pose_callback) rospy.spin()if __name__ == '__main__': try: pose_publisher() except rospy.ROSInterruptException: pass

This script initializes a new ROS node 'pose\_publisher', subscribes to the `/turtle1/pose` topic, and listens for `Pose` messages. Whenever it receives a new `Pose` message, the `pose_callback` function logs the position and orientation of the turtle in a readable format.

4. Build and Run the Pose Publisher

Finally, build the new package and execute the script:

$ cd ~/turtlesim_pose_ws$ catkin_make$ source devel/setup.bash$ rosrun turtlesim_pose_publisher pose_publisher.py

You should see turtle's pose displayed in a neat format in the terminal.

Now, you may control the turtle and observe the terminal displaying the accurate pose of the turtle. To control the turtle, open a new terminal and input the following commands:

$ rosrun turtlesim turtle_teleop_key

Exploring Further

With the acquired knowledge, you can experiment and modify the pose publisher to suit your needs. Some suggestions for further exploration include:

1. Design a custom pose display format

2. Add a pose history and display the path of the turtle

3. Implement a node that publishes static or dynamic transform between different turtle instances

In conclusion, publishing the pose of the Turtlesim turtle in the terminal provides insights into working with ROS nodes and Python scripts. By mastering this ability, you will not only understand the fundamental concepts of the Robot Operating System but also those of real-world robotics applications. So, keep experimenting and build your ROS proficiency.