Finite State Machine (FSM) Controller

• Finite State Machine (FSM) controllers are algorithmic constructs defined by discrete states, transitions, and outputs, facilitating modular and verifiable control.
• They are applied in robotics, embedded systems, and hardware design to ensure real-time, scalable performance with rigorous correctness analysis.
• Recent advances enhance FSM controllers with hierarchical decomposition, optimal planning, and learning integration for improved reconfigurability and efficiency.

A finite state machine (FSM) controller is a mathematically formalized, algorithmic construct used to orchestrate complex system behaviors by encoding control logic as a set of discrete states, transitions, and outputs. FSM controllers are foundational in reactive embedded systems, robotics, hardware design, and verification, as they encode sequenced behaviors, enforce structural modularity, and admit rigorous correctness analysis. Recent research has expanded FSM controller architectures to address scalability, modularity, real-time optimal planning, integration with machine learning, reconfigurability, and formal synthesis.

1. Formal Definitions and Fundamental Structure

FSM controllers are typically defined by a 5-tuple: $M = (S, \Sigma, \delta, s_0, F)$ where

• $S$ is a finite set of states,
• $\Sigma$ is a finite input alphabet,
• $\delta: S \times \Sigma \rightarrow S$ is a deterministic transition function,
• $s_0 \in S$ is the initial state,
• $F \subseteq S$ is a set of accepting (or terminal) states.

For Mealy and Moore machine formulations, output is formalized as either

• Mealy: $\lambda: S \times \Sigma \to \Lambda$
• Moore: $\lambda: S \to \Lambda$

Hierarchical FSMs (HFSMs) generalize this by composing state machines into a tree or graph structure, where each node is itself an FSM (often a Mealy machine), supporting modular, recursive decomposition of complex control logic (Stefansson et al., 2023).

2. Hierarchical Finite State Machine (HiMM) Controllers

Scalability and optimal real-time planning in large systems are addressed using Hierarchical Mealy Machines (HiMM), as developed by Stefansson & Johansson (Stefansson et al., 2023):

• Architecture: An HiMM $\mathcal{Z} = (X, T)$ comprises a set $X$ of Mealy machines $$M=(Q(M), \Sigma, \Lambda, \delta_M, \gamma_M, s(M))$$ arranged in a hierarchy $T$ (a tree). Each state is either a leaf or references a child machine. State transitions can propagate up the hierarchy and descend via start states to leaves, supporting modular composition and flattening at query time.
• Optimal Exit Costs: For planning, the optimal cost to exit a submachine $M$ on input $x$ is denoted $c_x^M$ and derived via augmented machines $\hat M$ and Dijkstra’s algorithm.
• Two-Step Planning:
  • Preprocessing: For each submachine, compute all optimal exit costs and cache optimal trajectories using Dijkstra. This process scales linearly with the number of machines $N$.
  • Query: When tasked to plan between arbitrary initial and goal leaves, the controller collapses irrelevant portions of the hierarchy and solves a Dijkstra problem on a reduced graph of $O(|\Sigma|\cdot \text{depth}(Z))$ nodes, followed by an expansion phase to unroll abstract transitions into concrete sequences.
• Reconfigurability: Modifications (add, remove, modify machines/arcs) only require reprocessing the affected submachine and its ancestors, scaling with depth $D$.
• Empirical Performance: In large robotic planning examples ($\sim 92$K states, depth 3), HiMM enables query times 2 orders of magnitude faster than flat Dijkstra (0.025 s vs. 3.73 s) and rapid online recovery from environment changes, outperforming Contraction Hierarchies in update latency (Stefansson et al., 2023).

3. FSM Controllers in Robotic Systems and Embedded Hardware

FSM controller principles are applied across domains:

• Vending Machine Controllers: FSMs model billing, dispensing, and service logic (e.g., one-hot encoded Mealy FSMs implemented on FPGA), systematically reducing hardware complexity versus custom combinatorial designs, with measured switching times $\sim$9.3 ns and much lower hardware cost for logic reconfiguration (Monga et al., 2012).
• Quadrupedal Locomotion: Event-based FSMs coordinate gait phases, where a policy network modulates FSM parameters for contact-aware, robust behavior under domain randomization and real-world noise (PM-FSM architecture), leading to significant gains in velocity tracking, disturbance rejection, and sim-to-real transfer (Liu et al., 2021).
• Bipedal Manipulation in MuJoCo: FSMs structure stateful high-level tasks (walk, stand, grasp, lift) with low-level QP-based servo control laws, enabling synchronized interleaving of locomotion and manipulation and rigorous cycle-by-cycle verification of task completion (Singh et al., 2022).
• Swarm Robotics: FSMs are deployed for decentralized group behaviors, e.g., in ant-inspired walling tasks, encounter-triggered FSMs stabilize spatial group boundaries, with performance characterized via metrics such as mixing ratio reduction and convergence time (Kannapiran et al., 26 Oct 2025).

4. Advances: Evolutionary FSMs, Synthesis, and Integration with Learning

• Evolving FSMs: e-FSMs incrementally grow state spaces using online clustering (e.g., evolving Takagi–Sugeno methods) and update transition probability matrices in a Markovian fashion, enabling online discovery of latent-risk states (e.g. Dead-End in car following) and integration with RL-based controllers for proactive action revision (Han et al., 2019, Han et al., 2020).
• FSM Synthesis and Formal Verification: Frameworks such as RoboChart encode controllers as formal state machines with events, guards, clocks, and operations, and produce both CSP semantics (for model checking with FDR) and directly mapped C++ code, ensuring implementation is a refinement of specification (Li et al., 2017).
• LLM-Driven FSM Manipulation and Code Generation:
  • AutoFSM: Employs a multi-agent pipeline for structured FSM IR extraction, verification, and Verilog code generation, with SystemC-based co-simulation and automatic bug localization, yielding up to 12% higher pass rates and lower syntax error rates on complex benchmarks (Luo et al., 12 Dec 2025).
  • LLM-FSM: Benchmarks LLMs on NL$\to$YAML$\to$RTL FSM recovery, revealing challenges as state/transition complexity increases and demonstrating the impact of training- and test-time scaling (Wu et al., 3 Feb 2026).
  • FSM Modification by LLMs: Few-shot prompted LLMs enable rapid editing of structured FSM-based robotic behavior code from natural language instructions, achieving parity with human accuracy and 40-fold speedup for realistic robotics state machines (Gan et al., 2024).

5. Methodologies for Optimal Planning, Modularity, and Scalability

Recent advances focus on exploiting modular structure, optimizing plan computation, and scaling to large systems:

• Hierarchical Decomposition: Modularizing by domain (e.g., building$\rightarrow$room$\rightarrow$task) collapses the exponential growth of state spaces in flat FSMs to compositional hierarchies amenable to linear-time preprocessing and near-linear query complexity with respect to depth (Stefansson et al., 2023).
• Exit Cost Abstraction: Storing local optimal exit costs in each module allows recursive composition and rapid replanning under localized changes, supporting real-time adaptation in dynamic or partially-known environments (e.g., blocked robot routes, partially serviced vending machines).
• Robust Control via Policy Modulation: Event-based FSMs combined with parametrically modulated sub-policies (frequency, amplitude, foot height) show superior generalization to perturbations and facilitate low-dimension learning, as evidenced by the superior push-recovery and stair traversal scores in PM-FSM (Liu et al., 2021).
• Distributed Control in Swarms: FSM-based local rules—possibly augmented with reinforcement learning—underpin scalable, decentralized strategies for spatial separation, collision avoidance, and emergent group structures (Kannapiran et al., 26 Oct 2025, Li et al., 2022).

6. Limitations and Future Directions

• Limitations in Expressive Power: Classical FSMs encode only regular behaviors and finite memory; hybrid extensions (stochastic FSMs, POMDP hierarchies, hybrid automata) are required for uncountable state spaces, continuous control, or fine-grained uncertainty propagation (Stefansson et al., 2023).
• Design Scalability: Manual specification is impractical for high-complexity FSMs; automated synthesis, automatic modular decomposition, and formal IRs (e.g., JSON/YAML) are necessary for maintainability (Luo et al., 12 Dec 2025, Wu et al., 3 Feb 2026).
• Learning Integration and Verification: Ensuring that learning-based policies respect explicit FSM constraints or modular boundaries is a continuing challenge. Recent trends integrate symbolic FSM structure as priors or gating mechanisms for policy learning (Mu et al., 7 Mar 2025, Gan et al., 2024).
• Online Adaptation: Evolving FSMs and their stochastic generalizations enable controllers to recognize and adapt to novel states or transitions in non-stationary environments, but require theoretically sound clustering, transition learning, and safety labeling (Han et al., 2019, Han et al., 2020).

7. Application Domains and Performance Benchmarks

Domain	FSM Role	Key Metrics	Reference
Hierarchical robotic planning	Modular, optimal navigation	Query/preprocess time, scalability	(Stefansson et al., 2023)
Hardware RTL design	Structured code generation	Pass rate, syntax error rate	(Luo et al., 12 Dec 2025, Wu et al., 3 Feb 2026)
Swarm behavior	Local, decentralized control	Mixing ratio, convergence, success	(Kannapiran et al., 26 Oct 2025)
Quadrupedal locomotion	Event-gated phase policies	Velocity error, disturbance resist	(Liu et al., 2021)
Vending machine control	Transactional, Mealy style	Switching time, logical simplicity	(Monga et al., 2012)
FSM modification	LLM-guided code editing	Structural correctness, time	(Gan et al., 2024)

FSM controllers remain a fundamental paradigm for encoding, analyzing, and synthesizing discrete control logic, with research focused on algorithmic scalability, learning integration, modularization, and automated formal synthesis, ensuring reliability and adaptability across domains from embedded hardware to large-scale, dynamic robotic architectures.