引言
在嵌入式开发中，如何在资源受限的单片机上实现高效并发一直是个挑战。传统RTOS虽然功能强大，但内存开销和复杂性较高。
本文介绍一种基于协程的轻量级并发方案，实现起来非常简单，通过创新的宏设计实现了代码段命名，大幅提升了代码的可读性和可维护性。
这个编程思路的灵感是lua语言带给我的，如果你学过lua你会发现我就是再精简的模拟lua语言的协程。
协程的基本原理
协程是一种用户态的轻量级线程，其切换由程序控制而不涉及内核态切换，因此开销极小。我们的实现基于 Duff's Device 技术，
通过 switch-case 语句和标号计算实现函数的多重入口。
协程框架核心设计
enum CoroutineStatus{
COROUTINE_READY = 0, // 就绪状态
COROUTINE_RUNNING = 1, // 运行状态
COROUTINE_SUSPENDED = 2, // 挂起状态
COROUTINE_FINISHED = 3 // 完成状态
};
struct Coroutine{
void *args, *res; //协程参数和返回值
size_t pc; //模拟程序计数器
enum CoroutineStatus status; // 当前状态
void (*func)(struct Coroutine *); // 协程函数
};
typedef struct Coroutine Coroutine;
typedef void (*CoroutineFuncType)(Coroutine *);
核心管理函数
// 初始化协程
void coroutineInit(Coroutine *cor, void *args, void *res, CoroutineFuncType func){
cor->args = args;
cor->res = res;
cor->func = func;
cor->pc = 1;
cor->status = COROUTINE_READY;
}
// 运行协程单步
int runCoroutine(Coroutine *cor) {
if (cor->status == COROUTINE_READY || cor->status == COROUTINE_SUSPENDED){
cor->status = COROUTINE_RUNNING;
cor->func(cor);
return 0;
}
return -1;
}
// 轮询调度器
void schedule(Coroutine *cor, size_t len){
int active;
do{
active = 0;
for (int i = 0; i < len; ++i){
if (cor[i].status != COROUTINE_FINISHED){
runCoroutine(&cor[i]);
active += 1;
}
}
}while (active);
}
协程控制宏
// 跳转到指定位置并挂起
#define COROUTINE_YIELD_SET_PC(cor, val) \
do{ \
(cor)->pc = val; \
(cor)->status = COROUTINE_SUSPENDED; \
return ; \
}while(0)
// 跳转到相对位置并挂起
#define COROUTINE_YIELD_NEXT(cor, delt) \
do{ \
(cor)->pc += delt; \
(cor)->status = COROUTINE_SUSPENDED; \
return ; \
}while(0)
// 结束协程
#define COROUTINE_END(cor) \
do{ \
(cor)->status = COROUTINE_FINISHED; \
return ; \
}while (0)
// 生成标签枚举
#define MAKE_LABEL(n1, p1, n2, p2, n3, p3, n4, p4, \
n5, p5, n6, p6, n7, p7, n8, p8, \
n9, p9, n10, p10, n11, p11, \
n12, p12, n13, p13, n14, p14, \
n15, p15, n16, p16, ...) \
enum{ \
n1 = 1, n2, n3, n4, n5, n6, n7, n8, n9, n10, \
n11, n12, n13, n14, n15, n16 \
}
// 生成case语句切片，模仿goto
// 由于标准c语言语法中goto后面只能加常量标签所以这里用switch-case模拟goto语句
#define MAKE_LABEL_SLICE(n1, p1, n2, p2, n3, p3, n4, p4, \
n5, p5, n6, p6, n7, p7, n8, p8, \
n9, p9, n10, p10, n11, p11, \
n12, p12, n13, p13, n14, p14, \
n15, p15, n16, p16, ...) \
case n1: p1; case n2: p2; case n3: p3; case n4: p4; \
case n5: p5; case n6: p6; case n7: p7; case n8: p8; \
case n9: p9; case n10: p10; case n11: p11; case n12: p12; \
case n13: p13; case n14: p14; case n15: p15; case n16: p16; \
default: break;
// 协程主体定义宏
#define COROUTINE_PROGN(cor, ...) \
MAKE_LABEL(__VA_ARGS__, N16, , N15, , N14, ,N13, \
, N12, , N11, , N10, , N9, , N8, , N7, \
, N6, , N5, , N4, , N3, , N2, , N1,); \
switch ((cor)->pc){ \
MAKE_LABEL_SLICE(__VA_ARGS__, N16, , N15, , N14, ,N13, \
, N12, , N11, , N10, , N9, , N8, , N7, \
, N6, , N5, , N4, , N3, , N2, , N1,); \
}
这里我只写了16个case，也就是说如果超过16个代码片段就会被抛弃，如果你的程序真的很复杂也可以自己再加，
不过16个应该能满足绝大多数情况了。
另一个问题是此方法可能要求编译器有一定优化能力，因为如果只写了几个片段剩下的case就是空的，
不过本人测试了一下，像clang和gcc对空case的优化特别好，哪怕不开编译优化也不会增加代码体积。
接下来我们写一个最简单的多协程计算数组所有元素的和，示范一下：
struct I32AddStructure{
int *array;
size_t len, idx;
};
typedef struct I32AddStructure I32AddStructure;
void add(Coroutine *cor){
int *sum = (int *)cor->res;
I32AddStructure *add = (I32AddStructure *)cor->args;
COROUTINE_PROGN(cor,
ADD_ONE_NUM /*给代码段命名，一般情况下可能无用，
如果你想COROUTINE_YIELD_SET_PC进行绝对跳转的时候特别有用*/,
{
if (add->idx == add->len)
COROUTINE_END(cor); // 已经到最后一个元素关闭协程
*sum += add->array[add->idx++];
COROUTINE_YIELD_NEXT(cor, 0); // 挂起，并且下次执行再执行此代码段
}
);
}
int main(){
Coroutine cor[2];
int array[100];
I32AddStructure add1, add2;
int sum = 0;
for (int i = 0; i < 100; ++i){
array[i] = i;
}
add1.array = array;
add1.len = 50;
add1.idx = 0;
add2.array = array + 50; add2.len = 50;
add2.idx = 0;
coroutineInit(&cor[0], &add1, &sum, add);
coroutineInit(&cor[1], &add2, &sum, add);
schedule(cor, 2);
printf("%d\n", sum);
return 0;
}
当然这并不是再单片机上运行的程序，只是简单的举个例子。核心用法就是使用COROUTINR_PROGN生成需要分割的代码段。
每个代码段用COROUTINE_YIELD_NEXT（相对跳转并挂起）或者COROURINE_YIELD_SET_PC（绝对跳转并挂起）主动的让出cpu
也就是说可以在一些耗时等待其他硬件操作完成时主动调用COROUTINE_YIELD让出cpu，或者在一段时间内完成多个作业也可以使用这个框架。
接下来再来一个复杂的例子（伪代码）：
// 传感器参数
typedef struct {
uint8_t sensor_pin;
float temperature;
float humidity;
uint32_t sample_count;
} SensorParams;
void sensorCoroutine(Coroutine *cor) {
SensorParams *params = (SensorParams*)cor->args;
static uint32_t last_sample_time = 0;
COROUTINE_PROGN(cor,
// 命名代码段：初始化传感器
INIT_SENSOR,
{
printf("初始化传感器引脚 %d\n", params->sensor_pin);
sensorInit(params->sensor_pin);
last_sample_time = getSystemTime();
COROUTINE_YIELD_NEXT(cor, 1); //挂起，下次运行时运行下一片段，也就是WAIT_SAMPLE_INTERVAL片段
}, // 别忘了这里的逗号
// 命名代码段：等待采样间隔
WAIT_SAMPLE_INTERVAL,
{
if (getSystemTime() - last_sample_time < 1000) { // 1秒间隔
COROUTINE_YIELD_NEXT(cor, 0); // 保持当前状态
}
COROUTINE_YIELD_NEXT(cor, 1); //挂起，下次运行时运行下一片段，也就是READ_SENSOR_DATA片段
}, // 别忘了这里的逗号
// 命名代码段：读取传感器数据
READ_SENSOR_DATA,
{
params->temperature = readTemperature(params->sensor_pin);
params->humidity = readHumidity(params->sensor_pin);
params->sample_count++;
last_sample_time = getSystemTime();
printf("第%lu样本: 温度=%.2fC, 湿度=%.2f%%\n",
params->sample_count, params->temperature, params->humidity);
COROUTINE_YIELD_NEXT(cor, -1); // 回到等待状态
// 或者使用COROUTINE_YIELD_SET_PC(cor, WAIT_SAMPLE_INTERVAL);
}
);
}
使用相对跳转还是使用绝对跳转要看情况，使用绝对跳转可以在以后维护添加代码时在一定程度上不受影响，相反的相对跳转会受影响。
相对跳转适合挂起后接着运行下一段代码片段。
技术优势
1. 极低的内存开销
每个协程仅需约20字节内存（还可以接着优化，比如pc和status可以都用uint8_t）
无需为每个任务分配独立堆栈
2. 高效的上下文切换
切换开销仅为几个寄存器操作
无系统调用开销
确定性执行时间
3. 避免复杂的同步机制
协程在明确位置主动让出CPU
无需互斥锁、信号量等同步原语
降低死锁风险
4. 高度可移植性
纯C实现，不依赖特定硬件特性
可在任何支持标准C的平台运行
与RTOS兼容，可作为补充方案
5. 灵活的调度策略
支持轮询、优先级等多种调度方式
可根据系统负载动态调整
关于拓展
值得注意的是我并没有写协程休眠的机制，其实也很好写，需要在Coroutine结构体中增加一个变量，
在CoroutineStatus增加COROUTINE_SLEEPING状态，并添加几个休眠宏函数，再修改runCoroutine函数就可以了：
enum CoroutineStatus{
COROUTINE_READY = 0,
COROUTINE_RUNNING = 1,
COROUTINE_SUSPENDED = 2,
COROUTINE_SLEEPING = 3, //增加睡眠状态
COROUTINE_FINISHED = 4
};
#define GET_TIME() clock(); //在单片机中可以用SysTick获取运行时间
int runCoroutine(Coroutine *cor) {
if (cor->status == COROUTINE_READY || cor->status == COROUTINE_SUSPENDED){
cor->status = COROUTINE_RUNNING;
cor->func(cor);
return 0;
} else if (cor->status == COROUTINE_SLEEPING){
//如果是睡眠状态检测是否到达唤醒时间
if (GET_TIME() >= cor->sleepEndTime){
cor->status = COROUTINE_SUSPENDED;
}
return 0;
}
return -1;
}
//睡眠并指定下一次唤醒跳转到哪里，绝对跳转
#define COROUTINE_SLEEP_SET_PC(cor, time, pc_val) \
do{ \
(cor)->pc = val; \
(cor)->sleepEndTime = GET_TIME() + time; \
(cor)->status = COROUTINE_SLEEPING; \
return ; \
}while(0)
//睡眠并指定下一次唤醒跳转到哪里，相对跳转
#define COROUTINE_SLEEP_NEXT(cor, time, delt) \
do{ \
(cor)->pc += delt; \
(cor)->sleepEndTime = GET_TIME() + time; \
(cor)->status = COROUTINE_SLEEPING; \
return ; \
}while(0)
不过可能很多人觉得这个和状态机很像，确实是这样，叫它封装的状态机也可以。最重要的是这种封装方式不仅简化代码，
而且也美观了一些不是吗？
结语
本文提出的基于协程的轻量级并发方案，为资源受限的嵌入式系统提供了一种简洁高效的并发编程范式。通过借鉴Lua语言的协程思想，
并巧妙运用C语言的宏定义和Duff's Device技术，我们成功地在单片机上实现了内存开销极低、切换效率极高的协程框架。
该方案的核心优势在于：
极简设计：每个协程仅需约20字节内存，无需独立堆栈
高效切换：纯用户态切换，无系统调用开销
代码优雅：通过宏定义实现了代码段命名，大幅提升了状态机代码的可读性和可维护性
高度可移植：纯C实现，不依赖特定硬件平台
与传统RTOS相比，本方案在满足大多数嵌入式并发需求的同时，避免了复杂的内存管理和同步机制，降低了系统复杂度和死锁风险。
特别是对于那些对内存和实时性要求极高的应用场景，这种轻量级协程框架展现出了独特的价值。
展望未来，该框架还可以进一步扩展，如增加优先级调度、协程间通信、动态创建销毁等功能。希望这个从Lua语言中汲取灵感的实现方案，能够为嵌入式开发者提供新的思路，在资源受限的环境中依然能够编写出清晰、高效的并发代码。
正如编程语言的设计哲学所示：简洁并不等于简单，优雅的解决方案往往来自于对问题本质的深刻理解。
浙公网安备 33010602011771号