Skip to content

完整源码与下载 ​

当前示例为 C++17。四个程序独立编译,共用头文件随源码一起提供。

下载完整示例(ZIP,含 CMake 和说明文档)

下面的代码与下载包来自同一份项目快照。博客可以独立构建,不依赖原项目在部署机器上存在。

Blue.cpp ​

cpp
/**
 * @file Blue.cpp
 * @brief 模拟 BLE 外设链路控制流程,射频时序交给芯片协议栈。
 * @author 兆鸣嵌入式
 */
#include "StateMachine.hpp"
#include <cstdio>

namespace {
enum class State : std::uint8_t {
    Idle, Advertising, Connected, Backoff, Count
};
enum class Event : std::uint8_t {
    Start, Connected, RxValid, Timeout, Stop, Fault, Count
};
constexpr std::uint32_t kAdvertisingTimeoutMs = 5000;
constexpr std::uint32_t kSupervisionTimeoutMs = 1000;
constexpr std::uint32_t kRetryDelayMs = 200;

struct RadioPort {
    virtual ~RadioPort() = default;
    virtual bool ready() const noexcept = 0;
    virtual void advertise() noexcept = 0;
    virtual void stopAdvertising() noexcept = 0;
    virtual void disconnect() noexcept = 0;
    virtual void reset() noexcept = 0;
    virtual void sleep() noexcept = 0;
    // 每次最多取出一个控制器事件,不等待无线电活动。
    virtual bool nextEvent(Event& event) noexcept = 0;
};

class BleLink {
public:
    explicit BleLink(RadioPort& radio) noexcept : radio_(radio)
    {
        onEntry(state_);
    }
    BleLink(const BleLink&) = delete;
    BleLink& operator=(const BleLink&) = delete;

    /** 启动和停止请求必须与 poll() 在同一工作任务中执行。 */
    fsm::Result request(Event event, std::uint32_t now) noexcept
    {
        now_ = now;
        return feed(event);
    }

    /** 由驱动工作任务周期调用,不可在中断服务程序中执行。 */
    fsm::Result poll(std::uint32_t now) noexcept
    {
        now_ = now;
        Event event = Event::Count;
        auto result = fsm::Result::Ignored;
        if (radio_.nextEvent(event)) {
            // 待处理的控制器完成事件优先于本地超时。
            result = feed(event);
            if (result == fsm::Result::InvalidEvent) {
                return result;
            }
        }
        if (state_ == State::Advertising &&
            fsm::elapsed(now_, entered_, kAdvertisingTimeoutMs)) {
            return feed(Event::Timeout);
        }
        if (state_ == State::Connected &&
            fsm::elapsed(now_, lastRx_, kSupervisionTimeoutMs)) {
            return feed(Event::Timeout);
        }
        if (state_ == State::Backoff &&
            fsm::elapsed(now_, entered_, kRetryDelayMs)) {
            return feed(Event::Timeout);
        }
        return result;
    }
    State state() const noexcept { return state_; }

private:
    fsm::Result feed(Event event) noexcept
    {
        using T = fsm::Transition<BleLink, State>;
        constexpr auto idle = T{State::Idle, nullptr, nullptr, false};
        constexpr auto adv = T{State::Advertising, nullptr, nullptr, false};
        constexpr auto link = T{State::Connected, nullptr, nullptr, false};
        constexpr auto wait = T{State::Backoff, nullptr, nullptr, false};
        constexpr auto retry = T{State::Advertising, nullptr, &BleLink::ready};
        constexpr auto stop = T{State::Idle};
        constexpr auto recover = T{State::Backoff};
        // 事件列顺序:启动、连接完成、有效接收、超时、停止、故障。
        static constexpr auto transitions =
            fsm::table<fsm::index(State::Count)>(
                fsm::row<fsm::index(Event::Count)>(
                    retry, idle, idle, idle, idle, idle),
                fsm::row<fsm::index(Event::Count)>(
                    adv, T{State::Connected}, adv, recover, stop, recover),
                fsm::row<fsm::index(Event::Count)>(
                    link, link, T{State::Connected, &BleLink::refreshRx},
                    recover, stop, recover),
                fsm::row<fsm::index(Event::Count)>(
                    wait, wait, wait, retry, stop, wait));
        static_assert(fsm::validTargets(transitions), "Invalid target");
        return fsm::dispatch(*this, state_, event, transitions,
            fsm::Hooks<BleLink, State>{&BleLink::onEntry, &BleLink::onExit});
    }
    bool ready() const noexcept { return radio_.ready(); }
    void refreshRx() noexcept { lastRx_ = now_; }
    void onEntry(State state) noexcept
    {
        entered_ = now_;
        switch (state) {
        case State::Idle: radio_.sleep(); break;
        case State::Advertising: radio_.advertise(); break;
        case State::Connected: lastRx_ = now_; break;
        case State::Backoff: radio_.reset(); break;
        default: break;
        }
    }
    void onExit(State state) noexcept
    {
        if (state == State::Advertising) {
            radio_.stopAdvertising();
        } else if (state == State::Connected) {
            radio_.disconnect();
        }
    }
    RadioPort& radio_;
    State state_ = State::Idle;
    std::uint32_t now_ = 0;
    std::uint32_t entered_ = 0;
    std::uint32_t lastRx_ = 0;
};

class SimRadio final : public RadioPort {
public:
    bool ready() const noexcept override { return isReady; }
    void advertise() noexcept override { std::puts("  start advertising"); }
    void stopAdvertising() noexcept override
    {
        std::puts("  stop advertising");
    }
    void disconnect() noexcept override { std::puts("  close connection"); }
    void reset() noexcept override { std::puts("  reset controller"); }
    void sleep() noexcept override { std::puts("  radio idle"); }
    bool nextEvent(Event& event) noexcept override
    {
        if (pending == Event::Count) {
            return false;
        }
        event = pending;
        pending = Event::Count;
        return true;
    }
    bool isReady = true;
    Event pending = Event::Count;
};

static bool runScenario() noexcept
{
    SimRadio radio;
    BleLink ble(radio);
    radio.isReady = false;
    bool ok = ble.request(Event::Start, 0) == fsm::Result::GuardRejected;
    radio.isReady = true;
    ok &= ble.request(Event::Start, 0) == fsm::Result::Handled;
    ok &= ble.request(Event::Start, 1) == fsm::Result::Ignored;
    radio.pending = Event::Connected;
    ok &= ble.poll(100) == fsm::Result::Handled;
    radio.pending = Event::RxValid;
    ok &= ble.poll(500) == fsm::Result::Handled;
    ok &= ble.poll(1499) == fsm::Result::Ignored;
    // 即使收到无关事件,也必须正常检查链路监督超时。
    radio.pending = Event::Start;
    ok &= ble.poll(1500) == fsm::Result::Handled;
    ok &= ble.state() == State::Backoff;
    ok &= ble.poll(1699) == fsm::Result::Ignored;
    radio.isReady = false;
    ok &= ble.poll(1700) == fsm::Result::GuardRejected;
    ok &= ble.state() == State::Backoff;
    radio.isReady = true;
    ok &= ble.poll(1700) == fsm::Result::Handled;
    ok &= ble.poll(6700) == fsm::Result::Handled;
    ok &= ble.poll(6900) == fsm::Result::Handled;
    radio.pending = Event::Fault;
    ok &= ble.poll(6901) == fsm::Result::Handled;
    ok &= ble.request(Event::Stop, 6902) == fsm::Result::Handled;
    ok &= ble.state() == State::Idle;
    ok &= ble.request(Event::Count, 6903) == fsm::Result::InvalidEvent;
    return ok;
}
} // 匿名命名空间结束

int main()
{
    const bool ok = runScenario();
    std::puts(ok ? "Blue: PASS" : "Blue: FAIL");
    return ok ? 0 : 1;
}

Button.cpp ​

cpp
/**
 * @file Button.cpp
 * @brief 低电平有效面板按键的按下与释放消抖。
 * @author 兆鸣嵌入式
 */
#include "StateMachine.hpp"
#include <array>
#include <cstdio>
#include <limits>

namespace {
enum class Level : std::uint8_t { Low, High };
enum class ButtonEvent : std::uint8_t { Pressed, Released };
enum class State : std::uint8_t {
    Released, DebouncePress, Pressed, DebounceRelease, Count
};
constexpr std::uint32_t kDebounceMs = 20;

struct ButtonSink {
    virtual ~ButtonSink() = default;
    virtual void onButton(ButtonEvent event) noexcept = 0;
};

class Button {
public:
    explicit Button(ButtonSink& sink) noexcept : sink_(sink) {}
    Button(const Button&) = delete;
    Button& operator=(const Button&) = delete;

    /** 每隔 1~5ms 传入一次 GPIO 采样,初始状态为释放。
     *  非法电平返回 false;通知接收者不得重入 sample()。 */
    bool sample(Level level, std::uint32_t now) noexcept
    {
        if (level != Level::Low && level != Level::High) {
            return false;
        }
        static constexpr auto handlers = std::array{
            &Button::released, &Button::debouncePress,
            &Button::pressed, &Button::debounceRelease
        };
        static_assert(handlers.size() == fsm::index(State::Count),
                      "Missing state handler");
        (this->*handlers[fsm::index(state_)])(level, now);
        return true;
    }
    State state() const noexcept { return state_; }

private:
    void change(State next, std::uint32_t now) noexcept
    {
        state_ = next;
        // 进入动作:仅在出现新的候选边沿时启动消抖计时。
        entered_ = now;
    }
    void released(Level level, std::uint32_t now) noexcept
    {
        if (level == Level::Low) {
            change(State::DebouncePress, now);
        }
    }
    void debouncePress(Level level, std::uint32_t now) noexcept
    {
        if (level == Level::High) {
            change(State::Released, now);
        } else if (fsm::elapsed(now, entered_, kDebounceMs)) {
            change(State::Pressed, now);
            sink_.onButton(ButtonEvent::Pressed);
        }
    }
    void pressed(Level level, std::uint32_t now) noexcept
    {
        if (level == Level::High) {
            change(State::DebounceRelease, now);
        }
    }
    void debounceRelease(Level level, std::uint32_t now) noexcept
    {
        if (level == Level::Low) {
            change(State::Pressed, now);
        } else if (fsm::elapsed(now, entered_, kDebounceMs)) {
            change(State::Released, now);
            sink_.onButton(ButtonEvent::Released);
        }
    }
    ButtonSink& sink_;
    State state_ = State::Released;
    std::uint32_t entered_ = 0;
};

class SimPanel final : public ButtonSink {
public:
    void onButton(ButtonEvent event) noexcept override
    {
        if (event == ButtonEvent::Pressed) {
            ++presses;
            std::puts("[button] one stable PRESS -> request playback");
        } else {
            ++releases;
            std::puts("[button] one stable RELEASE");
        }
    }
    std::uint32_t presses = 0;
    std::uint32_t releases = 0;
};

static bool runScenario() noexcept
{
    struct Sample { std::uint32_t time; Level level; };
    // 10/12/15ms 模拟按下抖动,120/125/130ms 模拟释放抖动。
    constexpr auto samples = std::array{
        Sample{0, Level::High}, Sample{10, Level::Low},
        Sample{12, Level::High}, Sample{15, Level::Low},
        Sample{34, Level::Low}, Sample{35, Level::Low},
        Sample{100, Level::Low}, Sample{120, Level::High},
        Sample{125, Level::Low}, Sample{130, Level::High},
        Sample{149, Level::High}, Sample{150, Level::High}
    };
    SimPanel panel;
    Button button(panel);
    bool ok = true;
    for (const auto& sample : samples) {
        ok &= button.sample(sample.level, sample.time);
    }
    ok &= panel.presses == 1 && panel.releases == 1;
    ok &= button.state() == State::Released;

    // 在 uint32_t 毫秒计数回绕前开始一次候选按下。
    constexpr auto nearWrap = std::numeric_limits<std::uint32_t>::max()
                              - kDebounceMs / 2;
    ok &= button.sample(Level::Low, nearWrap);
    ok &= button.sample(Level::Low, 8);
    ok &= panel.presses == 1;
    ok &= button.sample(Level::Low, 9);
    ok &= panel.presses == 2;
    ok &= button.sample(Level::High, 10);
    ok &= button.sample(Level::High, 30);
    ok &= panel.releases == 2;
    ok &= !button.sample(static_cast<Level>(2), 31);
    return ok;
}
} // 匿名命名空间结束

int main()
{
    const bool ok = runScenario();
    std::puts(ok ? "Button: PASS" : "Button: FAIL");
    return ok ? 0 : 1;
}

Phase.cpp ​

cpp
/**
 * @file Phase.cpp
 * @brief 面向 DMA 或中断字节流的 UART 增量帧解析器。
 * @author 兆鸣嵌入式
 */
#include "StateMachine.hpp"
#include <array>
#include <cstdio>
#include <limits>

namespace {
constexpr std::uint8_t kHeaderFirst = 0xAA;
constexpr std::uint8_t kHeaderSecond = 0x55;
constexpr std::size_t kMaxPayload = 16;
constexpr std::size_t kFrameOverhead = 5;
constexpr std::uint32_t kInterByteTimeoutMs = 50;
enum class State : std::uint8_t {
    SyncFirst, SyncSecond, Length, Command, Payload, Checksum, Count
};
enum class ParseResult : std::uint8_t {
    Pending, FrameReady, InvalidLength, ChecksumError, Timeout
};
struct Frame {
    std::uint8_t command = 0;
    std::uint8_t length = 0;
    std::array<std::uint8_t, kMaxPayload> payload{};
};
struct FrameSink {
    virtual ~FrameSink() = default;
    // 帧引用仅在回调期间有效;如需入队,必须复制帧数据。
    virtual void onFrame(const Frame& frame) noexcept = 0;
};

class Parser {
public:
    explicit Parser(FrameSink& sink) noexcept : sink_(sink) {}
    Parser(const Parser&) = delete;
    Parser& operator=(const Parser&) = delete;

    /** 在所属任务中输入一个字节;回调不得重入解析器。 */
    ParseResult feed(std::uint8_t byte, std::uint32_t now) noexcept
    {
        const auto timeout = tick(now);
        static constexpr auto handlers = std::array{
            &Parser::syncFirst, &Parser::syncSecond, &Parser::length,
            &Parser::command, &Parser::payload, &Parser::checksum
        };
        static_assert(handlers.size() == fsm::index(State::Count),
                      "Missing parser state");
        lastByte_ = now;
        const auto result = (this->*handlers[fsm::index(state_)])(byte);
        return result == ParseResult::Pending ? timeout : result;
    }

    /** 接收静默时也要检查时间,使未完成的帧能够超时释放。 */
    ParseResult tick(std::uint32_t now) noexcept
    {
        if (state_ != State::SyncFirst &&
            fsm::elapsed(now, lastByte_, kInterByteTimeoutMs)) {
            reset();
            return ParseResult::Timeout;
        }
        return ParseResult::Pending;
    }
    State state() const noexcept { return state_; }

private:
    void reset() noexcept
    {
        state_ = State::SyncFirst;
        offset_ = 0;
        xor_ = 0;
        frame_.length = 0;
    }
    void resync(std::uint8_t byte) noexcept
    {
        reset();
        // 被拒绝的字节也可能是下一候选帧头的起始字节。
        if (byte == kHeaderFirst) {
            state_ = State::SyncSecond;
        }
    }
    ParseResult syncFirst(std::uint8_t byte) noexcept
    {
        if (byte == kHeaderFirst) {
            state_ = State::SyncSecond;
        }
        return ParseResult::Pending;
    }
    ParseResult syncSecond(std::uint8_t byte) noexcept
    {
        if (byte == kHeaderSecond) {
            state_ = State::Length;
        } else if (byte != kHeaderFirst) {
            reset();
        }
        return ParseResult::Pending;
    }
    ParseResult length(std::uint8_t byte) noexcept
    {
        if (byte > kMaxPayload) {
            resync(byte);
            return ParseResult::InvalidLength;
        }
        frame_.length = byte;
        xor_ = byte;
        offset_ = 0;
        state_ = State::Command;
        return ParseResult::Pending;
    }
    ParseResult command(std::uint8_t byte) noexcept
    {
        frame_.command = byte;
        xor_ ^= byte;
        state_ = frame_.length == 0 ? State::Checksum : State::Payload;
        return ParseResult::Pending;
    }
    ParseResult payload(std::uint8_t byte) noexcept
    {
        // length() 已限制负载长度,收够指定字节后立即离开此状态。
        // 负载中与帧头相同的字节仍按普通数据处理。
        frame_.payload[offset_] = byte;
        ++offset_;
        xor_ ^= byte;
        if (offset_ == frame_.length) {
            state_ = State::Checksum;
        }
        return ParseResult::Pending;
    }
    ParseResult checksum(std::uint8_t byte) noexcept
    {
        if (byte != xor_) {
            resync(byte);
            return ParseResult::ChecksumError;
        }
        // 回调消费完帧引用后,才能重置负载长度。
        state_ = State::SyncFirst;
        sink_.onFrame(frame_);
        reset();
        return ParseResult::FrameReady;
    }
    FrameSink& sink_;
    Frame frame_{};
    State state_ = State::SyncFirst;
    std::size_t offset_ = 0;
    std::uint8_t xor_ = 0;
    std::uint32_t lastByte_ = 0;
};

class SimCommands final : public FrameSink {
public:
    void onFrame(const Frame& frame) noexcept override
    {
        ++frames;
        last = frame;
        std::printf("[UART] command=0x%02X, payload=%u bytes\n",
                    static_cast<unsigned>(frame.command),
                    static_cast<unsigned>(frame.length));
    }
    std::uint32_t frames = 0;
    Frame last{};
};

template <std::size_t Size>
constexpr auto encode(std::uint8_t command,
                      const std::array<std::uint8_t, Size>& payload) noexcept
{
    static_assert(Size <= kMaxPayload, "Payload too large");
    std::array<std::uint8_t, Size + kFrameOverhead> bytes{};
    bytes[0] = kHeaderFirst;
    bytes[1] = kHeaderSecond;
    bytes[2] = static_cast<std::uint8_t>(Size);
    bytes[3] = command;
    auto checksum = static_cast<std::uint8_t>(bytes[2] ^ command);
    for (std::size_t i = 0; i < Size; ++i) {
        bytes[i + 4] = payload[i];
        checksum ^= payload[i];
    }
    bytes.back() = checksum;
    return bytes;
}

template <std::size_t Size>
static ParseResult deliver(Parser& parser,
    const std::array<std::uint8_t, Size>& bytes, std::uint32_t now) noexcept
{
    auto result = ParseResult::Pending;
    for (auto byte : bytes) {
        result = parser.feed(byte, now);
    }
    return result;
}

static bool normalFrames(Parser& parser, SimCommands& commands) noexcept
{
    // 使用固定的线上字节序列验证校验结果,避免依赖 encode() 自证。
    constexpr auto wire = std::array<std::uint8_t, 7>{
        0xAA, 0x55, 0x02, 0x10, 0x01, 0x02, 0x11
    };
    bool ok = true;
    for (std::size_t i = 0; i < 4; ++i) {
        ok &= parser.feed(wire[i], 0) == ParseResult::Pending;
    }
    ok &= commands.frames == 0;
    for (std::size_t i = 4; i < wire.size(); ++i) {
        const auto result = parser.feed(wire[i], 10);
        ok &= result == (i + 1 == wire.size() ? ParseResult::FrameReady
                                             : ParseResult::Pending);
    }
    ok &= commands.last.command == 0x10;
    ok &= commands.last.length == 2 && commands.last.payload[1] == 2;
    constexpr auto empty = encode(0x20, std::array<std::uint8_t, 0>{});
    ok &= deliver(parser, empty, 10) == ParseResult::FrameReady;
    constexpr auto headerPayload = encode(0x30,
        std::array<std::uint8_t, 2>{kHeaderFirst, kHeaderSecond});
    ok &= deliver(parser, headerPayload, 10) == ParseResult::FrameReady;
    constexpr auto maximum = encode(0x40,
        std::array<std::uint8_t, kMaxPayload>{});
    ok &= deliver(parser, maximum, 10) == ParseResult::FrameReady;
    ok &= commands.frames == 4 && commands.last.length == kMaxPayload;
    return ok;
}

static bool recoveryFrames(Parser& parser, SimCommands& commands) noexcept
{
    constexpr auto good = encode(0x20, std::array<std::uint8_t, 0>{});
    auto bad = good;
    bad.back() ^= 1;
    bool ok = deliver(parser, bad, 20) == ParseResult::ChecksumError;
    constexpr auto oversized = std::array<std::uint8_t, 3>{
        kHeaderFirst, kHeaderSecond, kMaxPayload + 1
    };
    ok &= deliver(parser, oversized, 20) == ParseResult::InvalidLength;
    ok &= parser.feed(0x00, 20) == ParseResult::Pending;
    ok &= parser.feed(kHeaderFirst, 20) == ParseResult::Pending;
    // 遇到 AA AA 55 时,必须保留第二个 AA 作为候选帧头。
    ok &= deliver(parser, good, 20) == ParseResult::FrameReady;
    ok &= commands.frames == 5;
    ok &= parser.feed(kHeaderFirst, 100) == ParseResult::Pending;
    ok &= parser.feed(kHeaderSecond, 100) == ParseResult::Pending;
    ok &= parser.tick(149) == ParseResult::Pending;
    ok &= parser.tick(150) == ParseResult::Timeout;
    ok &= deliver(parser, good, 151) == ParseResult::FrameReady;
    constexpr auto nearWrap = std::numeric_limits<std::uint32_t>::max() - 10;
    ok &= parser.feed(kHeaderFirst, nearWrap) == ParseResult::Pending;
    ok &= parser.tick(38) == ParseResult::Pending;
    ok &= parser.tick(39) == ParseResult::Timeout;
    ok &= commands.frames == 6;
    // 旧候选帧超时后,不能丢弃同时到来的新帧头字节。
    ok &= parser.feed(kHeaderFirst, 100) == ParseResult::Pending;
    ok &= parser.feed(kHeaderFirst, 150) == ParseResult::Timeout;
    for (std::size_t i = 1; i < good.size(); ++i) {
        const auto result = parser.feed(good[i], 150);
        ok &= result == (i + 1 == good.size() ? ParseResult::FrameReady
                                             : ParseResult::Pending);
    }
    ok &= commands.frames == 7;
    ok &= parser.state() == State::SyncFirst;
    return ok;
}
} // 匿名命名空间结束

int main()
{
    SimCommands commands;
    Parser parser(commands);
    bool ok = normalFrames(parser, commands);
    ok &= recoveryFrames(parser, commands);
    std::puts(ok ? "Phase: PASS" : "Phase: FAIL");
    return ok ? 0 : 1;
}

Mode.cpp ​

cpp
/**
 * @file Mode.cpp
 * @brief 电池供电播放器:带守卫条件的工作模式切换。
 * @author 兆鸣嵌入式
 */
#include "StateMachine.hpp"
#include <cstdio>

namespace {
enum class State : std::uint8_t { Off, Standby, Play, Pause, Count };
enum class Event : std::uint8_t {
    On, Off, Pause, Play, LowBattery, Count
};
constexpr std::uint8_t kPlayBatteryThreshold = 20;
constexpr std::uint8_t kBatteryMaximum = 100;

// 硬件命令必须立即返回;适配异步板级驱动时,
// 失败与完成结果必须通过事件队列交付。
struct AudioPort {
    virtual ~AudioPort() = default;
    virtual void powerOn() noexcept = 0;
    virtual void powerOff() noexcept = 0;
    // 启动或恢复播放时,还需恢复退出播放状态前被静音的输出。
    virtual void start() noexcept = 0;
    virtual void pause() noexcept = 0;
    virtual void resume() noexcept = 0;
    virtual void mute() noexcept = 0;
};

class Player {
public:
    explicit Player(AudioPort& port) noexcept : port_(port)
    {
        onEntry(state_);
    }
    Player(const Player&) = delete;
    Player& operator=(const Player&) = delete;

    /** 串行输入一个事件;硬件端口不得递归调用本状态机。 */
    fsm::Result feed(Event event) noexcept
    {
        using T = fsm::Transition<Player, State>;
        constexpr auto off = T{State::Off, nullptr, nullptr, false};
        constexpr auto idle = T{State::Standby, nullptr, nullptr, false};
        constexpr auto play = T{State::Play, nullptr, nullptr, false};
        constexpr auto pause = T{State::Pause, nullptr, nullptr, false};
        constexpr auto stop = T{State::Off};
        // 事件列顺序:开机、关机、暂停、播放、低电量。
        static constexpr auto transitions =
            fsm::table<fsm::index(State::Count)>(
            fsm::row<fsm::index(Event::Count)>(
                T{State::Standby}, off, off, off, off),
            fsm::row<fsm::index(Event::Count)>(
                idle, stop, idle,
                T{State::Play, &Player::start, &Player::canPlay}, stop),
            fsm::row<fsm::index(Event::Count)>(
                play, stop, T{State::Pause, &Player::pause}, play, stop),
            fsm::row<fsm::index(Event::Count)>(
                pause, stop, pause,
                T{State::Play, &Player::resume, &Player::canPlay}, stop));
        static_assert(fsm::validTargets(transitions), "Invalid target");
        return fsm::dispatch(*this, state_, event, transitions,
            fsm::Hooks<Player, State>{&Player::onEntry, &Player::onExit});
    }

    /** 拒绝超过 100% 的电量测量值,不进行截断修正。 */
    bool setBattery(std::uint8_t percent) noexcept
    {
        if (percent > kBatteryMaximum) {
            return false;
        }
        battery_ = percent;
        return true;
    }
    State state() const noexcept { return state_; }

private:
    bool canPlay() const noexcept
    {
        return battery_ > kPlayBatteryThreshold;
    }
    void start() noexcept { port_.start(); }
    void pause() noexcept { port_.pause(); }
    void resume() noexcept { port_.resume(); }
    void onEntry(State state) noexcept
    {
        if (state == State::Off) {
            port_.powerOff();
        } else if (state == State::Standby) {
            port_.powerOn();
        }
    }
    void onExit(State state) noexcept
    {
        if (state == State::Play) {
            port_.mute();
        }
    }
    AudioPort& port_;
    State state_ = State::Off;
    std::uint8_t battery_ = kBatteryMaximum;
};

class SimAudio final : public AudioPort {
public:
    void powerOn() noexcept override { std::puts("  amplifier powered"); }
    void powerOff() noexcept override
    {
        std::puts("  stop decoder, amplifier off");
    }
    void start() noexcept override { std::puts("  decode from beginning"); }
    void pause() noexcept override { std::puts("  save playback position"); }
    void resume() noexcept override
    {
        std::puts("  resume saved position, unmute");
    }
    void mute() noexcept override { std::puts("  mute before leaving PLAY"); }
};

static bool runScenario() noexcept
{
    SimAudio audio;
    Player player(audio);
    bool ok = player.feed(Event::On) == fsm::Result::Handled;
    ok &= player.feed(Event::Pause) == fsm::Result::Ignored;
    ok &= player.state() == State::Standby;
    ok &= player.setBattery(kPlayBatteryThreshold);
    ok &= player.feed(Event::Play) == fsm::Result::GuardRejected;
    std::puts("[mode] battery=20%, PLAY rejected");
    ok &= player.setBattery(kBatteryMaximum);
    ok &= player.feed(Event::Play) == fsm::Result::Handled;
    ok &= player.feed(Event::Pause) == fsm::Result::Handled;
    ok &= player.feed(Event::Play) == fsm::Result::Handled;
    ok &= player.feed(Event::Play) == fsm::Result::Ignored;
    ok &= player.feed(Event::LowBattery) == fsm::Result::Handled;
    ok &= player.state() == State::Off;
    ok &= player.feed(Event::Count) == fsm::Result::InvalidEvent;
    ok &= !player.setBattery(kBatteryMaximum + 1);
    ok &= player.feed(Event::On) == fsm::Result::Handled;
    ok &= player.feed(Event::Off) == fsm::Result::Handled;
    return ok;
}
} // 匿名命名空间结束

int main()
{
    const bool ok = runScenario();
    std::puts(ok ? "Mode: PASS" : "Mode: FAIL");
    return ok ? 0 : 1;
}

StateMachine.hpp ​

cpp
/**
 * @file StateMachine.hpp
 * @brief 固定内存、表驱动的有限状态机基础组件(C++17)。
 * @author 兆鸣嵌入式
 */
#ifndef STATE_MACHINE_HPP
#define STATE_MACHINE_HPP

#include <array>
#include <cstddef>
#include <cstdint>

namespace fsm {

enum class Result { Handled, Ignored, GuardRejected, InvalidEvent };

template <typename Enum>
constexpr std::size_t index(Enum value) noexcept
{
    return static_cast<std::size_t>(value);
}

// 无符号差值支持正常的计时回绕,但不支持时钟被重置。
constexpr bool elapsed(std::uint32_t now, std::uint32_t since,
                       std::uint32_t interval) noexcept
{
    return static_cast<std::uint32_t>(now - since) >= interval;
}

template <typename Owner, typename State>
struct Transition {
    using Action = void (Owner::*)() noexcept;
    using Guard = bool (Owner::*)() const noexcept;
    State next;
    Action action = nullptr;
    Guard guard = nullptr;
    bool enabled = true;
};

// 先推导实际初始化条目数,再检查是否完整。
// 直接初始化 std::array<T, N> 会将缺失的单元静默补零。
template <std::size_t Count, typename... Cells>
constexpr auto row(Cells... cells) noexcept
{
    static_assert(sizeof...(Cells) == Count, "Missing event cell");
    return std::array{cells...};
}

template <std::size_t Count, typename... Rows>
constexpr auto table(Rows... rows) noexcept
{
    static_assert(sizeof...(Rows) == Count, "Missing state row");
    return std::array{rows...};
}

template <typename Table>
constexpr bool validTargets(const Table& transitions) noexcept
{
    for (const auto& row : transitions) {
        for (const auto& cell : row) {
            if (index(cell.next) >= transitions.size()) {
                return false;
            }
        }
    }
    return true;
}

template <typename Owner, typename State>
struct Hooks {
    using Hook = void (Owner::*)(State) noexcept;
    Hook entry;
    Hook exit;
};

// 串行分发事件,每次处理到完成;回调和动作不得递归投递到本状态机。
// 目标与当前状态相同视为内部转移,不执行退出和进入动作。
template <typename Owner, typename State, typename Event, typename Table>
Result dispatch(Owner& owner, State& state, Event event,
                const Table& transitions, Hooks<Owner, State> hooks) noexcept
{
    if (index(state) >= transitions.size() ||
        index(event) >= transitions[0].size()) {
        return Result::InvalidEvent;
    }
    const auto& cell = transitions[index(state)][index(event)];
    if (!cell.enabled) {
        return Result::Ignored;
    }
    if (cell.guard != nullptr && !(owner.*cell.guard)()) {
        return Result::GuardRejected;
    }
    const bool changes = cell.next != state;
    if (changes) {
        (owner.*hooks.exit)(state);
    }
    if (cell.action != nullptr) {
        (owner.*cell.action)();
    }
    state = cell.next;
    if (changes) {
        (owner.*hooks.entry)(state);
    }
    return Result::Handled;
}

} // 状态机基础组件命名空间
#endif // 状态机头文件保护结束

CMakeLists.txt ​

cmake
cmake_minimum_required(VERSION 3.16)
project(EmbeddedStateExamples LANGUAGES CXX)

enable_testing()
foreach(example IN ITEMS Blue Button Phase Mode)
    add_executable(${example} ${example}.cpp)
    set_target_properties(${example} PROPERTIES
        CXX_STANDARD 17
        CXX_STANDARD_REQUIRED YES
        CXX_EXTENSIONS NO)
    if(MSVC)
        target_compile_options(${example} PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(${example} PRIVATE
            -Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion
            -Werror -fno-exceptions -fno-rtti)
    endif()
    add_test(NAME ${example}_scenario COMMAND ${example})
endforeach()

记录实践,持续学习。