Implementing State Machines

In this lesson, you will learn how to use macros to enforce strict hardware state transitions at compile-time, ensuring your driver never enters an invalid operational state.

Enforcing Protocol Safety

When writing drivers, you often deal with hardware that must follow a strict sequence: PowerOff -> Initializing -> Ready -> Active. Using standard runtime variables for these states is error-prone. By leveraging procedural macros, we can generate a "typestate" pattern where each state is a unique structure, and transitions are only permitted through specific methods that consume the current state.

Instead of writing this boilerplate manually for every sensor or actuator, a custom derive macro can analyze your state definition and emit the necessary state-transition logic.

The Macro Approach

Imagine you define your states using a custom attribute. Your macro reads the TokenStream, parses the desired transitions, and generates a struct for each state. The key is to generate methods that consume self and return the next state struct:

#[state_machine]
pub enum SensorState {
    Idle -> Active,
    Active -> Idle,
    Active -> Error,
}

// Macro expands to:
pub struct Idle;
pub struct Active;

impl Idle {
    pub fn start(self) -> Active { Active }
}

impl Active {
    pub fn stop(self) -> Idle { Idle }
}

By generating these structures at compile-time, you turn "invalid state transition" bugs into "compiler error" bugs. If a developer tries to call .stop() on an Idle sensor, the Idle struct simply won't have that method, and the code will fail to compile.

Why use Macros here?

Writing these transitions by hand is tedious and leads to "state explosion." Macros allow you to define the topology of your hardware's state machine declaratively. The macro handles the heavy lifting of generating the state structs, the transition methods, and the type-safety checks, ensuring that your hardware driver is physically incapable of reaching an undefined state according to the manufacturer's datasheet.

Key Takeaway: By using procedural macros to generate typestate patterns, you shift the burden of hardware protocol validation from runtime checks to the Rust compiler's type system.