From Simple Motion to Autonomous Navigation: Making the Turtle Think

Demo Link: https://drive.google.com/file/d/1mjnzrN8IU-EwvVCyCZaqiOfy0pZb5PVk/view?usp=sharing

After successfully controlling the turtle using a ROS2 node and publishing velocity commands to /turtle1/cmd_vel, the turtle was able to move in a circular path. While this might seem like a simple exercise, it introduced one of the most important concepts in robotics: a robot can be controlled entirely through software by continuously sending motion commands.

The controller responsible for the circular motion repeatedly published a Twist message containing both a forward velocity and a rotational velocity:

msg.linear.x = 2.0
msg.angular.z = 1.0

This combination causes the turtle to move forward while simultaneously turning, resulting in a circular trajectory.

At this stage, however, the robot was still behaving blindly. It was not observing its surroundings or making decisions based on its current position. Regardless of where it was located, it would continue executing the same command forever.

To make the robot behave intelligently, it needed to answer three fundamental questions:

1. Where am I?

2. Where do I want to go?

3. What action should I take to get there?

These questions form the basis of nearly every navigation system used in robotics.

Introducing Closed-Loop Control

Unlike the circular controller, which continuously issued fixed commands, the next step was to build a controller that actively observed the turtle's current position using the /turtle1/pose topic.

The node subscribed to the turtle's pose information and continuously computed the error between the current position and a desired target location.

Conceptually, the controller worked as follows:

Current Position
        ↓
Compute Error
        ↓
Generate Velocity Command
        ↓
Move Turtle
        ↓
Read New Position
        ↓
Repeat

This feedback-driven approach is known as closed-loop control.

Instead of commanding the turtle to move in a predefined pattern, the controller constantly adjusted its behavior based on the turtle's actual location.

Navigating to a Goal

The first navigation task was simple: move the turtle to a single target point.

For example:

Goal: (8.0, 8.0)

The controller calculated:

• The distance to the goal

• The angle toward the goal

• The heading error between the turtle's orientation and the desired direction

Using this information, it generated velocity commands that gradually steered the turtle toward the destination.

The result was a smooth curved trajectory rather than a perfectly straight line. This happened because the turtle was continuously correcting its heading while moving forward.

Once the distance to the goal became sufficiently small, the controller stopped the robot.

This was the first example of autonomous navigation.

Moving Beyond a Single Goal

Reaching a single target is useful, but real robots rarely operate with only one destination.

Instead, robots often follow a sequence of locations known as waypoints.

To explore this concept, the controller was extended to manage a list of goals:

goals = [
    (2.0, 2.0),
    (8.0, 2.0),
    (8.0, 8.0),
    (2.0, 8.0),
    (2.0, 2.0)
]

These points represent the corners of a square.

The controller maintained an index pointing to the current waypoint. Whenever the turtle arrived at a waypoint, the controller automatically switched to the next one.

The logic looked like this:

Go to Waypoint 1
        ↓
Reached?
        ↓
Go to Waypoint 2
        ↓
Reached?
        ↓
Go to Waypoint 3
        ↓
...

This simple mechanism transformed the robot from a single-goal navigator into a waypoint-following system.

Drawing a Square Autonomously

With multiple waypoints defined, the turtle was able to traverse the corners of a square without any human intervention.

The resulting path was not a mathematically perfect square. Instead, the corners appeared slightly rounded because the controller continuously adjusted the turtle's orientation while moving.

Interestingly, this behavior resembles many real-world mobile robots. Rather than performing abrupt stop-turn-move actions, robots often generate smooth trajectories that are easier to execute physically.

The final system demonstrated several key robotics concepts:

• Velocity control through /cmd_vel

• Pose feedback through /turtle1/pose

• Closed-loop navigation

• Goal-based movement

• Waypoint following

• Basic autonomous behavior

Why This Matters

Although Turtlesim is a simple simulator, the concepts learned here directly translate to real robots.

The architecture developed during these exercises is remarkably similar to that used in modern navigation systems:

Localization
        ↓
Goal Selection
        ↓
Path Following
        ↓
Velocity Commands
        ↓
Robot Motion

In future stages, these ideas will be extended to realistic mobile robots in Gazebo, where sensors such as LiDAR and cameras will replace the simplified pose information provided by Turtlesim.

What began as a turtle moving in a circle has now evolved into a robot capable of navigating autonomously through a sequence of goals, a crucial milestone on the path toward autonomous mobile robotics.

Thank you for reading, hope you learn something too!!