Implementing State Machines in Embedded C

Quick Answer

Finite State Machines (FSM) in embedded C are best implemented using switch-case statements for simple FSMs, table-driven approaches for medium complexity, and function pointer arrays for maximum flexibility. Key principles: keep states discrete, handle all events in each state, use explicit state transitions.

Introduction

State machines are fundamental to embedded systems design. From button debouncing to communication protocols, motor control to user interfaces, state machines provide a structured way to manage complex behavior with clear, deterministic transitions between operational modes.

Core Content

1. State Machine Fundamentals

Components of an FSM

• States: Discrete modes of operation (Idle, Running, Error)
• Events: Triggers that cause state transitions
• Transitions: Rules for moving between states
• Actions: Operations performed during transitions
• Guard Conditions: Boolean conditions for transition

2. Switch-Case Implementation

typedef enum {
    STATE_IDLE,
    STATE_RUNNING,
    STATE_ERROR
} SystemState;

void FSM_Process(SystemState *state, Event event) {
    switch (*state) {
        case STATE_IDLE:
            if (event == EVENT_START) {
                *state = STATE_RUNNING;
            }
            break;
        case STATE_RUNNING:
            if (event == EVENT_ERROR) {
                *state = STATE_ERROR;
            }
            break;
        case STATE_ERROR:
            if (event == EVENT_RESET) {
                *state = STATE_IDLE;
            }
            break;
    }
}

3. Table-Driven Implementation

typedef struct {
    State current;
    Event event;
    State next;
    void (*action)(void);
} Transition;

Transition table[] = {
    {STATE_IDLE, EVENT_START, STATE_RUNNING, StartAction},
    {STATE_RUNNING, EVENT_STOP, STATE_IDLE, StopAction}
};

FAQ

When should I use a state machine vs. simple if-else logic?

Use a state machine when: System has distinct operational modes, behavior depends on history, or there are complex sequences of events. Use if-else for simple, stateless logic.

How do I handle timing in state machines?

Use timeout events. Set a timer when entering a state, and handle the timeout event to transition. This keeps the FSM non-blocking and responsive.

Conclusion

State machines are essential for embedded systems:

• Switch-Case: Simple, readable, best for small FSMs
• Table-Driven: Flexible, maintainable, good for medium complexity
• Function Pointers: Extensible, object-oriented, for complex systems

Need Help with Embedded System Design?

InnovChip provides embedded firmware development and consulting services. Contact us today for assistance with state machine design, firmware architecture, and embedded system development.