引言
在嵌入式开发中，如何在资源受限的单片机上实现高效并发一直是个挑战。传统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语言中汲取灵感的实现方案，能够为嵌入式开发者提供新的思路，在资源受限的环境中依然能够编写出清晰、高效的并发代码。
正如编程语言的设计哲学所示：简洁并不等于简单，优雅的解决方案往往来自于对问题本质的深刻理解。
