From 2f4c00fd3dda84e2a53c4886735de6bc1c29354e Mon Sep 17 00:00:00 2001 From: zhangzhaopeng Date: Thu, 8 Jan 2026 17:30:22 +0800 Subject: [PATCH] =?UTF-8?q?1.=E4=BF=AE=E5=A4=8D=E5=88=A0=E9=99=A4=E6=89=80?= =?UTF-8?q?=E6=9C=89=E6=B6=88=E6=81=AF=E6=8E=A5=E5=8F=A3=E7=9A=84bug=202.?= =?UTF-8?q?=E5=AE=8C=E5=96=84=E5=88=9D=E5=A7=8B=E5=8C=96=E6=97=B6=E7=9A=84?= =?UTF-8?q?=E9=94=99=E8=AF=AF=E5=A4=84=E7=90=86=203.=E6=B7=BB=E5=8A=A0free?= =?UTF-8?q?RTOS=E7=9A=84=E6=94=AF=E6=8C=81=204.=E6=B7=BB=E5=8A=A0rt-thread?= =?UTF-8?q?=E7=9A=84=E6=94=AF=E6=8C=81=205.=E6=B6=88=E9=99=A4=E4=B8=80?= =?UTF-8?q?=E4=BA=9B=E7=BC=96=E8=AF=91=E8=AD=A6=E5=91=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- mw/has_task_msg_manager/README | 5 +- mw/has_task_msg_manager/has_task_msg.h | 22 ++-- .../has_task_msg_mamanger.c | 99 +++++++++++------ .../has_task_msg_os_port.c | 104 ++++++++++++++++-- .../has_task_msg_os_port.h | 104 ++++++++---------- 5 files changed, 221 insertions(+), 113 deletions(-) diff --git a/mw/has_task_msg_manager/README b/mw/has_task_msg_manager/README index f5f0e86..ce39ea4 100644 --- a/mw/has_task_msg_manager/README +++ b/mw/has_task_msg_manager/README @@ -1,6 +1,5 @@ 这个软件用于代码模块之间的消息传递，采用发布-订阅的方式传递消息 使用方法： -1. 在 has_task_msg_os_port.h 选择操作系统，更改宏MSG_OPT_OS。或选择自定义自己实现接口。 -2. 在 has_task_msg.h 中添加自己负责的软件模块id号（has_module_ID_e），并且完成订阅表 SUBSCIBE_INFO - 填表，要把模块的id、模块要订阅的id等信息填好。 +1. 在 has_task_msg_os_port.h 选择操作系统，更改宏MSG_OPT_OS。或选择自定义自己实现接口，如果自己定义需要自己实现has_task_msg_os_port.c的相应接口。 +2. 在 has_task_msg.h 中添加自己负责的软件模块id号（has_module_ID_e），并且完成订阅表 SUBSCIBE_INFO ，要把模块的id、模块要订阅的id等信息填好。 3. 代码中使用：初始化、发布、订阅和消息回调即可。请参考示例 msg_example.c \ No newline at end of file diff --git a/mw/has_task_msg_manager/has_task_msg.h b/mw/has_task_msg_manager/has_task_msg.h index 428c8de..d16fbc4 100644 --- a/mw/has_task_msg_manager/has_task_msg.h +++ b/mw/has_task_msg_manager/has_task_msg.h @@ -15,21 +15,25 @@ typedef enum { MODULE_MAX } has_module_ID_e; +#define CHECK_SUBSCIBE_INFO // 如果打开，代码初始化时会检查订阅表是否写错，开发时应该打开 /* 格式：模块 订阅数量 订阅模块 */ #define SUBSCIBE_INFO \ { \ {GUI, 4, {ACM, SENSOR, WIFI, VOICE}}, \ - {SENSOR, 1, {GUI}}, \ + {SENSOR, 2, {GUI, WIFI}}, \ + {WIFI, 0}, \ } -// #define SUBSCIBE_INFO \ -// { \ -// {GUI, 4, {ACM, WIFI, VOICE, SENSOR}}, \ -// {SENSOR, 5, {ACM, GUI, WIFI, VOICE, SENSOR}}, \ -// {ACM, 4, {GUI, WIFI, VOICE, SENSOR}}, \ -// {WIFI, 4, {ACM, GUI, VOICE, SENSOR}}, \ -// {VOICE, 4, {ACM, WIFI, GUI, SENSOR}}, \ -// } +/* +#define SUBSCIBE_INFO \ +{ \ + {GUI, 4, {ACM, WIFI, VOICE, SENSOR}}, \ + {SENSOR, 5, {ACM, GUI, WIFI, VOICE, SENSOR}}, \ + {ACM, 4, {GUI, WIFI, VOICE, SENSOR}}, \ + {WIFI, 4, {ACM, GUI, VOICE, SENSOR}}, \ + {VOICE, 4, {ACM, WIFI, GUI, SENSOR}}, \ +} +*/ /** * @brief 消息处理回调类型 diff --git a/mw/has_task_msg_manager/has_task_msg_mamanger.c b/mw/has_task_msg_manager/has_task_msg_mamanger.c index b853f10..5dfa60c 100644 --- a/mw/has_task_msg_manager/has_task_msg_mamanger.c +++ b/mw/has_task_msg_manager/has_task_msg_mamanger.c @@ -26,7 +26,8 @@ #define msg_debug(fmt, ...) #endif -#define MSG_ASSERT {while(1);} +#define MSG_ASSERT \ +{msg_printf("!!!!!wrong config!!!!! file:%s line:%d\n", __FILE__, __LINE__);while(1);} #pragma pack(1) /* 消息数据 */ @@ -71,7 +72,7 @@ typedef struct { struct list_head msg_list; // 消息链表 } has_static_sub_list_t; static has_static_sub_list_t g_sub_list[] = SUBSCIBE_INFO; -static unsigned char g_sub_list_index[MODULE_MAX]; // 订阅表id索引 +static unsigned char g_sub_list_index[MODULE_MAX]; // 订阅表id索引，同时表示模块是否可用 /* 检查ID是否合法，id:检查的ID，ret:不合法时return的值 */ @@ -87,17 +88,19 @@ if (g_sub_list_index[(id)] == MODULE_MAX) { \ return (ret);} /** - * @brief 初始化消息表 + * @brief 初始化消息表,必须在所有接口调用之前调用init * * @return 0:成功 -1：失败 */ int has_msg_init() { int j; + has_static_pub_list_t *pub_list; /* 设置无效，标记是否初始化 */ memset(g_sub_list_index, MODULE_MAX, sizeof(g_sub_list_index)); memset(g_pub_list, 0, sizeof(g_pub_list)); - for (int i = 0; i < (sizeof(g_sub_list) / sizeof(g_sub_list[0])); i++) { + for (unsigned int i = 0; i < (sizeof(g_sub_list) / sizeof(g_sub_list[0])); i++) { +#ifdef CHECK_SUBSCIBE_INFO /* 检查各模块ID是否配置正确 */ if ((g_sub_list[i].module_id >= MODULE_MAX) || (g_sub_list[i].module_id == INVALID_ID)) { msg_printf("module_id:%d is invalid, please check the macro:SUBSCIBE_INFO row:%d\n" @@ -107,8 +110,8 @@ int has_msg_init() } /* 已经被初始化了，配置错误 */ if (g_sub_list_index[g_sub_list[i].module_id] != MODULE_MAX) { - msg_printf("[msg]warning: msg two same module id:%d\n", g_sub_list[i].module_id); - continue; + msg_printf("[msg warning]: msg two same module id:%d\n", g_sub_list[i].module_id); + MSG_ASSERT; // 配置都能写错，必须进断言 } /* 检查订阅表ID是否配置正确 */ @@ -131,24 +134,38 @@ int has_msg_init() MSG_ASSERT; // 配置都能写错，必须进断言 return -1; } - g_sub_list_index[g_sub_list[i].module_id] = i; // 索引表赋值 +#endif + /* 通知发布者，需要发给此模块 */ for (int k = 0; k < g_sub_list[i].sub_module_cnt; k++) { // 寻找发布者 - if (g_pub_list[g_sub_list[i].sub_module[k]].pub_num == 0) { - msg_mutex_init(&g_pub_list[g_sub_list[i].sub_module[k]].buffer_mutex); + pub_list = &g_pub_list[g_sub_list[i].sub_module[k]]; +#ifdef MSG_OPT_MUTEX_SEM + if (pub_list->pub_num == 0) { + if (msg_mutex_init(&pub_list->buffer_mutex) != 0) { + msg_printf("[msg warning]:pub mutex init err! pub id:%d\n" + , g_sub_list[i].sub_module[k]); + /* 使用计数没有加锁，释放msg的内存时有可能出错 */ + continue; + } } +#endif /* 注册所找到发布者的发布表 */ - g_pub_list[g_sub_list[i].sub_module[k]]. - pub_module[g_pub_list[g_sub_list[i].sub_module[k]].pub_num] - = g_sub_list[i].module_id; - g_pub_list[g_sub_list[i].sub_module[k]].pub_num ++; + pub_list->pub_module[pub_list->pub_num] = g_sub_list[i].module_id; + pub_list->pub_num ++; } - msg_mutex_init(&g_sub_list[i].msg_mutex); // 初始化该模块互斥量 INIT_LIST_HEAD(&g_sub_list[i].msg_list); // 初始化订阅链表 #ifdef MSG_OPT_MUTEX_SEM - msg_sem_init(&g_sub_list[i].sem); // 初始化同步量 + if (msg_sem_init(&g_sub_list[i].sem) != 0) { // 初始化该模块同步量 + msg_printf("[msg warning]:sub sem init err! sub id:%d\n", i); + continue; + } + if (msg_mutex_init(&g_sub_list[i].msg_mutex) != 0) { // 初始化该模块互斥量 + msg_printf("[msg warning]:sub mutex init err! sub id:%d\n", i); + continue; + } #endif + g_sub_list_index[g_sub_list[i].module_id] = i; // 索引表赋值,相当于enable } #ifdef MSG_OPT_DEBUG // msg_printf("show index:\n"); @@ -184,23 +201,26 @@ int has_msg_init() */ int has_msg_init_module(has_module_ID_e module_id) { - int i, j; + unsigned int i; + int j; + has_static_pub_list_t *pub_list; /* 检查ID */ +#ifdef CHECK_SUBSCIBE_INFO if ((module_id >= MODULE_MAX) || (module_id == INVALID_ID)) { msg_printf("%s:module_id:%d is invalid\n", __func__, module_id); MSG_ASSERT; // 配置都能写错，必须进断言 return -1; } +#endif /* 初始化该模块订阅表 */ for (i = 0; i < (sizeof(g_sub_list) / sizeof(g_sub_list[0])); i++) { if (g_sub_list[i].module_id == (unsigned char)module_id) { - // g_sub_list_index[module_id] = MODULE_MAX; - // g_pub_list[module_id].pub_num = 0; +#ifdef CHECK_SUBSCIBE_INFO /* 已经被初始化了，配置错误 */ if (g_sub_list_index[module_id] != MODULE_MAX) { - msg_printf("[msg]warning: msg two same module id:%d\n", module_id); - break; + msg_printf("[msg warning]: msg two same module id:%d\n", module_id); + MSG_ASSERT; // 配置都能写错，必须进断言 } /* 检查订阅表ID是否配置正确 */ for (j = 0; j < (MODULE_MAX - 1); j++) { @@ -223,24 +243,38 @@ int has_msg_init_module(has_module_ID_e module_id) MSG_ASSERT; // 配置都能写错，必须进断言 return -1; } - g_sub_list_index[module_id] = i; // 索引表赋值 +#endif /* 通知发布者，需要发给此模块 */ for (int k = 0; k < g_sub_list[i].sub_module_cnt; k++) { // 寻找发布者 - if (g_pub_list[g_sub_list[i].sub_module[k]].pub_num == 0) { - msg_mutex_init(&g_pub_list[g_sub_list[i].sub_module[k]].buffer_mutex); + pub_list = &g_pub_list[g_sub_list[i].sub_module[k]]; +#ifdef MSG_OPT_MUTEX_SEM + if (pub_list->pub_num == 0) { + if (msg_mutex_init(&pub_list->buffer_mutex) != 0) { + msg_printf("[msg warning]:pub mutex init err! pub id:%d\n" + , g_sub_list[i].sub_module[k]); + /* 使用计数没有加锁，释放msg的内存时有可能出错 */ + continue; + } } +#endif /* 注册所找到发布者的发布表 */ - g_pub_list[g_sub_list[i].sub_module[k]]. - pub_module[g_pub_list[g_sub_list[i].sub_module[k]].pub_num] = module_id; - g_pub_list[g_sub_list[i].sub_module[k]].pub_num ++; + pub_list->pub_module[pub_list->pub_num] = module_id; + pub_list->pub_num ++; } - msg_mutex_init(&g_sub_list[i].msg_mutex); // 初始化该模块互斥量 INIT_LIST_HEAD(&g_sub_list[i].msg_list); // 初始化订阅链表 #ifdef MSG_OPT_MUTEX_SEM - msg_sem_init(&g_sub_list[i].sem); // 初始化同步量 + if (msg_sem_init(&g_sub_list[i].sem) != 0) { // 初始化该模块同步量 + msg_printf("[msg warning]:sub sem init err! sub id:%d\n", i); + break; + } + if (msg_mutex_init(&g_sub_list[i].msg_mutex) != 0) { // 初始化该模块互斥量 + msg_printf("[msg warning]:sub mutex init err! sub id:%d\n", i); + break; + } #endif + g_sub_list_index[module_id] = i; // 索引表赋值,相当于enable break; } } @@ -264,6 +298,7 @@ int has_msg_os_init() { has_msg_init_module(i); } + return 0; } /* TODO:更合理的方式是每个消息一个互斥量，但是可能会导致每个消息malloc和free的时候频繁init和deinit */ @@ -309,9 +344,9 @@ int has_msg_publish(has_module_ID_e module_id, void *buffer, unsigned int length has_static_pub_list_t *pub_list; has_static_sub_list_t *sub_list; - MSG_CHECK_MODULE_ID(module_id, -1); + MSG_CHECK_ID_AND_INDEX(module_id, -1); + // MSG_CHECK_MODULE_ID 如果使用这个宏检查，未初始化的模块也可以发布 pub_list = &g_pub_list[module_id]; - // MSG_CHECK_ID_AND_INDEX TODO:如果使用这个，未初始化的模块也不能发布 if (pub_list->pub_num == 0) { // msg_printf("no one subscribe you:%d\n", module_id); return 0; @@ -342,7 +377,7 @@ int has_msg_publish(has_module_ID_e module_id, void *buffer, unsigned int length list_del(&node[i].list); // 添加失败，删除链表 msg_mutex_unlock(&sub_list->msg_mutex); msg_check_and_free_message(&node[i]); - msg_printf("warning:Failed to add msg on module:%d !!!\n" + msg_printf("[msg warning]:Failed to add msg on module:%d !!!\n" , sub_list->module_id); continue; } @@ -660,7 +695,7 @@ int has_msg_delete_all_message(has_module_ID_e module_id) list_add_tail(&node->list, &free_list); // 加入临时链表 } } - INIT_LIST_HEAD(&sub_list->msg_list); + // INIT_LIST_HEAD(&sub_list->msg_list); msg_mutex_unlock(&sub_list->msg_mutex); /* 释放内存 */ list_for_each_entry_safe(node, temp, &free_list, list) { diff --git a/mw/has_task_msg_manager/has_task_msg_os_port.c b/mw/has_task_msg_manager/has_task_msg_os_port.c index 6a25b6a..7feb9d6 100644 --- a/mw/has_task_msg_manager/has_task_msg_os_port.c +++ b/mw/has_task_msg_manager/has_task_msg_os_port.c @@ -9,7 +9,41 @@ #include #include "has_task_msg_os_port.h" +// TODO: 信号量限制最大数量 + #ifdef MSG_OPT_MUTEX_SEM +/** + * @brief 互斥量初始化 + * + * @param mutex:互斥量 + * @return 0:成功 -1：失败 + */ +int msg_mutex_init(msg_mutex_t *mutex) +{ +#if (MSG_OPT_OS == MSG_OPT_OS_LINUX) + if (pthread_mutex_init(mutex, NULL) != 0) { + return -1; + } + return 0; +#elif (MSG_OPT_OS == MSG_OPT_OS_freeRTOS) + *mutex = xSemaphoreCreateMutex(); + if (*mutex == NULL) { + msg_printf("create mutex err!!\n\n"); + return -1; + } + return 0; +#elif (MSG_OPT_OS == MSG_OPT_OS_RT_THREAD) + *mutex = rt_mutex_create("has_msg", RT_IPC_FLAG_FIFO); + if (*mutex == RT_NULL) { + msg_printf("create mutex err!!\n\n"); + return -1; + } + return 0; +#elif (MSG_OPT_OS == MSG_OPT_OS_USER_DEFINED) + /* to be done */ +#endif +} + /** * @brief 信号量初始化 * @@ -21,16 +55,28 @@ int msg_sem_init(msg_sem_t *sem) #if (MSG_OPT_OS == MSG_OPT_OS_LINUX) sem->poll_fd.fd = eventfd(0, EFD_SEMAPHORE | EFD_NONBLOCK); if (sem->poll_fd.fd == -1) { - printf("create eventfd error!\n"); + msg_printf("create eventfd error!\n"); return -1; } sem->poll_fd.events = POLLIN; // 监控可读事件 sem->poll_fd.revents = 0; return 0; #elif (MSG_OPT_OS == MSG_OPT_OS_freeRTOS) + *sem = xSemaphoreCreateCounting(UINT_MAX, 0) + if (*sem == NULL) { + msg_printf("create counting sem error!\n"); + return -1; + } + return 0; #elif (MSG_OPT_OS == MSG_OPT_OS_RT_THREAD) -#elif (MSG_OPT_OS == MSG_OPT_OS_NONE_OR_OSAL) + *sem = rt_sem_create("has_sem", 0, RT_IPC_FLAG_FIFO) + if (*sem == RT_NULL) { + msg_printf("create counting sem error!\n"); + return -1; + } + return 0; #elif (MSG_OPT_OS == MSG_OPT_OS_USER_DEFINED) + /* to be done */ #endif } @@ -45,14 +91,24 @@ int msg_sem_notify(msg_sem_t *sem) #if (MSG_OPT_OS == MSG_OPT_OS_LINUX) uint64_t val = 1; if (write(sem->poll_fd.fd, &val, sizeof(val)) != sizeof(val)) { - printf("notify thread err!\n"); + msg_printf("notify thread err!\n"); return -1; } return 0; #elif (MSG_OPT_OS == MSG_OPT_OS_freeRTOS) + if (xSemaphoreGive(*sem) != pdTRUE) { + msg_printf("notify thread err!\n"); + return -1; + } + return 0; #elif (MSG_OPT_OS == MSG_OPT_OS_RT_THREAD) -#elif (MSG_OPT_OS == MSG_OPT_OS_NONE_OR_OSAL) + if (rt_sem_release(*sem) != RT_EOK) { + msg_printf("notify thread err!\n"); + return -1; + } + return 0; #elif (MSG_OPT_OS == MSG_OPT_OS_USER_DEFINED) + /* to be done */ #endif } @@ -75,27 +131,57 @@ enum MSG_WAIT_RET msg_sem_wait(msg_sem_t *sem, int ms_timeout) perror("poll fail\n"); return WAIT_FAIL; } else if (ret == 0) { - // printf("poll timeout\n"); + // msg_printf("poll timeout\n"); return WAIT_TIMEOUT; } if (sem->poll_fd.revents & POLLIN) { if (read(sem->poll_fd.fd, &val, sizeof(val)) == sizeof(val)) { // 清零 - // printf("read %ld\n", val); + // msg_printf("read %ld\n", val); return WAIT_MSG_COME; } else { - printf("read error\n"); + msg_printf("read error\n"); } } // 检查错误事件 - printf("something err happened,revents:%x\n", sem->poll_fd.revents); + msg_printf("something err happened,revents:%x\n", sem->poll_fd.revents); return WAIT_FAIL; #elif (MSG_OPT_OS == MSG_OPT_OS_freeRTOS) + const TickType_t xTicksToWait; + if (ms_timeout < 0) { + xTicksToWait = portMAX_DELAY; + } else { + xTicksToWait = pdMS_TO_TICKS(ms_timeout); + } + + if (xSemaphoreTake(*sem, xTicksToWait) != pdTRUE) { + msg_printf("sem take fail\n"); + return WAIT_FAIL; + } + return WAIT_MSG_COME; #elif (MSG_OPT_OS == MSG_OPT_OS_RT_THREAD) -#elif (MSG_OPT_OS == MSG_OPT_OS_NONE_OR_OSAL) + rt_err_t ret; + rt_int32_t time; + if (ms_timeout < 0) { + time = RT_WAITING_FOREVER; + } else { + time = rt_tick_from_millisecond(ms_timeout); + } + + ret = rt_sem_take(*sem, time); + + if (ret == RT_EOK) { + return WAIT_MSG_COME; + } else if (ret == (-RT_ETIMEOUT)) { + return WAIT_TIMEOUT; + } else { + msg_printf("sem take fail\n"); + return WAIT_FAIL; + } #elif (MSG_OPT_OS == MSG_OPT_OS_USER_DEFINED) + /* to be done */ #endif } diff --git a/mw/has_task_msg_manager/has_task_msg_os_port.h b/mw/has_task_msg_manager/has_task_msg_os_port.h index c369495..4d3606e 100644 --- a/mw/has_task_msg_manager/has_task_msg_os_port.h +++ b/mw/has_task_msg_manager/has_task_msg_os_port.h @@ -36,7 +36,6 @@ enum MSG_WAIT_RET{ #include #include #define msg_mutex_t pthread_mutex_t -#define msg_mutex_init(m) pthread_mutex_init(m, NULL) #define msg_mutex_lock(m) pthread_mutex_lock(m) #define msg_mutex_unlock(m) pthread_mutex_unlock(m) typedef struct { @@ -44,12 +43,12 @@ typedef struct { } sync_t; #define msg_sem_t sync_t +int msg_mutex_init(msg_mutex_t *mutex); int msg_sem_init(msg_sem_t *sem); int msg_sem_notify(msg_sem_t *sem); enum MSG_WAIT_RET msg_sem_wait(msg_sem_t *sem, int ms_timeout); #else #define msg_mutex_t -#define msg_mutex_init(m) #define msg_mutex_lock(m) #define msg_mutex_unlock(m) #endif @@ -62,85 +61,74 @@ enum MSG_WAIT_RET msg_sem_wait(msg_sem_t *sem, int ms_timeout); #elif (MSG_OPT_OS == MSG_OPT_OS_freeRTOS) #include #include +#include #include "FreeRTOS.h" #include "semphr.h" -#ifdef MSG_OPT_MUTEX_SEM -#define msg_mutex_t SemaphoreHandle_t -static inline void msg_mutex_init(void *mutex) { - *mutex = xSemaphoreCreateMutex(); - if (*mutex == NULL) { - printf("create mutex err!!\n\n"); - } -} - -static inline void msg_mutex_lock(void *mutex) { - if (xSemaphoreTake(*mutex, portMAX_DELAY) != pdTRUE) { - printf("lock mutex err!!\n\n"); - } -} - -static inline void msg_mutex_unlock(void *mutex) { - xSemaphoreGive(*mutex); -} - -#define msg_sem_t int - -int msg_sem_init(msg_sem_t *sem); -int msg_sem_notify(msg_sem_t *sem); -enum MSG_WAIT_RET msg_sem_wait(msg_sem_t *sem, int ms_timeout); - -#else -#define msg_mutex_t -#define msg_mutex_init(m) -#define msg_mutex_lock(m) -#define msg_mutex_unlock(m) -#endif #define msg_malloc pvPortMalloc #define msg_free vPortFree #define msg_printf printf -/* ----------------------- for RT-thread ----------------------- */ -#elif (MSG_OPT_OS == MSG_OPT_OS_RT_THREAD) -#include -#include -#include #ifdef MSG_OPT_MUTEX_SEM -#define msg_mutex_t rt_mutex_t -static inline void msg_mutex_init(void *mutex) { - *mutex = rt_mutex_create("has_msg", RT_IPC_FLAG_FIFO); - if (*mutex == RT_NULL) { - printf("create mutex err!!\n\n"); +#define msg_mutex_t SemaphoreHandle_t + +static inline void msg_mutex_lock(msg_mutex_t *mutex) { + if (xSemaphoreTake(*mutex, portMAX_DELAY) != pdTRUE) { + msg_printf("lock mutex err!!\n\n"); } } -static inline void msg_mutex_lock(void *mutex) { - if (rt_mutex_take(*mutex, RT_WAITING_FOREVER) != RT_EOK) { - printf("lock mutex err!!\n\n"); - } +static inline void msg_mutex_unlock(msg_mutex_t *mutex) { + xSemaphoreGive(*mutex); } -static inline void msg_mutex_unlock(void *mutex) { - rt_mutex_release(*mutex); -} - -#define msg_sem_t int +#define msg_sem_t SemaphoreHandle_t +int msg_mutex_init(msg_mutex_t *mutex); int msg_sem_init(msg_sem_t *sem); int msg_sem_notify(msg_sem_t *sem); enum MSG_WAIT_RET msg_sem_wait(msg_sem_t *sem, int ms_timeout); #else #define msg_mutex_t -#define msg_mutex_init(m) #define msg_mutex_lock(m) #define msg_mutex_unlock(m) #endif +/* ----------------------- for RT-thread ----------------------- */ +#elif (MSG_OPT_OS == MSG_OPT_OS_RT_THREAD) +#include +#include +#include #define msg_malloc rt_malloc #define msg_free rt_free #define msg_printf printf +#ifdef MSG_OPT_MUTEX_SEM +#define msg_mutex_t rt_mutex_t + +static inline void msg_mutex_lock(msg_mutex_t *mutex) { + if (rt_mutex_take(*mutex, RT_WAITING_FOREVER) != RT_EOK) { + msg_printf("lock mutex err!!\n\n"); + } +} + +static inline void msg_mutex_unlock(msg_mutex_t *mutex) { + rt_mutex_release(*mutex); +} + +#define msg_sem_t rt_sem_t + +int msg_mutex_init(msg_mutex_t *mutex); +int msg_sem_init(msg_sem_t *sem); +int msg_sem_notify(msg_sem_t *sem); +enum MSG_WAIT_RET msg_sem_wait(msg_sem_t *sem, int ms_timeout); + +#else +#define msg_mutex_t +#define msg_mutex_lock(m) +#define msg_mutex_unlock(m) +#endif /* ----------------------- for none os ----------------------- */ #elif (MSG_OPT_OS == MSG_OPT_OS_NONE_OR_OSAL) #include @@ -148,7 +136,6 @@ enum MSG_WAIT_RET msg_sem_wait(msg_sem_t *sem, int ms_timeout); #undef MSG_OPT_MUTEX_SEM #define msg_mutex_t -#define msg_mutex_init(m) #define msg_mutex_lock(m) #define msg_mutex_unlock(m) @@ -163,27 +150,24 @@ enum MSG_WAIT_RET msg_sem_wait(msg_sem_t *sem, int ms_timeout); #ifdef MSG_OPT_MUTEX_SEM #define msg_mutex_t int/* to be done */ -static inline void msg_mutex_init(void *mutex) { - /* to be done */ -} -static inline void msg_mutex_lock(void *mutex) { +static inline void msg_mutex_lock(msg_mutex_t *mutex) { /* to be done */ } -static inline void msg_mutex_unlock(void *mutex) { +static inline void msg_mutex_unlock(msg_mutex_t *mutex) { /* to be done */ } #define msg_sem_t int // to be done +int msg_mutex_init(msg_mutex_t *mutex); int msg_sem_init(msg_sem_t *sem); int msg_sem_notify(msg_sem_t *sem); enum MSG_WAIT_RET msg_sem_wait(msg_sem_t *sem, int ms_timeout); #else #define msg_mutex_t -#define msg_mutex_init(m) #define msg_mutex_lock(m) #define msg_mutex_unlock(m) #endif