Finite State Machine (FSM)

A state is a distinct, well-defined condition or mode of operation for a system. In robotics, a state represents a specific behavioral phase, such as IDLE, MOVING, GRASPING, or ERROR. The set of all possible states is finite and enumerable. For example, a simple pick-and-place robot might have states: SEARCH_FOR_OBJECT, APPROACH_OBJECT, GRIP_CLOSE, LIFT, MOVE_TO_GOAL, GRIP_OPEN, and RETURN_HOME. Each state encapsulates the logic and outputs relevant to that phase.

A transition is a directed change from one state to another, triggered by a specific event or condition. It defines the dynamic behavior of the FSM. Transitions are often labeled in the format Event [Guard] / Action.

• Event: An external or internal stimulus (e.g., object_detected, timer_expired, grasp_successful).
• Guard: An optional boolean condition that must be true for the transition to fire (e.g., [battery_level > 20%]).
• Action: An optional output or function executed during the transition (e.g., / play_sound(beep)).

An event is an instantaneous occurrence that may trigger a state transition. Events can be:

• External: Originating from sensors or user commands (e.g., button_pressed, lidar_obstacle).
• Internal: Generated by the system itself, often upon completion of a timed action or sub-process (e.g., motion_complete, processing_done).
• Temporal: Based on timers or clocks (e.g., 5_sec_timeout). In deterministic FSMs, for a given current state and event, the next state is uniquely defined.

An action is an output or operation produced by the FSM. Actions can be associated with transitions (executed during the state change) or with states themselves (executed upon entry, during, or upon exit).

• Entry Action: Executed exactly once when the state is entered.
• Exit Action: Executed exactly once when the state is exited.
• Do Activity: A continuous or prolonged activity that runs while the machine is in that state (e.g., run_motor(speed)).
• Transition Action: A one-shot output tied to a specific transition.

Every FSM has designated special states that define its start and completion criteria.

• Initial State: The unique state in which the machine begins operation when started or reset. It is often denoted with an unlabeled incoming arrow. A robot's initial state is typically INIT or STANDBY.
• Accepting State (or Final State): In some FSM models (particularly automata theory), a state that signifies the successful completion or acceptance of an input sequence. In robotic task planning, reaching a specific state like TASK_COMPLETE or HOME_POSITION can signal the end of a planned sequence.

These are the two primary representations of an FSM's logic.

• State Transition Table: A matrix that explicitly lists, for each current state and possible event, the corresponding next state and any associated action. It is unambiguous and easy to implement in code (e.g., as a lookup table or switch statement).
• State Transition Diagram: A directed graph visualization where circles represent states and arrows represent transitions. This format is superior for human design, communication, and debugging, as it provides an intuitive, high-level view of the system's flow and possible sequences.

A mobile robot's navigation stack often uses an FSM to manage its high-level operational modes. Common states include:

• Idle: Awaiting a goal.
• Planning: Computing a path using an algorithm like A* or RRT.
• Executing: Following the planned trajectory.
• Recovering: Handling failures (e.g., stuck, blocked path) by triggering a replan or a predefined recovery behavior.
• Goal Reached: Signaling completion and returning to Idle. Transitions are triggered by perception events (e.g., obstacle detected) or task completion (e.g., path followed). This modular design cleanly separates planning logic from low-level motor control.

Robotic pick-and-place tasks are naturally modeled as FSMs. A typical sequence for grasping an object includes:

1. Approach: Move the end-effector to a pre-grasp pose.
2. Grasp: Execute the closing command for the gripper.
3. Lift: Retract the arm vertically.
4. Transport: Move to a target location.
5. Place: Open the gripper to release the object. Each state waits for a sensor confirmation (e.g., force-torque reading for grasp success, vision check for object presence) before transitioning. This ensures robustness against execution uncertainties.

In collaborative robotics, FSMs manage the flow of interaction based on human input and system state. A collaborative assembly assistant might have states like:

• Listening: Processing speech or gesture input.
• Understanding: Parsing intent (e.g., "hand me the wrench").
• Acting: Executing the corresponding primitive action (fetching the tool).
• Confirming: Using audio or visual signals to request verification.
• Error Handling: Managing miscommunication or failed actions. This structure provides clear, auditable interaction logic, which is critical for safety and user trust in Human-Robot Interaction (HRI) systems.

In multi-robot systems, FSMs can define the communication and coordination protocol for collaborative tasks like search or transport. A robot's state might be:

• Exploring: Mapping an assigned region.
• Reporting: Broadcasting found items to peers.
• Assisting: Moving to aid another robot.
• Waiting: Pausing for a resource or signal. Transitions are governed by both internal conditions and messages received from other agents. This creates a predictable, decentralized control logic that is easier to debug than emergent behaviors from pure reactive systems.

FSMs are the backbone of robust execution monitoring systems. A supervisory FSM watches lower-level controllers and transitions to a recovery state upon detecting anomalies. For example:

• Normal Operation: Monitor sensor thresholds.
• Deviation Detected: E.g., joint torque exceeds limit.
• Pause: Halt all motors immediately.
• Diagnose: Check specific subsystems.
• Execute Recovery: Run a predefined safe routine (e.g., relax pose, request help).
• Resume/Abort: Transition back to operation or signal a total failure. This pattern is essential for safe deployment in unstructured environments.

FSMs act as the 'bridge' between symbolic planners and continuous control. A Hierarchical Task Network (HTN) or STRIPS planner outputs a sequence of high-level actions (e.g., NavigateTo(Kitchen), PickUp(Cup)). Each abstract action is implemented by an FSM that manages the detailed, sensor-driven execution. The FSM handles the temporal sequencing of lower-level skills (from a skill library) and the conditional logic required for real-world interaction, translating discrete plan steps into reliable physical behavior.

A modular, hierarchical control architecture for autonomous agents that structures decision-making using a tree of nodes. Unlike the flat transition logic of a basic FSM, Behavior Trees offer greater scalability and reactivity through composite nodes for sequences, fallbacks, and parallel execution. They are particularly effective for managing complex, conditional behaviors in game AI and robotics, where they can be dynamically pruned or extended.

A hierarchical planning formalism that decomposes high-level tasks into subtasks using a library of methods until primitive, executable actions are reached. While an FSM manages state transitions, an HTN planner reasons about task decomposition. In a robotic architecture, an HTN might generate a high-level plan (e.g., 'Deliver Package'), which is then executed and monitored by a lower-level FSM controlling the robot's operational modes.

The set of all possible configurations or conditions that a dynamical system, such as a robot, can occupy. For an FSM, the state space is the finite set of discrete states it is designed to handle. In broader robotics, the state space is defined by continuous variables like joint angles, positions, and velocities. Motion planning occurs within this continuous state space, with the FSM often managing the discrete mode (e.g., 'Planning', 'Executing', 'Recovering') of the planner itself.

A short, parameterized trajectory segment representing a fundamental movement, such as a 'reach', 'grasp', or 'turn'. These are the atomic building blocks for complex motion. An FSM can sequence a series of motion primitives to accomplish a task. For example, a 'Pick Object' state in an FSM might trigger a pre-defined 'reach-to-pose' primitive, followed by a 'close-gripper' primitive, with transitions conditioned on success/failure sensors.

The process of observing a robot's state and environment during plan execution to detect deviations from expected outcomes or failures. This is a critical function often managed by an FSM. The monitor compares sensor feedback against expectations defined for the current state. Upon detecting an anomaly (e.g., object slipped), it triggers a transition to a recovery state (e.g., 'Re-grasp' or 'Abort'), enabling robust closed-loop control.

An advanced, continuous control method where a dynamic model of the system is used to predict future behavior and solve a finite-horizon optimization problem online to determine optimal control inputs. MPC operates at a lower, faster timescale than an FSM. A typical architecture uses an FSM for high-level task sequencing ('Move to Zone A'), while an MPC controller handles the continuous, constraint-satisfying trajectory execution for that command.