【EventOS Nano】EventOS Nano框架分析
1.核心数据结构
时间触发型事件结构体
// eos定时器事件
typedef struct eos_event_timer {
eos_u32_t topic : 13; // 事件主题
eos_u32_t oneshoot : 1; // 是否单次触发
eos_u32_t unit : 2; // 时间单位，共支持4种时间单位
eos_u32_t period : 16; // 触发周期时间值
eos_u32_t timeout_ms; // 时间触发型事件超时时间(当前系统时间+触发周期时间)
} eos_event_timer_t;
// 可以理解为角色?
typedef struct eos_actor {
eos_u32_t priority : 5; // 优先级
eos_u32_t mode : 1; // 模式
eos_u32_t enabled : 1; // 使能位
eos_u32_t reserve : 1;
} eos_actor_t;
为了将占用内存控制到最小，将eos_tag定义为全局变量
typedef struct eos_tag
{
eos_u32_t magic;
eos_mcu_t *sub_table; // 事件订阅表
// eos的actor参量
eos_mcu_t actor_exist; // actor存在标志位
eos_mcu_t actor_enabled; // acotr使能标志位
eos_actor_t *actor[EOS_MAX_ACTORS]; // actor表
// eos 的堆空间变量
eos_heap_t heap;
// eos时间触发型事件
eos_event_timer_t etimer[EOS_MAX_TIME_EVENT]; // 时间触发型事件表
eos_u32_t time; // 系统时基（时间）
eos_u32_t timeout_min; // 超时事件最短的定时器
eos_u8_t timer_count; // 定时器事件数量
// eos框架运行标志
eos_u8_t enabled :1; // 是否使能
eos_u8_t running :1; // 运行状态
eos_u8_t init_end :1;
}eos_t;
// 事件全局变量
static eos_t eos;
2.系统初始化
在Stm32F3的MCU平台上，eos的时基，是由Systick定时器中断提供的(stm32f10x_it.c)，在刚开始移植到到Linux平台下做仿真调试的时候，发现eos_run()后，eos上并没有运行，发现是因为移植到Linux环境后就没有Systick硬定时器，所以创建了一个软件定时器，在软件定时器中执行eos_tick()。
// timer-----------------------------------------
//定时器触发函数
void SysTickHandler(int signo){
eos_tick(); // 时钟中断一次，执行一次,eos.time+1
}
void init_sigaction(){
struct sigaction act;
act.sa_handler = SysTickHandler;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaction(SIGPROF,&act,NULL); //设置信号 SIGPROF 的处理函数为 SysTickHandler
}
void init_time() {
struct itimerval value;
value.it_value.tv_sec=1; //定时器启动后，每隔1秒将执行相应的函数
value.it_value.tv_usec=0;
value.it_interval=value.it_value;
setitimer(ITIMER_PROF,&value,NULL); //初始化 timer，到期发送 SIGPROF 信号
}
* main function ------------------------------------------------------------ */
int main(void)
{
init_sigaction();
init_time();
eos_init(); // EventOS初始化
#if (EOS_USE_PUB_SUB != 0)
eos_sub_init(eos_sub_table, Event_Max); // 订阅表初始化
#endif
#if (EOS_USE_SM_MODE != 0)
eos_sm_led_init(); // LED状态机初始化
#endif
eos_reactor_led_init();
eos_run(); // EventOS启动
return 0;
}
eos框架初始化
void eos_init(void)
{
eos_clear(); // 将timer_count清为0
eos.enabled = EOS_True; // eos框架使能
eos.running = EOS_False; // eos没有正在运行
eos.actor_exist = 0; // 存在的状态机
eos.actor_enabled = 0; // 状态机不使能
eos.sub_table = EOS_NULL; // 订阅表为空
eos_heap_init(&eos.heap);
eos.init_end = 1;
eos.time = 0; // 时基初始化
}
// 初始化发布-订阅表
void eos_sub_init(eos_mcu_t *flag_sub, eos_topic_t topic_max)
{
eos.sub_table = flag_sub;
for (int i = 0; i < topic_max; i ++) {
eos.sub_table[i] = 0;
}
}
3.事件发布
eos中有两种事件类型，分别为时间触发型事件和携带数据型事件，时间触发型事件又分为周期事件和非周期事件。
3.1 时间触发型事件发布
发布周期触发型事件
void eos_event_pub_period(eos_topic_t topic, eos_u32_t time_ms_period)
{
// topic:事件主题 time_ms_period:触发周期 EOS_False：是否只触发一次
eos_event_pub_time(topic, time_ms_period, EOS_False);
}
发布延时时间事件(非周期时间型事件)
void eos_event_pub_delay(eos_topic_t topic, eos_u32_t time_ms)
{
// topic:事件主题 time_ms:延时触发时间 EOS_True：只触发一次
eos_event_pub_time(topic, time_ms, EOS_True);
}
两种时间型事件都是调用的eos_event_pub_time函数，原理是计算发布的时间型事件etimer(eos_event_timer_t类型)各项成员值，赋给eos.etimer[i]，同时时间型事件数自增（eos.timer_count++）：
void eos_event_pub_time(eos_topic_t topic, eos_u32_t time_ms, eos_bool_t oneshoot)
{
EOS_ASSERT(time_ms != 0);
EOS_ASSERT(time_ms <= timer_threshold[EosTimerUnit_Minute]);
EOS_ASSERT(eos.timer_count < EOS_MAX_TIME_EVENT);
// 检查重复，不允许重复发送。
for (eos_u32_t i = 0; i < eos.timer_count; i ++) {
EOS_ASSERT(topic != eos.etimer[i].topic);
}
eos_u32_t system_ms = eos.time;
eos_u8_t unit = EosTimerUnit_Ms;
eos_u16_t period;
for (eos_u8_t i = 0; i < EosTimerUnit_Max; i ++) {
if (time_ms > timer_threshold[i])
continue;
unit = i;
if (i == EosTimerUnit_Ms) {
period = time_ms;
break;
}
period = (time_ms + (timer_unit[i] >> 1)) / timer_unit[i];
break;
}
eos_u32_t timeout = (system_ms + time_ms);
// 将计算好的值，赋给eos.etimer[eos.timer_count ++]
eos.etimer[eos.timer_count ++] = (eos_event_timer_t) {
topic, oneshoot, unit, period, timeout
};
// 更新系统当前最小的超时时间值
if (eos.timeout_min > timeout) {
eos.timeout_min = timeout;
}
}
如果想取消时间型事件的发布可以调用：
void eos_event_time_cancel(eos_topic_t topic);
实现原理就是遍历eos.etimer[i],将传入topic对应的删除，并同步eos.timer_count -=1,重新计算所有事件计时器中最小的事件赋给eos.timeout_min。
3.2 携带数据型事件发布
只发布事件主题（topic）
void eos_event_pub_topic(eos_topic_t topic)
{
// 入参只有topic
eos_s8_t ret = eos_event_pub_ret(topic, EOS_NULL, 0);
EOS_ASSERT(ret >= 0);
(void)ret;
}
发布携带数据的事件(topic+*data)
void eos_event_pub(eos_topic_t topic, void *data, eos_u32_t size)
{
eos_s8_t ret = eos_event_pub_ret(topic, data, size);
EOS_ASSERT(ret >= 0);
(void)ret;
}
两种方法调用的都是eos_event_pub_ret：
eos_s8_t eos_event_pub_ret(eos_topic_t topic, void *data, eos_u32_t size)
{
if (eos.init_end == 0) {
return (eos_s8_t)EosRunErr_NotInitEnd;
}
#if (EOS_USE_PUB_SUB != 0)
if (eos.sub_table == EOS_NULL) {
return (eos_s8_t)EosRunErr_SubTableNull;
}
#endif
// 保证框架已经运行
if (eos.enabled == 0) {
return (eos_s8_t)EosRun_NotEnabled;
}
if (eos.actor_exist == 0) {
return (eos_s8_t)EosRun_NoActor;
}
// 没有状态机使能，返回
if (eos.actor_enabled == 0) {
return (eos_s8_t)EosRun_NotEnabled;
}
// 没有输入topic事件的状态机订阅，返回
#if (EOS_USE_PUB_SUB != 0)
if (eos.sub_table[topic] == 0) {
return (eos_s8_t)EosRun_NoActorSub;
}
#endif
eos_port_critical_enter();
// 申请事件空间
eos_event_inner_t *e = eos_heap_malloc(&eos.heap, (size + sizeof(eos_event_inner_t)));
if (e == (eos_event_inner_t *)0) {
eos_port_critical_exit();
return (eos_s8_t)EosRunErr_MallocFail;
}
e->topic = topic;
#if (EOS_USE_PUB_SUB != 0)
e->sub = eos.sub_table[e->topic];
#else
e->sub = eos.actor_exist;
#endif
eos.heap.sub_general |= e->sub;
eos_u8_t *e_data = (eos_u8_t *)e + sizeof(eos_event_inner_t);
for (eos_u32_t i = 0; i < size; i ++) {
e_data[i] = ((eos_u8_t *)data)[i];
}
eos_port_critical_exit();
return (eos_s8_t)EosRun_OK;
}
3.3 eos的运行和事件的处理
eos_run循环调用eos_once()
void eos_run(void)
{
eos_hook_start();
EOS_ASSERT(eos.enabled == EOS_True);
#if (EOS_USE_PUB_SUB != 0)
EOS_ASSERT(eos.sub_table != 0);
#endif
#if (EOS_USE_EVENT_DATA != 0 && EOS_USE_HEAP != 0)
EOS_ASSERT(eos.heap.size != 0);
#endif
eos.running = EOS_True;
// eos一直处于使能状态
while (eos.enabled) {
// 实际一直调用eos_once()
eos_s8_t ret = eos_once();
EOS_ASSERT(ret >= 0);
if (ret == EosRun_NotEnabled) {
break;
}
if (ret == EosRun_NoActor || ret == EosRun_NoEvent) {
#if (EOS_USE_MAGIC != 0)
EOS_ASSERT(eos.heap.magic == EOS_MAGIC_NUMBER);
EOS_ASSERT(eos.magic == EOS_MAGIC_NUMBER);
for (eos_u8_t i = 0; i < EOS_MAX_ACTORS; i ++) {
if ((eos.actor_exist & (1 << i)) != 0) {
EOS_ASSERT(eos.actor[i]->magic == EOS_MAGIC_NUMBER);
}
}
#endif
eos_hook_idle();
}
}
// 如果EosRun_NotEnabled置位
while (1) {
eos_hook_idle();
}
}
eos_once分别执行SM模式逻辑和reactor模式逻辑
eos_s8_t eos_once(void)
{
if (eos.init_end == 0) {
return (eos_s8_t)EosRunErr_NotInitEnd;
}
#if (EOS_USE_PUB_SUB != 0)
if (eos.sub_table == EOS_NULL) {
return (eos_s8_t)EosRunErr_SubTableNull;
}
#endif
if (eos.enabled == EOS_False) {
eos_clear();
return (eos_s8_t)EosRun_NotEnabled;
}
// 检查是否有状态机的注册
if (eos.actor_exist == 0 || eos.actor_enabled == 0) {
return (eos_s8_t)EosRun_NoActor;
}
#if (EOS_USE_TIME_EVENT != 0)
/* 处理定时器事件，如果有某个定时器时间到达，则发布定时器事件的topic，并寻找
当前定时器数组中最近到达的超时时间，赋给eos.timeout_min*/
eos_evttimer();
#endif
if (eos.heap.empty == EOS_True) {
return (eos_s8_t)EosRun_NoEvent;
}
// 寻找到优先级最高，且有事件需要处理的 Actor
eos_actor_t *actor = eos.actor[0];
eos_u8_t priority = EOS_MAX_ACTORS;
for (eos_s8_t i = (eos_s8_t)(EOS_MAX_ACTORS - 1); i >= 0; i --) {
// 检测是否有事件需要处理
if ((eos.actor_exist & (1 << i)) == 0)
continue;
if ((eos.heap.sub_general & (1 << i)) == 0)
continue;
actor = eos.actor[i];
priority = i;
break;
}
// 如果没有找到，返回
if (priority == EOS_MAX_ACTORS) {
return (eos_s8_t)EosRun_NoActorSub;
}
// 寻找当前Actor的最老的事件
eos_port_critical_enter();
eos_event_inner_t * e = eos_heap_get_block(&eos.heap, priority);
EOS_ASSERT(e != EOS_NULL);
eos_port_critical_exit();
eos_event_t event;
event.topic = e->topic;
event.data = (void *)((eos_pointer_t)e + sizeof(eos_event_inner_t));
eos_block_t *block = (eos_block_t *)((eos_pointer_t)e - sizeof(eos_block_t));
event.size = block->size - block->offset - sizeof(eos_event_inner_t);
// 对事件进行执行
#if (EOS_USE_PUB_SUB != 0)
if ((eos.sub_table[e->topic] & (1 << actor->priority)) != 0)
#endif
{
#if (EOS_USE_SM_MODE != 0)
if (actor->mode == EOS_Mode_StateMachine) {
// SM模式的切换逻辑，执行状态的转换
eos_sm_t *sm = (eos_sm_t *)actor;
eos_sm_dispath(sm, &event);
}
else
#endif
{
// reactor模式的处理逻辑，触发事件
eos_reactor_t *reactor = (eos_reactor_t *)actor;
reactor->event_handler(reactor, &event);
}
}
#if (EOS_USE_PUB_SUB != 0)
else {
return (eos_s8_t)EosRunErr_ActorNotSub;
}
#endif
#if (EOS_USE_EVENT_DATA != 0)
// 销毁过期事件与其携带的参数
eos_port_critical_enter();
eos_heap_gc(&eos.heap, e);
eos_port_critical_exit();
#endif
return (eos_s8_t)EosRun_OK;
}
3.4 eos退出
执行eos_stop，失能eos，并hook_stop执行退出，释放资源
void eos_stop(void)
{
eos.enabled = EOS_False;
eos_hook_stop();
}
