Events for External Reflexes

In the previous Vision Tracking Using Depth tutorial, the robot was using the VisionRGBDFollower algorithm. This meant that the robot will wait for a user to send a request to the controller to follow a an object with a given ID.

In this tutorial, we will make the behavior intelligent. The robot will:

1. Idle/Patrol by default.

2. Switch to Follow Mode automatically when a “person” is detected in the video feed.

1. The Setup

Prerequisites: Completed Vision Tracking Using Depth.

We use the same component setup (Vision, Controller, DriveManager), but we initialize the Controller in path following mode (standard navigation) instead of Vision mode.

# Start the controller in standard navigation mode (PathFollowing)
controller = Controller(component_name="controller")
controller.algorithm = "PurePursuit" # Default mode
controller.direct_sensor = True

# Vision Component (as before)

2. Event A: Person Detected -> Follow

We want to detect if the class “person” appears in the detections list. If it does, we trigger the Controller’s Action Server to start the tracking behavior.

from kompass.ros import Event

# Trigger if "person" is in the list of detected labels
event_person_detected= Event(
    event_condition=detections_topic.msg.labels.contains("person"),
    on_change=True
)

The Action

We need to tell the Controller to switch behaviors. We use two actions:

1. Switch Algorithm: Change the internal logic to VisionRGBDFollower.

2. Trigger Action Server: Send a goal to the controller to start the active tracking loop.

Tip

If you link an Event to a set of Actions, the action set will get executed in sequence.

# Import the required actions
from kompass.actions import update_parameter, send_component_action_server_goal

# Import the vision follower 'ActionServer' ROS2 message
from kompass_interfaces.action import TrackVisionTarget

# Switch to vision following
# Option 1: use set_algorithm action from the controller (same as in the fallbacks tutorial)
# switch_algorithm_action =  Action(method=controller.set_algorithm, args=(ControllersID.VISION_DEPTH,))

# Option 2: use the update_parameter action to change the 'algorithm' parameter value
# the value can be set to ControllersID.VISION_DEPTH or directly the string name of the algorithm class VisionRGBDFollower
switch_algorithm_action = update_parameter(
    component=controller,
    param_name="algorithm",
    new_value="VisionRGBDFollower"
)

# Action to trigger the action server to follow a person
action_request_msg = TrackVisionTarget.Goal()
action_request_msg.label = "person"  # Specify the target to follow
action_start_person_following = send_component_action_server_goal(
    component=controller,
    request_msg=action_request_msg,
)

# Set the event/action(s) pair
events_action = {
    event_person_detected: [switch_algorithm_action, action_start_person_following]
}

4. Complete Recipe

Here is the complete script. Launch this, run it and stand in front of the robot to make it follow you!

turtlebot3_with_fallbacks.py

import numpy as np
from agents.components import Vision
from agents.config import VisionConfig
from agents.ros import Topic
from kompass.components import Controller, ControllerConfig, DriveManager, LocalMapper
from kompass.robot import (
    AngularCtrlLimits,
    LinearCtrlLimits,
    RobotGeometry,
    RobotType,
    RobotConfig,
)
from kompass.ros import Launcher, Event
from kompass.actions import update_parameter, send_component_action_server_goal
from kompass_interfaces.action import TrackVisionTarget


image0 = Topic(name="/camera/rgbd", msg_type="RGBD")
detections_topic = Topic(name="detections", msg_type="Detections")

detection_config = VisionConfig(threshold=0.5, enable_local_classifier=True)
vision = Vision(
    inputs=[image0],
    outputs=[detections_topic],
    trigger=image0,
    config=detection_config,
    component_name="detection_component",
)

# Setup your robot configuration
my_robot = RobotConfig(
    model_type=RobotType.ACKERMANN,
    geometry_type=RobotGeometry.Type.CYLINDER,
    geometry_params=np.array([0.1, 0.3]),
    ctrl_vx_limits=LinearCtrlLimits(max_vel=1,0, max_acc=3.0, max_decel=2.5),
    ctrl_omega_limits=AngularCtrlLimits(
        max_vel=4.0, max_acc=6.0, max_decel=10.0, max_steer=np.pi / 3
    ),
)

depth_cam_info_topic = Topic(name="/camera/aligned_depth_to_color/camera_info", msg_type="CameraInfo")

# Setup the controller
config = ControllerConfig(ctrl_publish_type="Parallel")
controller = Controller(component_name="controller", config=config)
controller.inputs(vision_detections=detections_topic, depth_camera_info=depth_cam_info_topic)
controller.algorithm = "VisionRGBDFollower"
controller.direct_sensor = False

# Add additional helper components
driver = DriveManager(component_name="driver")
mapper = LocalMapper(component_name="local_mapper")


# Define Event: Trigger if "person" is in the list of detected labels
event_person_detected= Event(
    event_condition=detections_topic.msg.labels.contains("person"),
    on_change=True
)

# Define Action(s)
switch_algorithm_action = update_parameter(
    component=controller,
    param_name="algorithm",
    new_value="VisionRGBDFollower"
)

# Action to trigger the action server to follow a person
action_request_msg = TrackVisionTarget.Goal()
action_request_msg.label = "person"  # Specify the target to follow
action_start_person_following = send_component_action_server_goal(
    component=controller,
    request_msg=action_request_msg,
)

# Set the event/action(s) pair
events_action = {
    event_person_detected: [switch_algorithm_action, action_start_person_following]
}

# Bring it up with the launcher
launcher = Launcher()

launcher.add_pkg(components=[vision], ros_log_level="warn",
                 package_name="automatika_embodied_agents",
                 executable_entry_point="executable",
                 multiprocessing=True)

# Add component and the events to monitor
launcher.kompass(components=[controller, mapper, driver], events_actions=events_action)

# Set the robot config for all components
launcher.robot = my_robot
launcher.bringup()

Next Steps

We have handled single-topic events for both cross-component healing and external reflexes. But real-world decisions are rarely based on one factor.

In the next tutorial, we will use Logic Gates to create smarter, composed events (e.g., “If Emergency Stop AND Battery Low”).

Logic Gates & Composed Events →