🕰️Robots With Schedules

🏙️ Welcome to a Timely Town

In Robot Town, not all bots act on commands.

Some bots operate on daily schedules — like:

• WaterBot watering gardens at sunrise ☀️

• TrashBot collecting garbage every evening 🗑️

• DanceBot performing hourly groove sessions 🕺

These bots don’t wait for messages or user input — they use timers to trigger actions periodically.

Today, we’ll learn to give our bots their own alarm clocks using ROS2 Timers.

---

⏰ Timers in ROS2: What Are They?

In simple terms, a timer tells your bot:

“Hey! Every x seconds, do this thing.”

Timers are perfect for:

• Repeating actions at intervals

• Scheduling routines

• Looping without using while True

---

🧠 How ROS2 Timers Work (Simple Mental Model)

Think of it like this:

Timer = A robot’s digital alarm clock.
Every few seconds → “Ring!” → Run a task.

You set:

• The interval (e.g., every 2 seconds)

• The callback function (what to do when the alarm rings)

---

🤖 Introducing WaterBot

Let’s build WaterBot, who waters plants every 5 seconds.

📁 Folder Prep (Inside robot_town_ws/src/water_bot/)

water_bot/
├── water_bot/
│   ├── __init__.py
│   └── water_node.py
├── package.xml
├── setup.py
└── resource/
    └── water_bot

Make sure CMakeLists.txt and setup.cfg are set up (like in previous bots).

---

💧 water_node.py

Here’s a simple timer-powered ROS2 node.

import rclpy
from rclpy.node import Node

class WaterBot(Node):
    def __init__(self):
        super().__init__('water_bot')  # Initialize the node with the name 'water_bot'
        self.counter = 0  # Keeps track of how many times the plants have been watered

        # 🕒 Create a timer that triggers the water_plants method every 5 seconds
        # - 5.0 is the interval in seconds
        # - self.water_plants is the callback function to call every interval
        self.timer = self.create_timer(5.0, self.water_plants)

        # 📝 Log startup message to indicate the bot is active
        self.get_logger().info('WaterBot is on duty!')

    def water_plants(self):
        # 🧮 Increment the watering counter
        self.counter += 1

        # 📣 Log each watering action with round number
        self.get_logger().info(f'🌱 Watering plants... round {self.counter}')

def main(args=None):
    rclpy.init(args=args)     # 🔌 Initialize the ROS 2 system
    node = WaterBot()         # 🤖 Create an instance of WaterBot
    rclpy.spin(node)          # 🔄 Keep the node alive and processing timer callbacks
    rclpy.shutdown()          # 📴 Shutdown the ROS 2 system when done

if __name__ == '__main__':
    main()  # 🏁 Run the main function if this file is executed directly

---

🔨 Build & Run WaterBot

Build your workspace:

colcon build
source install/setup.bash

Then run:

ros2 run water_bot water_node

Expected output:

[INFO] [water_bot]: WaterBot is on duty!
[INFO] [water_bot]: 🌱 Watering plants... round 1
[INFO] [water_bot]: 🌱 Watering plants... round 2
...

---

🧭 What’s Happening Behind the Scenes?

create_timer(interval, callback)

• Calls callback() every interval seconds.

rclpy.spin(node)

• Keeps the bot running and waiting for timer events.

• Like a power grid that lets timers tick.

---

🗂️ Folder Structure Recap

Here’s how your WaterBot package should now look:

robot_town_ws/
└── src/
    ├── water_bot/
    │   ├── water_bot/
    │   │   └── water_node.py
    │   ├── package.xml
    │   ├── setup.py
    │   ├── setup.cfg
    │   └── resource/
    │       └── water_bot

If you've built mayor_bot, door_bot, chatter_bot, etc., your workspace may now look like:

src/
├── mayor_bot/
├── door_bot/
├── chatter_bot/
├── weather_bot/
├── umbrella_bot/
├── chef_bot/
├── water_bot/

One big bustling bot community!

---

🧹 Enter TrashBot: Evening Cleanup Duty

Let’s build a second bot: TrashBot, who takes out the trash every 3 seconds.

---

🛠️ Folder Setup (Inside robot_town_ws/src/trash_bot/)

trash_bot/
├── trash_bot/
│   ├── __init__.py
│   └── trash_node.py
├── package.xml
├── setup.py
└── resource/
    └── trash_bot

---

♻️ trash_node.py

import rclpy
from rclpy.node import Node

class TrashBot(Node):
    def __init__(self):
        super().__init__('trash_bot')
        self.counter = 0

        # Timer: every 3 seconds
        self.timer = self.create_timer(3.0, self.take_out_trash)
        self.get_logger().info('TrashBot reporting for duty!')

    def take_out_trash(self):
        self.counter += 1
        self.get_logger().info(f'🗑️ Taking out trash... trip {self.counter}')

def main(args=None):
    rclpy.init(args=args)
    node = TrashBot()
    rclpy.spin(node)
    rclpy.shutdown()

if __name__ == '__main__':
    main()

---

🔀 Launching WaterBot + TrashBot Together

Now let’s create a launch file to wake both bots up together, like setting multiple alarms in one clock.

---

📂 Create a New Package: daily_schedule

tcd ~/robot_town_ws/src
ros2 pkg create --build-type ament_python daily_schedule

Inside daily_schedule/launch/, create:

daily_schedule/
├── daily_schedule/
│   └── __init__.py
├── launch/
│   └── morning_routine.launch.py
├── package.xml
├── setup.py
└── resource/
    └── daily_schedule

---

🌄 morning_routine.launch.py

from launch import LaunchDescription               # 📦 Import the LaunchDescription object from the 'launch' module
from launch_ros.actions import Node                # 🚀 Import the Node action from the ROS 2 launch system

def generate_launch_description():
    return LaunchDescription([                     # 📜 Create and return a list of launch actions

        # 🌊 Launch WaterBot
        Node(
            package='water_bot',                   # The ROS 2 package containing the node
            executable='water_node',               # The executable name defined in setup.py or entry_points
            name='water_bot'                       # The name the node will use in the ROS graph
        ),

        # 🗑️ Launch TrashBot
        Node(
            package='trash_bot',                   # Package where the trash bot's code lives
            executable='trash_node',               # The actual ROS 2 executable for TrashBot
            name='trash_bot'                       # Node name used for logging, namespace, etc.
        ),
    ])

---

🧪 Build and Launch It

Step 1: Build Everything

cd ~/robot_town_ws
colcon build
source install/setup.bash

Step 2: Run the Routine

ros2 launch daily_schedule morning_routine.launch.py

---

🌇 Expected Output

[INFO] [water_bot]: WaterBot is on duty!
[INFO] [trash_bot]: TrashBot reporting for duty!

[INFO] [water_bot]: 🌱 Watering plants... round 1
[INFO] [trash_bot]: 🗑️ Taking out trash... trip 1
[INFO] [trash_bot]: 🗑️ Taking out trash... trip 2
[INFO] [water_bot]: 🌱 Watering plants... round 2
...

---

🗂️ Robot Town So Far

Here’s how your workspace might look now:

robot_town_ws/
└── src/
    ├── mayor_bot/
    ├── door_bot/
    ├── chatter_bot/
    ├── weather_bot/
    ├── umbrella_bot/
    ├── chef_bot/
    ├── water_bot/
    ├── trash_bot/
    └── daily_schedule/

Each bot lives in its own home, and daily_schedule acts like the Town Planner, coordinating routines.

---

🧠 What You Learned

• ROS2 Timers let bots perform tasks at scheduled intervals.

• create_timer() is used to register periodic callbacks.

• Launch files can activate multiple bots together like synchronized clocks.

---

✅ Mini Project: Build a Chore Scheduler

Create more bots with timers:

• 🧽 CleanBot: cleans every 10 sec

• 🚗 PatrolBot: patrols every 7 sec

• 🍽️ ServeBot: serves food every 4 sec

Add them to your morning_routine.launch.py!

---

📰 Coming Up Next:

Silent Conversations (Actions in ROS2)

Bots will now make requests that take time, and wait for replies — like ordering parts or requesting repairs.

---

Ready to turn bots into helpful collaborators instead of just time-based task machines?
Let’s build silent action bots in the next issue of Robot Town! 🛠️🤖