完整源码与下载
当前示例为 C++17。四个程序独立编译,共用头文件随源码一起提供。
下面的代码与下载包来自同一份项目快照。博客可以独立构建,不依赖原项目在部署机器上存在。
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()