임베디드 State Machine 패턴 — Variant·Visitor·Table-driven 비교

1
bool is_idle = true;
2
bool is_playing = false;
3
bool is_paused = false;
4

5
void play() {
6
    if (is_idle) {
7
        is_idle = false;
8
        is_playing = true;
9
    }
10
    // ...복잡, 상태 invariant 깨지기 쉬움
11
}

1
enum class State { Stopped, Playing, Paused };
2

3
State current_state = State::Stopped;
4

5
void on_play() {
6
    switch (current_state) {
7
        case State::Stopped:
8
            start_playback();
9
            current_state = State::Playing;
10
            break;
11
        case State::Paused:
12
            resume_playback();
13
            current_state = State::Playing;
14
            break;
15
        case State::Playing:
16
            // 이미 재생 중 — 무시
17
            break;
18
    }
19
}
20

21
void on_pause() {
22
    if (current_state == State::Playing) {
23
        pause_playback();
24
        current_state = State::Paused;
25
    }
26
}
27

28
void on_stop() {
29
    if (current_state != State::Stopped) {
30
        stop_playback();
31
        current_state = State::Stopped;
32
    }
33
}

1
#include <variant>
2

3
struct Stopped {};
4
struct Playing { uint32_t position; };
5
struct Paused  { uint32_t position; };
6

7
using State = std::variant<Stopped, Playing, Paused>;
8

9
State current_state = Stopped{};
10

11
State on_play(State s) {
12
    return std::visit([](auto&& state) -> State {
13
        using T = std::decay_t<decltype(state)>;
14
        if constexpr (std::is_same_v<T, Stopped>) {
15
            start_playback();
16
            return Playing{0};
17
        }
18
        else if constexpr (std::is_same_v<T, Paused>) {
19
            resume_playback(state.position);
20
            return Playing{state.position};
21
        }
22
        else {
23
            return state;   // 이미 Playing
24
        }
25
    }, s);
26
}
27

28
State on_pause(State s) {
29
    return std::visit([](auto&& state) -> State {
30
        using T = std::decay_t<decltype(state)>;
31
        if constexpr (std::is_same_v<T, Playing>) {
32
            pause_playback();
33
            return Paused{state.position};
34
        }
35
        return state;
36
    }, s);
37
}
38

39
current_state = on_play(current_state);
40
current_state = on_pause(current_state);

1
struct Listen { uint16_t port; };
2
struct SynReceived { Conn conn; };
3
struct Established { Conn conn; uint32_t seq; };
4
struct FinWait { Conn conn; };
5
struct Closed {};
6

7
using TcpState = std::variant<Listen, SynReceived, Established, FinWait, Closed>;
8

9
TcpState handle_syn(TcpState s, const Packet& p) {
10
    return std::visit([&p](auto&& state) -> TcpState {
11
        using T = std::decay_t<decltype(state)>;
12
        if constexpr (std::is_same_v<T, Listen>) {
13
            return SynReceived{accept(state.port, p)};
14
        }
15
        return state;
16
    }, s);
17
}
18

19
TcpState handle_ack(TcpState s, const Packet& p) {
20
    return std::visit([&p](auto&& state) -> TcpState {
21
        using T = std::decay_t<decltype(state)>;
22
        if constexpr (std::is_same_v<T, SynReceived>) {
23
            return Established{state.conn, p.seq};
24
        }
25
        // ... 다른 state는 ack 무시
26
        return state;
27
    }, s);
28
}

1
#include <etl/fsm.h>
2

3
// Event 정의
4
class PlayEvent  : public etl::message<1> {};
5
class PauseEvent : public etl::message<2> {};
6
class StopEvent  : public etl::message<3> {};
7

8
// State ID
9
enum class StateId : etl::fsm_state_id_t {
10
    Stopped,
11
    Playing,
12
    Paused,
13
};
14

15
// FSM 클래스
16
class MediaPlayerFsm : public etl::fsm {
17
public:
18
    MediaPlayerFsm() : fsm(0) {}
19
    void log_transition(const char* msg) { /* */ }
20
};
21

22
// State 구현
23
class StoppedState : public etl::fsm_state<MediaPlayerFsm, StoppedState,
24
                                              (etl::fsm_state_id_t)StateId::Stopped,
25
                                              PlayEvent> {
26
public:
27
    etl::fsm_state_id_t on_event(const PlayEvent&) {
28
        get_fsm_context().log_transition("Stopped → Playing");
29
        start_playback();
30
        return (etl::fsm_state_id_t)StateId::Playing;
31
    }
32

33
    etl::fsm_state_id_t on_event_unknown(const etl::imessage&) {
34
        return STATE_ID;
35
    }
36
};
37

38
class PlayingState : public etl::fsm_state<MediaPlayerFsm, PlayingState,
39
                                              (etl::fsm_state_id_t)StateId::Playing,
40
                                              PauseEvent, StopEvent> {
41
public:
42
    etl::fsm_state_id_t on_event(const PauseEvent&) {
43
        pause_playback();
44
        return (etl::fsm_state_id_t)StateId::Paused;
45
    }
46

47
    etl::fsm_state_id_t on_event(const StopEvent&) {
48
        stop_playback();
49
        return (etl::fsm_state_id_t)StateId::Stopped;
50
    }
51

52
    etl::fsm_state_id_t on_event_unknown(const etl::imessage&) {
53
        return STATE_ID;
54
    }
55
};
56

57
// 사용
58
StoppedState stopped;
59
PlayingState playing;
60
PausedState paused;
61

62
etl::ifsm_state* states[] = {&stopped, &playing, &paused};
63

64
MediaPlayerFsm fsm;
65
fsm.set_states(states, etl::size(states));
66
fsm.start();
67

68
fsm.receive(PlayEvent{});
69
fsm.receive(PauseEvent{});
70
fsm.receive(StopEvent{});

1
// transition table — 컴파일 타임 데이터
2
struct Transition {
3
    StateId from;
4
    EventId event;
5
    StateId to;
6
};
7

8
constexpr Transition transitions[] = {
9
    {StateId::Stopped, EventId::Play,  StateId::Playing},
10
    {StateId::Playing, EventId::Pause, StateId::Paused},
11
    {StateId::Playing, EventId::Stop,  StateId::Stopped},
12
    {StateId::Paused,  EventId::Play,  StateId::Playing},
13
    {StateId::Paused,  EventId::Stop,  StateId::Stopped},
14
};
15

16
constexpr StateId next_state(StateId current, EventId event) {
17
    for (const auto& t : transitions) {
18
        if (t.from == current && t.event == event) return t.to;
19
    }
20
    return current;
21
}
22

23
// 런타임 또는 컴파일 타임
24
constexpr StateId s1 = next_state(StateId::Stopped, EventId::Play);
25
static_assert(s1 == StateId::Playing);
26

27
StateId state = StateId::Stopped;
28
state = next_state(state, EventId::Play);

1
template<typename FsmType>
2
void transition(FsmType& fsm, StateId from, StateId to, const char* event) {
3
    log_info("FSM transition: %s -> %s on %s",
4
             to_string(from), to_string(to), event);
5
    fsm.state = to;
6
}

1
bool playing = false;
2
bool paused = false;
3
playing = true;
4
paused = true;   // 둘 다 true? — 불가능한 상태

1
void on_play() { state = ...; }
2
void on_pause() { state = ...; }
3
void on_other() { state = ...; }
4
// 한곳에 모이지 않음

1
switch (state) {
2
    case A: break;
3
    case B: break;
4
    // C 처리 누락
5
}