diff --git a/System/sv_int_pend.c b/System/sv_int_pend.c new file mode 100644 index 0000000..f8f87d1 --- /dev/null +++ b/System/sv_int_pend.c @@ -0,0 +1,289 @@ +/**************************************************************************//** + * @item CosyOS-II Kernel + * @file sv_int_pend.c + * @brief 中断挂起服务 - 执行函数（仅在PendSV中调用并执行） + * @author 迟凯峰 + * @version V2.0.0 + * @date 2024.03.17 + ******************************************************************************/ + +#include "os_link.h" + +/* 恢复任务 */ +static void _resume_task_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_tasknode_tsp node = ((sp_task_tsp)sv)->node; + if(node == NULL) return; + if(node->status & OS_STATUS_SUSPENDED){ + node->status &= (~OS_STATUS_SUSPENDED & 0xFF); + if(!s_sign_scheduling){ + s_scheduling_ready(node); + } + } +} + +/* 挂起任务 */ +static void _suspend_task_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_tasknode_tsp node = ((sp_task_tsp)sv)->node; + if(node == NULL) return; + if(node->status < OS_STATUS_SUSPENDED){ + node->status |= OS_STATUS_SUSPENDED; + if(!s_sign_scheduling){ + if(node == s_task_current){ + s_sign_scheduling = true; + } + } + } +} + +/* 删除任务 */ +static void _delete_task_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_tasknode_tsp node = ((sp_task_tsp)sv)->node; + if(node == NULL) return; + if(node->status < OS_STATUS_DELETED){ + node->status = OS_STATUS_DELETED; + if(!s_sign_scheduling){ + if(node == s_task_current){ + s_sign_scheduling = true; + } + } + } +} + +/* 设置任务优先级 */ +static void _set_taskpri_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_tasknode_tsp node = ((sp_taskpri_tsp)sv)->node; + if(node == NULL) return; + if(node->status < OS_STATUS_STOPPED){ + s_u8_t pri = ((sp_taskpri_tsp)sv)->pri; + if(node->pri != pri){ + node->pri = pri; + s_set_taskpri(node); + if(!s_sign_scheduling){ + s_scheduling_ready(node); + } + } + } +} + +/* 设置阻塞（时间）*/ +static void _set_block_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_tasknode_tsp node = ((sp_blocktime_tsp)sv)->node; + if(node == NULL) return; + if(node->status == OS_STATUS_BLOCKED || node->status == OS_STATUS_FLOATING){ + s_delay_loader[node->tid] = ((sp_blocktime_tsp)sv)->tick; + if(!((sp_blocktime_tsp)sv)->tick){ + node->status = OS_STATUS_READY; + if(!s_sign_scheduling){ + s_scheduling_taskpri(node); + } + } + } +} + +/* 清除阻塞（状态）*/ +static void _clear_block_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_tasknode_tsp node = ((sp_task_tsp)sv)->node; + if(node == NULL) return; + if(node->status == OS_STATUS_BLOCKED || node->status == OS_STATUS_FLOATING){ + s_delay_loader[node->tid] = 0; + node->status = OS_STATUS_READY; + if(!s_sign_scheduling){ + s_scheduling_taskpri(node); + } + } +} + +/* 定时中断 */ +#if OS_TIMINTTOTAL +static void _timint_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_timint_loader[((sp_timint_tsp)sv)->tmid] + = s_timint_reload[((sp_timint_tsp)sv)->tmid] + = ((sp_timint_tsp)sv)->tick; +} +#else +#define _timint_ (s_voidvptr_tfp)NULL +#endif + +/* 定时查询 */ +#if OS_TIMQRYTOTAL +static void _timqry_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_timqry_loader[((sp_timqry_tsp)sv)->tmid] + = s_timqry_reload[((sp_timqry_tsp)sv)->tmid] + = ((sp_timqry_tsp)sv)->tick; +} +#else +#define _timqry_ (s_voidvptr_tfp)NULL +#endif + +/* 上锁/给予二值信号量 */ +#if SYSCFG_BINARY == __ENABLED__ +static void _binary_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_binary_tsp bin = ((sp_binary_tsp)sv)->bin; + bin->binary = ((sp_binary_tsp)sv)->value; + if(!bin->binary) return; + if(!s_sign_scheduling){ + s_scheduling_notnull(bin->node); + } +} +#else +#define _binary_ (s_voidvptr_tfp)NULL +#endif + +/* 给予计数信号量 */ +#if SYSCFG_SEMAPHORE == __ENABLED__ +static void _give_sem_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_semaph_tsp sem = ((sp_semaph_tsp)sv)->sem; + if(sem->counter < sem->maximum){ + sem->counter++; + } + if(!s_sign_scheduling){ + s_scheduling_notnull(sem->node); + } +} +#else +#define _give_sem_ (s_voidvptr_tfp)NULL +#endif + +/* 发送飞信 */ +#if SYSCFG_FETION == __ENABLED__ +static void _send_fetion_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_fetion_tsp tbox = ((sp_fetion_tsp)sv)->tbox; + tbox->fetion = ((sp_fetion_tsp)sv)->fetion; + if(!s_sign_scheduling){ + s_scheduling_notnull(tbox->node); + } +} +#else +#define _send_fetion_ (s_voidvptr_tfp)NULL +#endif + +/* 发送邮件 */ +#if SYSCFG_MAILBOX == __ENABLED__ +static void _send_mail_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + si_accessor_tsp accessor = ((sp_accessor_tsp)sv)->accessor; + #if SYSCFG_MAILBOX_ACCESSMECHANISM == 1 + accessor->lf = true; + #endif + sWrite_MBoxAccessor((s_accessor_tsp)accessor); + s_memcpy(&accessor->gm->mail0, accessor->lm, accessor->size); + sWrite_MBoxAccessor(NULL); + #if SYSCFG_MAILBOX_ACCESSMECHANISM == 0 + accessor->gm->gf = true; + #elif SYSCFG_MAILBOX_ACCESSMECHANISM == 1 + accessor->gm->gf = accessor->lf; + #endif + if(!s_sign_scheduling){ + s_scheduling_notnull(accessor->gm->node); + } +} +#else +#define _send_mail_ (s_voidvptr_tfp)NULL +#endif + +/* 发送消息 */ +#if SYSCFG_MSGQUEUE == __ENABLED__ +static void _send_msg_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + s_msgqueue_tsp queue = ((sp_msg_tsp)sv)->queue; + queue->mutex = false; + if(queue->counter == queue->len){ + queue->mutex = true; + #if SYSCFG_DEBUGGING == __ENABLED__ + s_alarm.overflow_msgqueue = true; + #endif + return; + } + if(queue->type == __DYNAMIC__){ + s_msgnode_tsp node = NULL; + node = (s_msgnode_tsp)s_malloc(sizeof(s_msgnode_ts)); + if(node == NULL){ + queue->mutex = true; + #if SYSCFG_DEBUGGING == __ENABLED__ + s_fault.mallocfailed_msgnode = true; + #endif + return; + } + sSendMsg_Dynamic(((sp_msg_tsp)sv)->msg); + } + else{ + sSendMsg_Static(((sp_msg_tsp)sv)->msg); + } + if(!s_sign_scheduling){ + s_scheduling_notnull(queue->node); + } + queue->mutex = true; +} +#else +#define _send_msg_ (s_voidvptr_tfp)NULL +#endif + +/* 写标志组 */ +#if SYSCFG_FLAGGROUP == __ENABLED__ +static void _group_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + switch(((sp_group_tsp)sv)->size){ + case +1: *(s_u8_t *)((sp_group_tsp)sv)->group |= ((sp_group_tsp)sv)->value; break; + case +2: *(s_u16_t *)((sp_group_tsp)sv)->group |= ((sp_group_tsp)sv)->value; break; + case +4: *(s_u32_t *)((sp_group_tsp)sv)->group |= ((sp_group_tsp)sv)->value; break; + case -1: *(s_u8_t *)((sp_group_tsp)sv)->group &=~((sp_group_tsp)sv)->value; break; + case -2: *(s_u16_t *)((sp_group_tsp)sv)->group &=~((sp_group_tsp)sv)->value; break; + case -4: *(s_u32_t *)((sp_group_tsp)sv)->group &=~((sp_group_tsp)sv)->value; break; + } +} +#else +#define _group_ (s_voidvptr_tfp)NULL +#endif + +/* 全局变量写访问 */ +static void _gvar_write_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + ((sp_gvar_tsp)sv)->size + ? s_memcpy(((sp_gvar_tsp)sv)->gp, ((sp_gvar_tsp)sv)->lp, ((sp_gvar_tsp)sv)->size) + : s_strcpy((char *)((sp_gvar_tsp)sv)->gp, (char *)((sp_gvar_tsp)sv)->lp); +} + +/* 挂起服务调用 */ +static void _pendsvc_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + (*((sp_pendsvc_tsp)sv)->fp)(); +} + +/* 发送信号 */ +static void _send_sign_(void _OBJ_MEM_ *sv) MCUCFG_C51USING +{ + *((sp_sign_tsp)sv)->sign = true; +} + +typedef void (_CODE_MEM_ *s_voidvptr_tfp)(void _OBJ_MEM_ *); +void (_CODE_MEM_ * const _CONST_MEM_ sPendSV_Handler[OS_SVID_END])(void _OBJ_MEM_ *) = +{ + _resume_task_, + _suspend_task_, + _delete_task_, + _set_taskpri_, + _set_block_, + _clear_block_, + _timint_, + _timqry_, + _binary_, + _give_sem_, + _send_fetion_, + _send_mail_, + _send_msg_, + _group_, + _gvar_write_, + _pendsvc_, + _send_sign_ +}; diff --git a/System/sv_int_pend.h b/System/sv_int_pend.h new file mode 100644 index 0000000..8ccc362 --- /dev/null +++ b/System/sv_int_pend.h @@ -0,0 +1,230 @@ +/**************************************************************************//** + * @item CosyOS-II Kernel + * @file sv_int_pend.h + * @brief 中断挂起服务 - 调用宏（仅在用户中断中调用） + * @author 迟凯峰 + * @version V2.0.0 + * @date 2024.03.17 + ******************************************************************************/ + +#ifndef __SV_INT_PEND_H +#define __SV_INT_PEND_H + + + +/* + * 任务 + */ + +/* 恢复任务 */ +#define sPSV_ResumeTask(load) \ +do{ \ + static sp_task_ts u_psv = {OS_SVID_RESUMETASK, NULL}; \ + u_psv.node = load; \ + mPendSV_Load; \ +}while(false) + +/* 挂起任务 */ +#define sPSV_SuspendTask(load) \ +do{ \ + static sp_task_ts u_psv = {OS_SVID_SUSPENDTASK, NULL}; \ + u_psv.node = load; \ + mPendSV_Load; \ +}while(false) + +/* 删除任务 */ +#define sPSV_DeleteTask(load) \ +do{ \ + static sp_task_ts u_psv = {OS_SVID_DELETETASK, NULL}; \ + u_psv.node = load; \ + mPendSV_Load; \ +}while(false) + +/* 设置任务优先级 */ +#define sPSV_SetTaskPri(load, pri) \ +do{ \ + static sp_taskpri_ts u_psv = {OS_SVID_SETTASKPRI, NULL, pri}; \ + u_psv.node = load; \ + mPendSV_Load; \ +}while(false) + +/* 设置阻塞（时间）*/ +#define sPSV_SetBlock(load, tc) \ +do{ \ + static sp_blocktime_ts u_psv = {OS_SVID_SETBLOCK, NULL, tc}; \ + u_psv.node = load; \ + mPendSV_Load; \ +}while(false) + +/* 清除阻塞（状态）*/ +#define sPSV_ClearBlock(load) \ +do{ \ + static sp_task_ts u_psv = {OS_SVID_CELARBLOCK, NULL}; \ + u_psv.node = load; \ + mPendSV_Load; \ +}while(false) + + + +/* + * 定时 + */ + +/* 定时中断 */ +#define sPSV_TimInt(tmid, tc) \ +do{ \ + static sp_timint_ts u_psv = {OS_SVID_TIMINT, tmid, 0}; \ + u_psv.tick = tc; \ + mPendSV_Load; \ +}while(false) + +/* 定时查询 */ +#define sPSV_TimQry(tmid, tc) \ +do{ \ + static sp_timqry_ts u_psv = {OS_SVID_TIMQRY, tmid, 0}; \ + u_psv.tick = tc; \ + mPendSV_Load; \ +}while(false) + + + +/* + * 二值信号量 + */ + +/* 上锁/给予 */ +#define sPSV_WriteBin(bin, val) \ +do{ \ + static sp_binary_ts u_psv = {OS_SVID_BINARY, &bin, val}; \ + mPendSV_Load; \ +}while(false) + + + +/* + * 计数信号量 + */ + +/* 给予 */ +#define sPSV_GiveSem(sem) \ +do{ \ + static sp_sem_ts u_psv = {OS_SVID_GIVESEM, &sem}; \ + mPendSV_Load; \ +}while(false) + + + +/* + * 飞信 + */ + +/* 发送飞信 */ +#define sPSV_SendFetion(tbox, tion) \ +do{ \ + static sp_fetion_ts u_psv = {OS_SVID_SENDFETION, &tbox, 0}; \ + u_psv.fetion = tion; \ + mPendSV_Load; \ +}while(false) + + + +/* + * 消息邮箱 + */ + +#if SYSCFG_MAILBOX_ACCESSMECHANISM == 0 + #define sPSV_0x03 + +#elif SYSCFG_MAILBOX_ACCESSMECHANISM == 1 + #define sPSV_0x03 false, + +#endif + +/* 发送邮件 */ +#define sPSV_SendMail(mbox, mail) \ +do{ \ + static si_accessor_ts u_acc = {(s_mailbox_tsp)&mbox, mail, sPSV_0x03 sizeof(mbox.mail0)}; \ + static sp_accessor_ts u_psv = {OS_SVID_SENDMAIL, &u_acc}; \ + mPendSV_Load; \ +}while(false) + + + +/* + * 消息队列 + */ + +/* 发送消息 */ +#define sPSV_SendMsg(que, msg) \ +do{ \ + static sp_msg_ts u_psv = {OS_SVID_SENDMSG, que, msg}; \ + mPendSV_Load; \ +}while(false) + + + +/* + * 事件标志组 + */ + +/* 清除标志组 */ +#define sPSV_ClearFlagGroup(group) \ +do{ \ + static sp_group_ts u_psv = {OS_SVID_GROUP, (void *)&group, -sizeof(group), ~0}; \ + mPendSV_Load; \ +}while(false) + +/* 写多标志位 */ +#define sPSV_WriteFlagBits(group, sign, nbit) \ +do{ \ + static sp_group_ts u_psv = {OS_SVID_GROUP, (void *)&group, sign##sizeof(group), 0}; \ + u_##group##_ts lv; \ + miWriteFlagBits; \ + sizeof(lv) == 1 ? *(s_u8_t *)&lv = false : OS_NOPx1; \ + sizeof(lv) == 2 ? *(s_u16_t *)&lv = false : OS_NOPx1; \ + sizeof(lv) == 4 ? *(s_u32_t *)&lv = false : OS_NOPx1; \ + siWriteFlagBits_##nbit( + + + +/* + * 全局变量 + */ + +/* 全局变量写访问 */ +#define sPSV_WriteGVar(gp, lp, size) \ +do{ \ + static sp_gvar_ts u_psv = {OS_SVID_GVARWRITE, gp, lp, size}; \ + mPendSV_Load; \ +}while(false) + +/* 挂起服务调用 */ +#define sPSV_PendSVC(fp) \ +do{ \ + static sp_pendsvc_ts u_psv = {OS_SVID_PENDSVC, fp}; \ + mPendSV_Load; \ +}while(false) + +/* 发送信号 */ +#define sPSV_SendSign(sign) \ +do{ \ + static sp_sign_ts u_psv = {OS_SVID_SENDSIGN, (s_bool_t *)&sign}; \ + mPendSV_Load; \ +}while(false) + + + +/* + * 软件RTC + */ + +/* 设置时间 */ +#define sPSV_SetTime(t) \ +do{ \ + iWriteGAry(s_rtc[0], t, sizeof(s_rtc[0])); \ + iSendSign(s_sign_rtc); \ +}while(false) + + + +#endif diff --git a/System/sv_task.c b/System/sv_task.c new file mode 100644 index 0000000..6bf68a3 --- /dev/null +++ b/System/sv_task.c @@ -0,0 +1,844 @@ +/**************************************************************************//** + * @item CosyOS-II Kernel + * @file sv_task.c + * @brief 任务服务（仅在任务中调用） + * @author 迟凯峰 + * @version V2.0.0 + * @date 2024.03.17 + ******************************************************************************/ + +#include "os_var.h" +#include "os_api.h" +#include "ur_api.h" + +/* 进入任务临界区 */ +void su_enter_critical(void) +{ + mSysIRQ_Disable; + s_taskcri_counter++; +} + +/* 退出任务临界区 */ +void su_exit_critical(void) +{ + s_taskcri_counter--; + if(!s_taskcri_counter){ + if(s_sign_scheduling){ + mPendSV_Set; + mSysIRQ_Enable; + while(s_sign_scheduling); + } + else{ + mSysIRQ_Enable; + } + } +} + +void *su_return_voidptr(void *p) +{ + uExitCritical; + return p; +} + +/* 无条件任务调度 */ +void su_task_scheduling(void) +{ + if(!s_sign_scheduling){ + uEnterCritical; + s_sign_scheduling = true; + uExitCritical; + } +} + +/* 任务优先级调度 */ +void su_taskpri_scheduling(s_tasknode_tsp node) +{ + if(!s_sign_scheduling){ + uEnterCritical; + s_scheduling_taskpri(node); + uExitCritical; + } +} + +/* 启动任务 */ +s_ecode_t su_startup_task(s_taskhand_tsp hand, s_u8_t status) +{ + static s_tid_t _SYS_MEM_ tid = 0; + if(!hand->tid){ + tid++; + hand->tid = tid; + } + if(*hand->handle != NULL){ + ((s_tasknode_tsp)hand)->status = status; + } + else{ + s_task_status0 = status; + } + s_task_starter = hand; + s_sign_scheduling = true; + uExitCritical; + return s_startup_code; +} + +/* 挂起任务 */ +s_ecode_t su_suspend_task(s_tasknode_tsp node) +{ + if(node == NULL){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status < OS_STATUS_SUSPENDED){ + node->status |= OS_STATUS_SUSPENDED; + if(!s_sign_scheduling){ + if(node == s_task_current){ + s_sign_scheduling = true; + } + } + uExitCritical; + return OS_ECODE_NOERROR; + } + if(node->status & OS_STATUS_SUSPENDED){ + uExitCritical; + return OS_ECODE_TASKSUSPENDED; + } + if(node->status & OS_STATUS_STOPPED){ + uExitCritical; + return OS_ECODE_TASKSTOPPED; + } + if(node->status == OS_STATUS_DELETED){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + else{ + uExitCritical; + return OS_ECODE_DONOTKNOW; + } +} + +/* 恢复任务 */ +s_ecode_t su_resume_task(s_tasknode_tsp node) +{ + if(node == NULL){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status & OS_STATUS_SUSPENDED){ + node->status &= (~OS_STATUS_SUSPENDED & 0xFF); + if(!s_sign_scheduling){ + s_scheduling_ready(node); + } + uExitCritical; + return OS_ECODE_NOERROR; + } + if(node->status < OS_STATUS_STOPPED){ + uExitCritical; + return OS_ECODE_TASKNOTSUSPENDED; + } + if(node->status & OS_STATUS_STOPPED){ + uExitCritical; + return OS_ECODE_TASKSTOPPED; + } + if(node->status == OS_STATUS_DELETED){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + else{ + uExitCritical; + return OS_ECODE_DONOTKNOW; + } +} + +/* 恢复指定任务并挂起自身任务 */ +s_ecode_t su_resume_suspend(s_tasknode_tsp node) +{ + if(node == NULL){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status & OS_STATUS_SUSPENDED){ + node->status &= (~OS_STATUS_SUSPENDED & 0xFF); + } + if(node->status <= OS_STATUS_FLOATING){ + s_task_current->status |= OS_STATUS_SUSPENDED; + s_sign_scheduling = true; + uExitCritical; + return OS_ECODE_NOERROR; + } + if(node->status < OS_STATUS_STOPPED){ + uExitCritical; + return OS_ECODE_TASKNOTREADY; + } + if(node->status & OS_STATUS_STOPPED){ + uExitCritical; + return OS_ECODE_TASKSTOPPED; + } + if(node->status == OS_STATUS_DELETED){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + else{ + uExitCritical; + return OS_ECODE_DONOTKNOW; + } +} + +/* 删除任务 */ +s_ecode_t su_delete_task(s_tasknode_tsp node) +{ + if(node == NULL){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status < OS_STATUS_DELETED){ + node->status = OS_STATUS_DELETED; + if(!s_sign_scheduling){ + if(node == s_task_current){ + s_sign_scheduling = true; + } + } + uExitCritical; + return OS_ECODE_NOERROR; + } + if(node->status == OS_STATUS_DELETED){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + else{ + uExitCritical; + return OS_ECODE_DONOTKNOW; + } +} + +/* 设置任务优先级 */ +s_ecode_t su_set_taskpri(s_tasknode_tsp node, s_u8_t pri) +{ + if(node == NULL){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status < OS_STATUS_STOPPED){ + if(node->pri != pri){ + if(!s_sign_scheduling){ + if(node == s_task_current){ + if(node->pri > pri){ + s_sign_scheduling = true; + } + node->pri = pri; + } + else{ + node->pri = pri; + s_scheduling_ready(node); + } + } + else{ + node->pri = pri; + } + s_set_taskpri(node); + uExitCritical; + return OS_ECODE_NOERROR; + } + else{ + uExitCritical; + return OS_ECODE_TASKPRIUNCHANGED; + } + } + if(node->status & OS_STATUS_STOPPED){ + uExitCritical; + return OS_ECODE_TASKSTOPPED; + } + if(node->status == OS_STATUS_DELETED){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + else{ + uExitCritical; + return OS_ECODE_DONOTKNOW; + } +} + +/* 设置阻塞（时间）*/ +s_ecode_t su_set_block(s_tasknode_tsp node, s_delay_t tick) +{ + if(node == NULL){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status == OS_STATUS_BLOCKED || node->status == OS_STATUS_FLOATING){ + s_delay_loader[node->tid] = tick; + if(!tick){ + node->status = OS_STATUS_READY; + if(!s_sign_scheduling){ + s_scheduling_taskpri(node); + } + } + uExitCritical; + return OS_ECODE_NOERROR; + } + else{ + uExitCritical; + return OS_ECODE_TASKNOTBLOCKED; + } +} + +/* 清除阻塞（状态）*/ +s_ecode_t su_clear_block(s_tasknode_tsp node) +{ + if(node == NULL){ + uExitCritical; + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status == OS_STATUS_BLOCKED || node->status == OS_STATUS_FLOATING){ + s_delay_loader[node->tid] = 0; + node->status = OS_STATUS_READY; + if(!s_sign_scheduling){ + s_scheduling_taskpri(node); + } + uExitCritical; + return OS_ECODE_NOERROR; + } + else{ + uExitCritical; + return OS_ECODE_TASKNOTBLOCKED; + } +} + +/* 自身任务延时 */ +void su_delay(s_delay_t tick) +{ + if(s_task_current->status == OS_STATUS_READY){ + s_delay_loader[s_task_current->tid] = tick; + s_task_current->status = OS_STATUS_BLOCKED; + s_sign_scheduling = true; + } + else if(s_task_current->status == OS_STATUS_BLOCKED){ + s_delay_loader[s_task_current->tid] += tick; + } + uExitCritical; +} + + + +/* + * 互斥信号量 + */ +#if SYSCFG_MUTEX == __ENABLED__ +/* 获取 */ +s_bool_t su_take_mutex(s_mutex_tsp mut, s_delay_t tick) +{ + if(!mut->mutex) goto __RET_TRUE1; + if(s_task_current == mut->node) goto __RET_TRUE2; + if(!tick) goto __RET_FALSE; + + s_delay_loader[s_task_current->tid] = tick; + s_task_current->status = OS_STATUS_BLOCKED; + s_task_current->blocktype = OS_BLOCKED_MUTEX | 0x0F; + s_task_current->ptr = mut; + if(s_task_current->pri > mut->node->pri){ + mut->node->pri = s_task_current->pri; + s_set_taskpri(mut->node); + } + s_sign_scheduling = true; + uExitCritical; + s_task_current->blocktype = 0; + #if SYSCFG_MCUCORE == 8051 + mut = (s_mutex_tsp)s_task_current->ptr; + #endif + if(!mut->mutex) goto __RET_TRUE1; + +__RET_FALSE: + uExitCritical; + return false; + +__RET_TRUE1: + mut->node = s_task_current; + mut->oldpri = s_task_current->pri; + +__RET_TRUE2: + mut->mutex++; + uExitCritical; + return true; +} + +/* 归还 */ +void su_back_mutex(s_mutex_tsp mut) +{ + if(!mut->mutex); + else if(s_task_current == mut->node){ + mut->mutex--; + if(!mut->mutex){ + if(s_task_current->pri > mut->oldpri){ + s_task_current->pri = mut->oldpri; + s_set_taskpri(s_task_current); + s_sign_scheduling = true; + } + } + } + uExitCritical; +} + +#endif + + + +/* + * 二值信号量 + */ +#if SYSCFG_BINARY == __ENABLED__ +/* 等待 */ +s_bool_t su_wait_binary(s_binary_tsp bin, s_delay_t tick) +{ + if(bin->binary) goto __RET_TRUE; + if(!tick) goto __RET_FALSE; + + bin->node = s_task_current; + s_delay_loader[s_task_current->tid] = tick; + s_task_current->status = OS_STATUS_BLOCKED; + s_task_current->blocktype = OS_BLOCKED_BINARY | sizeof(bin->binary); + s_task_current->ptr = bin; + s_sign_scheduling = true; + uExitCritical; + s_task_current->blocktype = 0; + #if SYSCFG_MCUCORE == 8051 + bin = (s_binary_tsp)s_task_current->ptr; + #endif + bin->node = NULL; + if(bin->binary) goto __RET_TRUE; + +__RET_FALSE: + uExitCritical; + return false; + +__RET_TRUE: + uExitCritical; + return true; +} + +/* 获取 */ +s_bool_t su_take_binary(s_binary_tsp bin, s_delay_t tick) +{ + if(bin->binary) goto __RET_TRUE; + if(!tick) goto __RET_FALSE; + + bin->node = s_task_current; + s_delay_loader[s_task_current->tid] = tick; + s_task_current->status = OS_STATUS_BLOCKED; + s_task_current->blocktype = OS_BLOCKED_BINARY | sizeof(bin->binary); + s_task_current->ptr = bin; + s_sign_scheduling = true; + uExitCritical; + s_task_current->blocktype = 0; + #if SYSCFG_MCUCORE == 8051 + bin = (s_binary_tsp)s_task_current->ptr; + #endif + bin->node = NULL; + if(bin->binary) goto __RET_TRUE; + +__RET_FALSE: + uExitCritical; + return false; + +__RET_TRUE: + bin->binary = false; + uExitCritical; + return true; +} + +/* 给予 */ +void su_give_binary(s_binary_tsp bin) +{ + bin->binary = true; + if(!s_sign_scheduling){ + s_scheduling_notnull(bin->node); + } + uExitCritical; +} + +#endif + + + +/* + * 计数信号量 + */ +#if SYSCFG_SEMAPHORE == __ENABLED__ +/* 获取 */ +s_bool_t su_take_semaphore(s_semaph_tsp sem, s_delay_t tick) +{ + if(sem->counter) goto __RET_TRUE; + if(!tick) goto __RET_FALSE; + + sem->node = s_task_current; + s_delay_loader[s_task_current->tid] = tick; + s_task_current->status = OS_STATUS_BLOCKED; + s_task_current->blocktype = OS_BLOCKED_SEMAPHORE | sizeof(sem->counter); + s_task_current->ptr = sem; + s_sign_scheduling = true; + uExitCritical; + s_task_current->blocktype = 0; + #if SYSCFG_MCUCORE == 8051 + sem = (s_semaph_tsp)s_task_current->ptr; + #endif + sem->node = NULL; + if(sem->counter) goto __RET_TRUE; + +__RET_FALSE: + uExitCritical; + return false; + +__RET_TRUE: + (sem->counter)--; + uExitCritical; + return true; +} + +/* 给予 */ +void su_give_semaphore(s_semaph_tsp sem) +{ + if(sem->counter < sem->maximum){ + sem->counter++; + } + if(!s_sign_scheduling){ + s_scheduling_notnull(sem->node); + } + uExitCritical; +} + +/* 归还 */ +void su_back_semaphore(s_semaph_tsp sem) +{ + if(sem->counter < sem->maximum){ + sem->counter++; + } + uExitCritical; +} + +#endif + + + +/* + * 私信 + */ +#if SYSCFG_TASKMSG == __ENABLED__ +/* 接收私信 */ +s_bool_t su_recv_taskmsg(m_taskmsg_t _OBJ_MEM_ *nmf, s_delay_t tick) +{ + if(*nmf) goto __RET_TRUE; + if(!tick) goto __RET_FALSE; + + s_delay_loader[s_task_current->tid] = tick; + s_task_current->status = OS_STATUS_BLOCKED; + s_task_current->blocktype = OS_BLOCKED_TASKMSG | sizeof(*nmf); + s_task_current->ptr = nmf; + s_sign_scheduling = true; + uExitCritical; + s_task_current->blocktype = 0; + #if SYSCFG_MCUCORE == 8051 + nmf = (m_taskmsg_t *)s_task_current->ptr; + #endif + if(*nmf) goto __RET_TRUE; + +__RET_FALSE: + uExitCritical; + return false; + +__RET_TRUE: + *nmf = false; + return true; +} + +#endif + + + +/* + * 飞信 + */ +#if SYSCFG_FETION == __ENABLED__ +/* 接收飞信 */ +static m_fetion_t _recv_fetion_(s_fetion_tsp fet) +{ + m_fetion_t fetion = fet->fetion; + fet->fetion = false; + uExitCritical; + return fetion; +} + +m_fetion_t su_recv_fetion(s_fetion_tsp fet, s_delay_t tick) +{ + if(fet->fetion) goto __RET_TION; + if(!tick) goto __RET_FALSE; + + fet->node = s_task_current; + s_delay_loader[s_task_current->tid] = tick; + s_task_current->status = OS_STATUS_BLOCKED; + s_task_current->blocktype = OS_BLOCKED_FETION | sizeof(fet->fetion); + s_task_current->ptr = fet; + s_sign_scheduling = true; + uExitCritical; + s_task_current->blocktype = 0; + #if SYSCFG_MCUCORE == 8051 + fet = (s_fetion_tsp)s_task_current->ptr; + #endif + fet->node = NULL; + +__RET_TION: + return _recv_fetion_(fet); + +__RET_FALSE: + uExitCritical; + return false; +} + +#endif + + + +/* + * 消息邮箱 + */ +#if SYSCFG_MAILBOX == __ENABLED__ +/* 接收邮件 */ +s_bool_t su_recv_mail(s_mailbox_tsp gm, s_delay_t tick) +{ + if(gm->gf) goto __RET_TRUE; + if(!tick) goto __RET_FALSE; + + gm->node = s_task_current; + s_delay_loader[s_task_current->tid] = tick; + s_task_current->status = OS_STATUS_BLOCKED; + s_task_current->blocktype = OS_BLOCKED_MAIL | sizeof(gm->gf); + s_task_current->ptr = gm; + s_sign_scheduling = true; + uExitCritical; + s_task_current->blocktype = 0; + #if SYSCFG_MCUCORE == 8051 + gm = (s_mailbox_tsp)s_task_current->ptr; + #endif + gm->node = NULL; + if(gm->gf) goto __RET_TRUE; + +__RET_FALSE: + uExitCritical; + return false; + +__RET_TRUE: + gm->gf = false; + return true; +} + +/* 发送邮件 */ +void su_send_mail(s_mailbox_tsp gm, void *lm, size_t size) +{ + static s_accessor_ts accessor; + accessor.gm = gm; + #if SYSCFG_MAILBOX_ACCESSMECHANISM == 1 + accessor.lm = lm; + accessor.lf = true; + #endif + sWrite_MBoxAccessor(&accessor); + s_memcpy(&gm->mail0, lm, size); + sWrite_MBoxAccessor(NULL); + #if SYSCFG_MAILBOX_ACCESSMECHANISM == 0 + gm->gf = true; + #elif SYSCFG_MAILBOX_ACCESSMECHANISM == 1 + gm->gf = accessor.lf; + #endif + if(!s_sign_scheduling){ + s_scheduling_notnull(gm->node); + } + uExitCritical; +} + +#endif + + + +/* + * 消息队列 + */ +#if SYSCFG_MSGQUEUE == __ENABLED__ +/* 接收消息 */ +void *su_recv_msg(s_msgqueue_tsp queue, s_delay_t tick) +{ + void *msg; + s_msgnode_tsp node; + queue->mutex = false; + if(queue->counter) goto __RECV_MSG; + queue->mutex = true; + if(!tick) goto __RET_NULL; + + queue->node = s_task_current; + s_delay_loader[s_task_current->tid] = tick; + s_task_current->status = OS_STATUS_BLOCKED; + s_task_current->blocktype = OS_BLOCKED_MSG | sizeof(queue->counter); + s_task_current->ptr = queue; + s_sign_scheduling = true; + uExitCritical; + s_task_current->blocktype = 0; + #if SYSCFG_MCUCORE == 8051 + queue = (s_msgqueue_tsp)s_task_current->ptr; + #endif + queue->node = NULL; + queue->mutex = false; + if(!queue->counter) goto __FREE_MUTEX; + +__RECV_MSG: + if(queue->type == __DYNAMIC__){ + sRecvMsg_Dynamic(msg); + } + else{ + sRecvMsg_Static(msg); + } + queue->mutex = true; + return su_return_voidptr(msg); + +__FREE_MUTEX: + queue->mutex = true; + +__RET_NULL: + uExitCritical; + return NULL; +} + +/* 发送消息 */ +s_ecode_t su_send_msg(s_msgqueue_tsp queue, void *msg) +{ + queue->mutex = false; + if(queue->counter == queue->len){ + queue->mutex = true; + #if SYSCFG_DEBUGGING == __ENABLED__ + s_alarm.overflow_msgqueue = true; + #endif + uExitCritical; + return OS_ECODE_OVERFLOW_MSGQUEUE; + } + if(queue->type == __DYNAMIC__){ + s_msgnode_tsp node = NULL; + node = (s_msgnode_tsp)s_malloc(sizeof(s_msgnode_ts)); + if(node == NULL){ + queue->mutex = true; + #if SYSCFG_DEBUGGING == __ENABLED__ + s_fault.mallocfailed_msgnode = true; + #endif + uExitCritical; + return OS_ECODE_MALLOCFAIL_MSGNODE; + } + sSendMsg_Dynamic(msg); + } + else{ + sSendMsg_Static(msg); + } + if(!s_sign_scheduling){ + s_scheduling_notnull(queue->node); + } + queue->mutex = true; + uExitCritical; + return OS_ECODE_NOERROR; +} + +#endif + + + +/* + * 事件标志组 + */ +#if SYSCFG_FLAGGROUP == __ENABLED__ +/* 查询标志组 */ +s_bool_t su_query_group(void _OBJ_MEM_ *p, s_u8_t size) +{ + switch(size){ + case 1: if(*(s_u8_t *)p) goto __RET_TRUE; break; + case 2: if(*(s_u16_t *)p) goto __RET_TRUE; break; + case 4: if(*(s_u32_t *)p) goto __RET_TRUE; break; + } + uExitCritical; + return false; + +__RET_TRUE: + uExitCritical; + return true; +} + +/* 等待标志组 */ +s_bool_t su_wait_group(void _OBJ_MEM_ *p, s_u8_t size, s_delay_t tick) +{ + switch(size){ + case 1: if(*(s_u8_t *)p) goto __RET_TRUE; break; + case 2: if(*(s_u16_t *)p) goto __RET_TRUE; break; + case 4: if(*(s_u32_t *)p) goto __RET_TRUE; break; + } + if(!tick) goto __RET_FALSE; + + s_delay_loader[s_task_current->tid] = tick; + s_task_current->status = OS_STATUS_BLOCKED; + s_task_current->blocktype = OS_BLOCKED_FLAGGROUP | size; + s_task_current->ptr = p; + s_sign_scheduling = true; + uExitCritical; + #if SYSCFG_MCUCORE == 8051 || SYSCFG_MCUCORE == 80251 + size = s_task_current->blocktype & 0x0F; + #endif + s_task_current->blocktype = 0; + #if SYSCFG_MCUCORE == 8051 + p = s_task_current->ptr; + #endif + switch(size){ + case 1: if(*(s_u8_t *)p) goto __RET_TRUE; break; + case 2: if(*(s_u16_t *)p) goto __RET_TRUE; break; + case 4: if(*(s_u32_t *)p) goto __RET_TRUE; break; + } +__RET_FALSE: + uExitCritical; + return false; + +__RET_TRUE: + uExitCritical; + return true; +} + +#endif + + + +/* + * 动态内存 + */ +#if SYSCFG_DYNMEMMGE == __ENABLED__ +/* uxalloc */ +void _MALLOC_MEM_ *su_xalloc(void _MALLOC_MEM_ *p) +{ + uExitCritical; + return p; +} + +/* 初始化线程内存池 */ +s_bool_t su_init_mempool(s_thrmem_tsp p, size_t size) +{ + p->head = p->move = s_malloc(size); + if(p->head == NULL){ + uExitCritical; + return false; + } + else{ + p->size = size; + uExitCritical; + return true; + } +} + +/* 线程内存分配 */ +void _MALLOC_MEM_ *su_talloc(s_thrmem_tsp p, size_t size) +{ + if(p->head == NULL || (size_t)p->move - (size_t)p->head + size > p->size){ + return NULL; + } + else{ + void _MALLOC_MEM_ *r = p->move; + p->move = (s_u8_t *)p->move + size; + return r; + } +} + +#endif diff --git a/System/sv_task.h b/System/sv_task.h new file mode 100644 index 0000000..71b81f6 --- /dev/null +++ b/System/sv_task.h @@ -0,0 +1,419 @@ +/**************************************************************************//** + * @item CosyOS-II Kernel + * @file sv_task.h + * @brief 任务服务（仅在任务中调用） + * @author 迟凯峰 + * @version V2.0.0 + * @date 2024.03.17 + ******************************************************************************/ + +#ifndef __SV_TASK_H +#define __SV_TASK_H + +void su_enter_critical (void); +void su_exit_critical (void); +void *su_return_voidptr (void *p); +void su_task_scheduling (void); +void su_taskpri_scheduling(s_tasknode_tsp node); +s_ecode_t su_startup_task (s_taskhand_tsp hand, s_u8_t status); +s_ecode_t su_suspend_task (s_tasknode_tsp node); +s_ecode_t su_resume_task (s_tasknode_tsp node); +s_ecode_t su_resume_suspend (s_tasknode_tsp node); +s_ecode_t su_delete_task (s_tasknode_tsp node); +s_ecode_t su_set_taskpri (s_tasknode_tsp node, s_u8_t pri); +s_ecode_t su_set_block (s_tasknode_tsp node, s_delay_t tick); +s_ecode_t su_clear_block (s_tasknode_tsp node); +void su_delay (s_delay_t tick); +s_bool_t su_take_mutex (s_mutex_tsp mut, s_delay_t tick); +void su_back_mutex (s_mutex_tsp mut); +s_bool_t su_wait_binary (s_binary_tsp bin, s_delay_t tick); +s_bool_t su_take_binary (s_binary_tsp bin, s_delay_t tick); +void su_give_binary (s_binary_tsp bin); +s_bool_t su_take_semaphore (s_semaph_tsp sem, s_delay_t tick); +void su_give_semaphore (s_semaph_tsp sem); +void su_back_semaphore (s_semaph_tsp sem); +s_bool_t su_recv_taskmsg (m_taskmsg_t _OBJ_MEM_ *nmf, s_delay_t tick); +m_fetion_t su_recv_fetion (s_fetion_tsp fet, s_delay_t tick); +s_bool_t su_recv_mail (s_mailbox_tsp gm, s_delay_t tick); +void su_send_mail (s_mailbox_tsp gm, void *lm, size_t size); +void *su_recv_msg (s_msgqueue_tsp queue, s_delay_t tick); +s_ecode_t su_send_msg (s_msgqueue_tsp queue, void *msg); +s_bool_t su_query_group (void _OBJ_MEM_ *p, s_u8_t size); +s_bool_t su_wait_group (void _OBJ_MEM_ *p, s_u8_t size, s_delay_t tick); + +s_bool_t su_init_mempool (s_thrmem_tsp p, size_t size); +void _MALLOC_MEM_ *su_talloc (s_thrmem_tsp p, size_t size); +void _MALLOC_MEM_ *su_xalloc (void _MALLOC_MEM_ *p); + + + +/* + * 任务 + */ + +/* 启动任务 */ +#define sUSV_StartTask(hand, status) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_startup_task((s_taskhand_tsp)hand, !status ? OS_STATUS_READY : OS_STATUS_SUSPENDED) : false \ +) + +/* 挂起任务 */ +#define sUSV_SuspendTask(node) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_suspend_task(node) : false \ +) + +/* 恢复任务 */ +#define sUSV_ResumeTask(node) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_resume_task(node) : false \ +) + +/* 恢复指定任务并挂起自身任务 */ +#define sUSV_ResumeSuspend(node) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_resume_suspend(node) : false \ +) + +/* 删除任务 */ +#define sUSV_DeleteTask(node) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_delete_task(node) : false \ +) + +/* 设置任务优先级 */ +#define sUSV_SetTaskPri(node, pri) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_set_taskpri(node, pri) : false \ +) + +/* 设置阻塞（时间）*/ +#define sUSV_SetBlock(node, tc) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_set_block(node, tc) : false \ +) + +/* 清除阻塞（状态）*/ +#define sUSV_ClearBlock(node) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_clear_block(node) : false \ +) + +/* 自身任务延时 */ +#define sUSV_Delay(tc) \ +do{ \ + uEnterCritical; \ + su_delay(tc); \ +}while(false) + + + +/* + * 定时 + */ + +/* 定时中断 */ +#define sUSV_TimInt(tmid, tc) \ +do{ \ + uEnterCritical; \ + s_timint_loader[tmid] = s_timint_reload[tmid] = tc; \ + uExitCritical; \ +}while(false) + +/* 定时查询 */ +#define sUSV_TimQry(tmid, tc) \ +do{ \ + uEnterCritical; \ + s_timqry_loader[tmid] = s_timqry_reload[tmid] = tc; \ + uExitCritical; \ +}while(false) + + + +/* + * 互斥信号量 + */ + +/* 获取 */ +#define sUSV_TakeMut(mut, tc) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_take_mutex(&mut, tc) : false \ +) + +/* 归还 */ +#define sUSV_BackMut(mut) \ +do{ \ + uEnterCritical; \ + su_back_mutex(&mut); \ +}while(false) + + + +/* + * 二值信号量 + */ + +/* 等待 */ +#define sUSV_WaitBin(bin, tc) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_wait_binary(&bin, tc) : false \ +) + +/* 获取 */ +#define sUSV_TakeBin(bin, tc) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_take_binary(&bin, tc) : false \ +) + +/* 给予 */ +#define sUSV_GiveBin(bin) \ +do{ \ + uEnterCritical; \ + su_give_binary(&bin); \ +}while(false) + + + +/* + * 计数信号量 + */ + +/* 获取 */ +#define sUSV_TakeSem(sem, tc) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_take_semaphore(&sem, tc) : false \ +) + +/* 给予 */ +#define sUSV_GiveSem(sem) \ +do{ \ + uEnterCritical; \ + su_give_semaphore(&sem); \ +}while(false) + +/* 归还 */ +#define sUSV_BackSem(sem) \ +do{ \ + uEnterCritical; \ + su_back_semaphore(&sem); \ +}while(false) + + + +/* + * 私信 + */ + +/* 接收私信 */ +#define sUSV_RecvTaskMsg(tc) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true \ + ? su_recv_taskmsg(&m0_, tc) \ + ? s_memcpy(&m0 + 1, &m0_ + 1, MCUCFG_TASKMSG_SIZE) || true \ + ? (m_boolvoid_tf(su_exit_critical))() || true \ + : (m_boolvoid_tf(su_exit_critical))() || true \ + : false \ + : false \ +) + +/* 发送私信 */ +#define sUSV_SendTaskMsg(task) \ + uEnterCritical; \ + s_sign_send_taskmsg = true; \ + MCUCFG_TASKMSG_PSP; \ + if(!s_sign_scheduling) s_scheduling_taskmsg(u_taskhandle_##task); \ + task(MCUCFG_TASKMSG_VAL, + + + +/* + * 飞信 + */ + +/* 接收飞信 */ +#define sUSV_RecvFetion(tbox, tc) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_recv_fetion(&tbox, tc) : false \ +) + +/* 发送飞信 */ +#define sUSV_SendFetion(tbox, tion) \ +do{ \ + uEnterCritical; \ + tbox.fetion = tion; \ + if(!s_sign_scheduling) s_scheduling_notnull(tbox.node); \ + uExitCritical; \ +}while(false) + + + +/* + * 消息邮箱 + */ + +/* 接收邮件 */ +#define sUSV_RecvMail(mail, mbox, tc) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true \ + ? su_recv_mail((s_mailbox_tsp)&mbox, tc) \ + ? s_memcpy(mail, &mbox.mail0, sizeof(mbox.mail0)) || true \ + ? (m_boolvoid_tf(su_exit_critical))() || true \ + : (m_boolvoid_tf(su_exit_critical))() || true \ + : false \ + : false \ +) + +/* 发送邮件 */ +#define sUSV_SendMail(mbox, mail) \ +do{ \ + uEnterCritical; \ + su_send_mail((s_mailbox_tsp)&mbox, mail, sizeof(mbox.mail0)); \ +}while(false) + + + +/* + * 消息队列 + */ + +/* 接收消息 */ +#define sUSV_RecvMsg(que, tc) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_recv_msg(que, tc) : NULL \ +) + +/* 发送消息 */ +#define sUSV_SendMsg(que, msg) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_send_msg(que, msg) : false \ +) + + + +/* + * 事件标志组 + */ + +/* 查询标志组 */ +#define sUSV_QueryFlagGroup(group) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_query_group((void *)&group, sizeof(group)) : false \ +) + +/* 等待标志组 */ +#define sUSV_WaitFlagGroup(group, tc) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_wait_group((void *)&group, sizeof(group), tc) : false \ +) + +/* 清除标志组 */ +#define sUSV_ClearFlagGroup(group) \ +do{ \ + uEnterCritical; \ + sizeof(group) == 1 ? *(s_u8_t *)&group = false : OS_NOPx1; \ + sizeof(group) == 2 ? *(s_u16_t *)&group = false : OS_NOPx1; \ + sizeof(group) == 4 ? *(s_u32_t *)&group = false : OS_NOPx1; \ + uExitCritical; \ +}while(false) + +/* 写标志位 */ +#define sUSV_WriteFlagBit(group, bit, value) \ +do{ \ + uEnterCritical; \ + group.bit = value; \ + uExitCritical; \ +}while(false) + + + +/* + * 软件RTC + */ + +/* 获取时间 */ +#define sUSV_GetTime(t) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_return_voidptr(s_memcpy(t, s_rtc[0], sizeof(s_rtc[0]))) : NULL \ +) + +/* 设置时间 */ +#define sUSV_SetTime(t) \ +do{ \ + uEnterCritical; \ + s_memcpy(s_rtc[0], t, sizeof(s_rtc[0])); \ + uUpdateCopy(s_memcpy(s_rtc[1], s_rtc[0], sizeof(s_rtc[0]))); \ + uExitCritical; \ +}while(false) + + + +/* + * 进程内存 + */ + +/* malloc */ +#define sUSV_Malloc(size) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_xalloc(s_malloc(size)) : NULL \ +) + +/* calloc */ +#define sUSV_Calloc(nmemb, size) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_xalloc(s_calloc(nmemb, size)) : NULL \ +) + +/* realloc */ +#define sUSV_Realloc(p, size) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_xalloc(s_realloc(p, size)) : NULL \ +) + +/* free */ +#define sUSV_Free(p) \ +do{ \ + uEnterCritical; \ + s_free(p); \ + uExitCritical; \ +}while(false) + + + +/* + * 线程内存 + */ + +/* 初始化线程内存池 */ +#define sUSV_InitMempool(size) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_init_mempool(&u_thrmem, size) : false \ +) + +/* 线程内存分配 */ +#define sUSV_Talloc(size) \ +( \ + (m_boolvoid_tf(su_enter_critical))() || true ? su_xalloc(su_talloc(&u_thrmem, size)) : NULL \ +) + +/* 释放线程内存池 */ +#define sUSV_FreeMempool \ +do{ \ + sUSV_Free(u_thrmem.head); \ + u_thrmem.head = u_thrmem.move = NULL; \ +}while(false) + + + +/* + * 任务调度 + */ + +/* 无条件任务调度 */ +#define sUSV_TaskScheduling su_task_scheduling() + +/* 任务优先级调度 */ +#define sUSV_TaskPriScheduling(node) su_taskpri_scheduling(node) + + + +#endif diff --git a/System/sv_tick.c b/System/sv_tick.c new file mode 100644 index 0000000..6ed2df3 --- /dev/null +++ b/System/sv_tick.c @@ -0,0 +1,282 @@ +/**************************************************************************//** + * @item CosyOS-II Kernel + * @file sv_tick.c + * @brief 滴答服务（仅在滴答钩子、定时中断钩子、定时查询钩子中调用） + * @author 迟凯峰 + * @version V2.0.0 + * @date 2024.03.17 + ******************************************************************************/ + +#include "os_var.h" +#include "os_api.h" + + + +/* + * 任务 + */ + +/* 挂起任务 */ +s_ecode_t st_suspend_task(s_tasknode_tsp node) MCUCFG_C51USING +{ + if(node == NULL){ + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status < OS_STATUS_SUSPENDED){ + node->status |= OS_STATUS_SUSPENDED; + return OS_ECODE_NOERROR; + } + if(node->status & OS_STATUS_SUSPENDED){ + return OS_ECODE_TASKSUSPENDED; + } + if(node->status & OS_STATUS_STOPPED){ + return OS_ECODE_TASKSTOPPED; + } + if(node->status == OS_STATUS_DELETED){ + return OS_ECODE_TASKNOTSTARTED; + } + else{ + return OS_ECODE_DONOTKNOW; + } +} + +/* 恢复任务 */ +s_ecode_t st_resume_task(s_tasknode_tsp node) MCUCFG_C51USING +{ + if(node == NULL){ + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status & OS_STATUS_SUSPENDED){ + node->status &= (~OS_STATUS_SUSPENDED & 0xFF); + return OS_ECODE_NOERROR; + } + if(node->status < OS_STATUS_STOPPED){ + return OS_ECODE_TASKNOTSUSPENDED; + } + if(node->status & OS_STATUS_STOPPED){ + return OS_ECODE_TASKSTOPPED; + } + if(node->status == OS_STATUS_DELETED){ + return OS_ECODE_TASKNOTSTARTED; + } + else{ + return OS_ECODE_DONOTKNOW; + } +} + +/* 删除任务 */ +s_ecode_t st_delete_task(s_tasknode_tsp node) MCUCFG_C51USING +{ + if(node == NULL){ + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status < OS_STATUS_DELETED){ + node->status = OS_STATUS_DELETED; + return OS_ECODE_NOERROR; + } + if(node->status == OS_STATUS_DELETED){ + return OS_ECODE_TASKNOTSTARTED; + } + else{ + return OS_ECODE_DONOTKNOW; + } +} + +/* 设置任务优先级 */ +s_ecode_t st_set_taskpri(s_tasknode_tsp node, s_u8_t pri) MCUCFG_C51USING +{ + if(node == NULL){ + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status < OS_STATUS_STOPPED){ + if(node->pri != pri){ + node->pri = pri; + s_set_taskpri(node); + return OS_ECODE_NOERROR; + } + else{ + return OS_ECODE_TASKPRIUNCHANGED; + } + } + if(node->status & OS_STATUS_STOPPED){ + return OS_ECODE_TASKSTOPPED; + } + if(node->status == OS_STATUS_DELETED){ + return OS_ECODE_TASKNOTSTARTED; + } + else{ + return OS_ECODE_DONOTKNOW; + } +} + +/* 设置阻塞（时间）*/ +s_ecode_t st_set_block(s_tasknode_tsp node, s_delay_t tick) MCUCFG_C51USING +{ + if(node == NULL){ + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status == OS_STATUS_BLOCKED || node->status == OS_STATUS_FLOATING){ + s_delay_loader[node->tid] = tick; + if(!tick){ + node->status = OS_STATUS_READY; + } + return OS_ECODE_NOERROR; + } + return OS_ECODE_TASKNOTBLOCKED; +} + +/* 清除阻塞（状态）*/ +s_ecode_t st_clear_block(s_tasknode_tsp node) MCUCFG_C51USING +{ + if(node == NULL){ + return OS_ECODE_TASKNOTSTARTED; + } + if(node->status == OS_STATUS_BLOCKED || node->status == OS_STATUS_FLOATING){ + s_delay_loader[node->tid] = 0; + node->status = OS_STATUS_READY; + return OS_ECODE_NOERROR; + } + return OS_ECODE_TASKNOTBLOCKED; +} + + + +/* + * 二值信号量 + */ +#if SYSCFG_BINARY == __ENABLED__ +/* 获取 */ +s_bool_t st_take_binary(s_binary_tsp bin) MCUCFG_C51USING +{ + if(bin->binary){ + bin->binary = false; + return true; + } + return false; +} + +#endif + + + +/* + * 计数信号量 + */ +#if SYSCFG_SEMAPHORE == __ENABLED__ +/* 获取 */ +s_bool_t st_take_semaphore(s_semaph_tsp sem) MCUCFG_C51USING +{ + if(sem->counter){ + (sem->counter)--; + return true; + } + return false; +} + +/* 给予/归还 */ +void st_give_semaphore(s_semaph_tsp sem) MCUCFG_C51USING +{ + if(sem->counter < sem->maximum){ + sem->counter++; + } +} + +#endif + + + +/* + * 飞信 + */ +#if SYSCFG_FETION == __ENABLED__ +/* 接收飞信 */ +m_fetion_t st_recv_fetion(s_fetion_tsp fet) MCUCFG_C51USING +{ + m_fetion_t fetion = fet->fetion; + fet->fetion = false; + return fetion; +} + +#endif + + + +/* + * 消息邮箱 + */ +#if SYSCFG_MAILBOX == __ENABLED__ +/* 发送邮件 */ +void st_send_mail(s_mailbox_tsp gm, void *lm, size_t size) MCUCFG_C51USING +{ + static s_accessor_ts accessor; + accessor.gm = gm; + #if SYSCFG_MAILBOX_ACCESSMECHANISM == 1 + accessor.lm = lm; + accessor.lf = true; + #endif + sWrite_MBoxAccessor(&accessor); + s_memcpy(&gm->mail0, lm, size); + sWrite_MBoxAccessor(NULL); + #if SYSCFG_MAILBOX_ACCESSMECHANISM == 0 + gm->gf = true; + #elif SYSCFG_MAILBOX_ACCESSMECHANISM == 1 + gm->gf = accessor.lf; + #endif +} + +#endif + + + +/* + * 消息队列 + */ +#if SYSCFG_MSGQUEUE == __ENABLED__ +/* 接收消息 */ +void *st_recv_msg(s_msgqueue_tsp queue) MCUCFG_C51USING +{ + void *msg = NULL; + s_msgnode_tsp node; + queue->mutex = false; + if(!queue->counter); + else if(queue->type == __DYNAMIC__){ + sRecvMsg_Dynamic(msg); + } + else{ + sRecvMsg_Static(msg); + } + queue->mutex = true; + return msg; +} + +/* 发送消息 */ +s_ecode_t st_send_msg(s_msgqueue_tsp queue, void *msg) MCUCFG_C51USING +{ + queue->mutex = false; + if(queue->counter == queue->len){ + queue->mutex = true; + #if SYSCFG_DEBUGGING == __ENABLED__ + s_alarm.overflow_msgqueue = true; + #endif + return OS_ECODE_OVERFLOW_MSGQUEUE; + } + if(queue->type == __DYNAMIC__){ + s_msgnode_tsp node = NULL; + node = (s_msgnode_tsp)s_malloc(sizeof(s_msgnode_ts)); + if(node == NULL){ + queue->mutex = true; + #if SYSCFG_DEBUGGING == __ENABLED__ + s_fault.mallocfailed_msgnode = true; + #endif + return OS_ECODE_MALLOCFAIL_MSGNODE; + } + sSendMsg_Dynamic(msg); + } + else{ + sSendMsg_Static(msg); + } + queue->mutex = true; + return OS_ECODE_NOERROR; +} + +#endif diff --git a/System/sv_tick.h b/System/sv_tick.h new file mode 100644 index 0000000..2033b6f --- /dev/null +++ b/System/sv_tick.h @@ -0,0 +1,197 @@ +/**************************************************************************//** + * @item CosyOS-II Kernel + * @file sv_tick.h + * @brief 滴答服务（仅在滴答钩子、定时中断钩子、定时查询钩子中调用） + * @author 迟凯峰 + * @version V2.0.0 + * @date 2024.03.17 + ******************************************************************************/ + +#ifndef __SV_TICK_H +#define __SV_TICK_H + +s_ecode_t st_suspend_task (s_tasknode_tsp node); +s_ecode_t st_resume_task (s_tasknode_tsp node); +s_ecode_t st_delete_task (s_tasknode_tsp node); +s_ecode_t st_set_taskpri (s_tasknode_tsp node, s_u8_t pri); +s_ecode_t st_set_block (s_tasknode_tsp node, s_delay_t tick); +s_ecode_t st_clear_block (s_tasknode_tsp node); +s_bool_t st_take_binary (s_binary_tsp bin); +s_bool_t st_take_semaphore (s_semaph_tsp sem); +void st_give_semaphore (s_semaph_tsp sem); +m_fetion_t st_recv_fetion (s_fetion_tsp fet); +void st_send_mail (s_mailbox_tsp gm, void *lm, size_t size); +void *st_recv_msg (s_msgqueue_tsp queue); +s_ecode_t st_send_msg (s_msgqueue_tsp queue, void *msg); + + + +/* + * 任务 + */ + +/* 挂起指定任务 */ +#define sTSV_SuspendTask(node) \ + st_suspend_task(node) + +/* 恢复指定任务 */ +#define sTSV_ResumeTask(node) \ + st_resume_task(node) + +/* 删除指定任务 */ +#define sTSV_DeleteTask(node) \ + st_delete_task(node) + +/* 设置任务优先级 */ +#define sTSV_SetTaskPri(node, tpl) \ + st_set_taskpri(node, tpl) + +/* 设置阻塞（时间）*/ +#define sTSV_SetBlock(node, tc) \ + st_set_block(node, tc) + +/* 清除阻塞（状态）*/ +#define sTSV_ClearBlock(node) \ + st_clear_block(node) + + + +/* + * 定时 + */ + +/* 定时中断 */ +#define sTSV_TimInt(tmid, tc) \ + s_timint_loader[tmid] = s_timint_reload[tmid] = tc + +/* 定时查询 */ +#define sTSV_TimQry(tmid, tc) \ + s_timqry_loader[tmid] = s_timqry_reload[tmid] = tc + + + +/* + * 二值信号量 + */ + +/* 获取 */ +#define sTSV_TakeBin(bin) \ + st_take_binary(&bin) + + + +/* + * 计数信号量 + */ + +/* 获取 */ +#define sTSV_TakeSem(sem) \ + st_take_semaphore(&sem) + +/* 给予 */ +#define sTSV_GiveSem(sem) \ + st_give_semaphore(&sem) + +/* 归还 */ +#define sTSV_BackSem(sem) \ + st_give_semaphore(&sem) + + + +/* + * 私信 + */ + +/* 发送私信 */ +#define sTSV_SendTaskMsg(task) \ + s_sign_send_taskmsg = true; \ + MCUCFG_TASKMSG_PSP; \ + task(MCUCFG_TASKMSG_VAL, + + + +/* + * 飞信 + */ + +/* 接收飞信 */ +#define sTSV_RecvFetion(tbox) \ + st_recv_fetion(&tbox) + + + +/* + * 消息邮箱 + */ + +/* 接收邮件 */ +#define sTSV_RecvMail(mail, mbox) \ +( \ + mbox.gf \ + ? s_memcpy(mail, &mbox.mail0, sizeof(mbox.mail0)) || true \ + ? mbox.gf-- \ + : mbox.gf-- \ + : false \ +) + +/* 发送邮件 */ +#define sTSV_SendMail(mbox, mail) \ + st_send_mail((s_mailbox_tsp)&mbox, mail, sizeof(mbox.mail0)) + + + +/* + * 消息队列 + */ + +/* 接收消息 */ +#define sTSV_RecvMsg(que) \ + st_recv_msg(que) + +/* 发送消息 */ +#define sTSV_SendMsg(que, msg) \ + st_send_msg(que, msg) + + + +/* + * 事件标志组 + */ + +/* 查询标志组 */ +#define sTSV_QueryFlagGroup(group) \ +( \ + sizeof(group) == 1 ? *(s_u8_t *)&group ? true : false \ + : sizeof(group) == 2 ? *(s_u16_t *)&group ? true : false \ + : sizeof(group) == 4 ? *(s_u32_t *)&group ? true : false \ + : false \ +) + +/* 清除标志组 */ +#define sTSV_ClearFlagGroup(group) \ +do{ \ + sizeof(group) == 1 ? *(s_u8_t *)&group = false : OS_NOPx1; \ + sizeof(group) == 2 ? *(s_u16_t *)&group = false : OS_NOPx1; \ + sizeof(group) == 4 ? *(s_u32_t *)&group = false : OS_NOPx1; \ +}while(false) + + + +/* + * 软件RTC + */ + +/* 获取时间 */ +#define sTSV_GetTime(t) \ + s_memcpy(t, s_rtc[0], sizeof(s_rtc[0])) + +/* 设置时间 */ +#define sTSV_SetTime(t) \ +do{ \ + s_memcpy(s_rtc[0], t, sizeof(s_rtc[0])); \ + tUpdateCopy(s_memcpy(s_rtc[1], s_rtc[0], sizeof(s_rtc[0]))); \ +}while(false) + + + +#endif diff --git a/System/ur_api.h b/System/ur_api.h new file mode 100644 index 0000000..b347a06 --- /dev/null +++ b/System/ur_api.h @@ -0,0 +1,698 @@ +/**************************************************************************//** + * @item CosyOS-II Kernel + * @file ur_api.h + * @brief 用户API（创建API、任务API、滴答API、中断API、公共API） + * @author 迟凯峰 + * @version V2.0.0 + * @date 2024.03.17 + ******************************************************************************/ + +#ifndef __UR_API_H +#define __UR_API_H + + + +/* + * 声明任务 + */ + +/* 无私信 */ +#define uExternTask(task) \ + sCSV_ExternTask(task) + +#define dExternTask(task) \ + dCSV_ExternTask(task) + +/* 有私信 */ +#define uExternTask_Msg(task) \ + sCSV_ExternTask_Msg(task) /**< \taskmsg\params ...) >*/ + +#define dExternTask_Msg(task) \ + dCSV_ExternTask_Msg(task) /**< \taskmsg\params ...) >*/ + + + +/* + * 创建任务 + */ + +/* 创建一般任务 */ +#define uCreateTask(task, pri, tss, srt, ntm) \ + sCSV_CreateTask(task, pri, tss, srt, ntm) /**[ \taskmsg\params (...) ]*//**< \taskcode {...} >*/ + +#define dCreateTask(task, pri, tss, srt, ntm) \ + dCSV_CreateTask(task, pri, tss, srt, ntm) /**[ \taskmsg\params (...) ]*//**< \taskcode {...} >*/ + +/* 创建定时中断任务 */ +#define uCreateTask_TimInt(tmid, arl, task, pri, tss, srt, ntm) \ + sCSV_CreateTask_TimInt(tmid, arl, task, pri, tss, srt, ntm) /**[ \taskmsg\params (...) ]*//**< \taskcode {...} >*/ + +#define dCreateTask_TimInt(tmid, arl, task, pri, tss, srt, ntm) \ + dCSV_CreateTask_TimInt(tmid, arl, task, pri, tss, srt, ntm) /**[ \taskmsg\params (...) ]*//**< \taskcode {...} >*/ + +/* 创建定时查询任务 */ +#define uCreateTask_TimQry(tmid, event, arl, task, pri, tss, srt, ntm) \ + sCSV_CreateTask_TimQry(tmid, event, arl, task, pri, tss, srt, ntm) /**[ \taskmsg\params (...) ]*//**< \taskcode {...} >*/ + +#define dCreateTask_TimQry(tmid, event, arl, task, pri, tss, srt, ntm) \ + dCSV_CreateTask_TimQry(tmid, event, arl, task, pri, tss, srt, ntm) /**[ \taskmsg\params (...) ]*//**< \taskcode {...} >*/ + + + +/* + * 创建钩子 + */ + +/* 创建定时中断钩子 */ +#define uCreateHook_TimInt(tmid, arl, hook) \ + sCSV_CreateHook_TimInt(tmid, arl, hook) /**< \hookcode {...} >*/ + +/* 创建定时查询钩子 */ +#define uCreateHook_TimQry(tmid, event, arl, hook) \ + sCSV_CreateHook_TimQry(tmid, event, arl, hook) /**< \hookcode {...} >*/ + + + +/* + * 启动任务 + */ + +/* 启动任务 */ +#define uStartTask(task, status) sUSV_StartTask(&u_taskhand_##task, status) /** \return ecode */ + +/* 启动任务并就绪 */ +#define uStartTask_Ready(task) sUSV_StartTask(&u_taskhand_##task, OS_STATUS_READY) /** \return ecode */ + +/* 启动任务并挂起 */ +#define uStartTask_Suspend(task) sUSV_StartTask(&u_taskhand_##task, OS_STATUS_SUSPENDED) /** \return ecode */ + + + +/* + * 操作任务 + */ + +/* 恢复任务 */ +#define uResumeTask(task) sUSV_ResumeTask(u_taskhandle_##task) /** \return ecode */ +#define tResumeTask(task) sTSV_ResumeTask(u_taskhandle_##task) /** \return ecode */ +#define iResumeTask(task) sPSV_ResumeTask(u_taskhandle_##task) + +/* 挂起任务 */ +#define uSuspendTask(task) sUSV_SuspendTask(u_taskhandle_##task) /** \return ecode */ +#define tSuspendTask(task) sTSV_SuspendTask(u_taskhandle_##task) /** \return ecode */ +#define iSuspendTask(task) sPSV_SuspendTask(u_taskhandle_##task) + +/* 删除任务 */ +#define uDeleteTask(task) sUSV_DeleteTask(u_taskhandle_##task) /** \return ecode */ +#define tDeleteTask(task) sTSV_DeleteTask(u_taskhandle_##task) /** \return ecode */ +#define iDeleteTask(task) sPSV_DeleteTask(u_taskhandle_##task) + +/* 设置任务优先级 */ +#define uSetTaskPri(task, pri) sUSV_SetTaskPri(u_taskhandle_##task, pri) /** \return ecode */ +#define tSetTaskPri(task, pri) sTSV_SetTaskPri(u_taskhandle_##task, pri) /** \return ecode */ +#define iSetTaskPri(task, pri) sPSV_SetTaskPri(u_taskhandle_##task, pri) + + + +/* + * 操作自身任务 + */ + +/* 设置自身任务优先级 */ +#define uSetTaskingPri(pri) sUSV_SetTaskPri(s_task_current, pri) /** \return ecode */ + +/* 挂起自身任务 */ +#define uSuspendTasking sUSV_SuspendTask(s_task_current) /** \return ecode */ + +/* 删除自身任务 */ +#define uDeleteTasking sUSV_DeleteTask(s_task_current) /** \return ecode */ + +/* 恢复指定任务并挂起自身任务 */ +#define uResumeSuspend(task) sUSV_ResumeSuspend(u_taskhandle_##task) /** \return ecode */ + +/* 结束自身任务 */ +#define uEndTasking }while(true) + + + +/* + * 设置阻塞（时间） + */ + +/* 滴答周期 */ +#define uSetBlock_tc(task, tc) sUSV_SetBlock(u_taskhandle_##task, tc) /** \return ecode */ +#define tSetBlock_tc(task, tc) sTSV_SetBlock(u_taskhandle_##task, tc) /** \return ecode */ +#define iSetBlock_tc(task, tc) sPSV_SetBlock(u_taskhandle_##task, tc) + +/* 毫秒 */ +#define uSetBlock_ms(task, ms) uSetBlock_tc(task, (1000UL * ms) / SYSCFG_SYSTICKCYCLE) /** \return ecode */ +#define tSetBlock_ms(task, ms) tSetBlock_tc(task, (1000UL * ms) / SYSCFG_SYSTICKCYCLE) /** \return ecode */ +#define iSetBlock_ms(task, ms) iSetBlock_tc(task, (1000UL * ms) / SYSCFG_SYSTICKCYCLE) + +/* 秒钟 */ +#define uSetBlock_s(task, s) uSetBlock_ms(task, 1000UL * s) /** \return ecode */ +#define tSetBlock_s(task, s) tSetBlock_ms(task, 1000UL * s) /** \return ecode */ +#define iSetBlock_s(task, s) iSetBlock_ms(task, 1000UL * s) + +/* 分钟 */ +#define uSetBlock_m(task, m) uSetBlock_s(task, 60UL * m) /** \return ecode */ +#define tSetBlock_m(task, m) tSetBlock_s(task, 60UL * m) /** \return ecode */ +#define iSetBlock_m(task, m) iSetBlock_s(task, 60UL * m) + +/* 小时 */ +#define uSetBlock_h(task, h) uSetBlock_m(task, 60UL * h) /** \return ecode */ +#define tSetBlock_h(task, h) tSetBlock_m(task, 60UL * h) /** \return ecode */ +#define iSetBlock_h(task, h) iSetBlock_m(task, 60UL * h) + + + +/* + * 清除阻塞（状态） + */ + +#define uClearBlock(task) sUSV_ClearBlock(u_taskhandle_##task) /** \return ecode */ +#define tClearBlock(task) sTSV_ClearBlock(u_taskhandle_##task) /** \return ecode */ +#define iClearBlock(task) sPSV_ClearBlock(u_taskhandle_##task) + + + +/* + * 自身任务延时 + */ + +/* 延时滴答周期 */ +#define uDelay_tc(tc) sUSV_Delay(tc) + +/* 延时毫秒 */ +#define uDelay_ms(ms) uDelay_tc((1000UL * ms) / SYSCFG_SYSTICKCYCLE) + +/* 延时秒钟 */ +#define uDelay_s(s) uDelay_ms(1000UL * s) + +/* 延时分钟 */ +#define uDelay_m(m) uDelay_s(60UL * m) + +/* 延时小时 */ +#define uDelay_h(h) uDelay_m(60UL * h) + + + +/* + * 定时中断 + */ + +/* 定时中断滴答周期 */ +#define uTimInt_tc(tmid, tc) sUSV_TimInt(tmid, tc) +#define tTimInt_tc(tmid, tc) sTSV_TimInt(tmid, tc) +#define iTimInt_tc(tmid, tc) sPSV_TimInt(tmid, tc) + +/* 定时中断毫秒 */ +#define uTimInt_ms(tmid, ms) uTimInt_tc(tmid, (1000UL * ms) / SYSCFG_SYSTICKCYCLE) +#define tTimInt_ms(tmid, ms) tTimInt_tc(tmid, (1000UL * ms) / SYSCFG_SYSTICKCYCLE) +#define iTimInt_ms(tmid, ms) iTimInt_tc(tmid, (1000UL * ms) / SYSCFG_SYSTICKCYCLE) + +/* 定时中断秒钟 */ +#define uTimInt_s(tmid, s) uTimInt_ms(tmid, 1000UL * s) +#define tTimInt_s(tmid, s) tTimInt_ms(tmid, 1000UL * s) +#define iTimInt_s(tmid, s) iTimInt_ms(tmid, 1000UL * s) + +/* 定时中断分钟 */ +#define uTimInt_m(tmid, m) uTimInt_s(tmid, 60UL * m) +#define tTimInt_m(tmid, m) tTimInt_s(tmid, 60UL * m) +#define iTimInt_m(tmid, m) iTimInt_s(tmid, 60UL * m) + +/* 定时中断小时 */ +#define uTimInt_h(tmid, h) uTimInt_m(tmid, 60UL * h) +#define tTimInt_h(tmid, h) tTimInt_m(tmid, 60UL * h) +#define iTimInt_h(tmid, h) iTimInt_m(tmid, 60UL * h) + +/* 定时中断定时器自动重装载 */ +#define xTimInt_AutoReload(tmid, arl) s_timint_autoreload[tmid] = arl + + + +/* + * 定时查询 + */ + +/* 定时查询滴答周期 */ +#define uTimQry_tc(tmid, tc) sUSV_TimQry(tmid, tc) +#define tTimQry_tc(tmid, tc) sTSV_TimQry(tmid, tc) +#define iTimQry_tc(tmid, tc) sPSV_TimQry(tmid, tc) + +/* 定时查询毫秒 */ +#define uTimQry_ms(tmid, ms) uTimQry_tc(tmid, (1000UL * ms) / SYSCFG_SYSTICKCYCLE) +#define tTimQry_ms(tmid, ms) tTimQry_tc(tmid, (1000UL * ms) / SYSCFG_SYSTICKCYCLE) +#define iTimQry_ms(tmid, ms) iTimQry_tc(tmid, (1000UL * ms) / SYSCFG_SYSTICKCYCLE) + +/* 定时查询秒钟 */ +#define uTimQry_s(tmid, s) uTimQry_ms(tmid, 1000UL * s) +#define tTimQry_s(tmid, s) tTimQry_ms(tmid, 1000UL * s) +#define iTimQry_s(tmid, s) iTimQry_ms(tmid, 1000UL * s) + +/* 定时查询分钟 */ +#define uTimQry_m(tmid, m) uTimQry_s(tmid, 60UL * m) +#define tTimQry_m(tmid, m) tTimQry_s(tmid, 60UL * m) +#define iTimQry_m(tmid, m) iTimQry_s(tmid, 60UL * m) + +/* 定时查询小时 */ +#define uTimQry_h(tmid, h) uTimQry_m(tmid, 60UL * h) +#define tTimQry_h(tmid, h) tTimQry_m(tmid, 60UL * h) +#define iTimQry_h(tmid, h) iTimQry_m(tmid, 60UL * h) + +/* 定时查询定时器自动重装载 */ +#define xTimQry_AutoReload(tmid, arl) s_timqry_autoreload[tmid] = arl + + + +/* + * 互斥信号量 + */ + +/* 声明 */ +#define uExternMut(mut) \ + sCSV_ExternMut(mut) + +/* 创建 */ +#define uCreateMut(mut) \ + sCSV_CreateMut(mut) + +/* 获取 */ +#define uTakeMut(mut, tc) sUSV_TakeMut(mut, tc) /** \return result */ + +/* 归还 */ +#define uBackMut(mut) sUSV_BackMut(mut) + + + +/* + * 二值信号量 + */ + +/* 声明 */ +#define uExternBin(bin) \ + sCSV_ExternBin(bin) + +/* 创建 */ +#define uCreateBin(bin, init) \ + sCSV_CreateBin(bin, init) + +/* 上锁 */ +#define uLockBin(bin) bin.binary = false +#define tLockBin(bin) bin.binary = false +#define iLockBin(bin) sPSV_WriteBin(bin, false) + +/* 等待 */ +#define uWaitBin(bin, tc) sUSV_WaitBin(bin, tc) /** \return result */ + +/* 给予 */ +#define uGiveBin(bin) sUSV_GiveBin(bin) +#define tGiveBin(bin) bin.binary = true +#define iGiveBin(bin) sPSV_WriteBin(bin, true) + +/* 获取 */ +#define uTakeBin(bin, tc) sUSV_TakeBin(bin, tc) /** \return result */ +#define tTakeBin(bin) sTSV_TakeBin(bin) /** \return result */ +#define iTakeBin(bin) sISV_TakeBin(bin) /** \return result */ + +/* 归还 */ +#define uBackBin(bin) bin.binary = true +#define tBackBin(bin) bin.binary = true +#define iBackBin(bin) bin.binary = true + + + +/* + * 计数信号量 + */ + +/* 声明 */ +#define uExternSem(sem) \ + sCSV_ExternSem(sem) + +/* 创建 */ +#define uCreateSem(sem, init, max) \ + sCSV_CreateSem(sem, init, max) + +/* 给予 */ +#define uGiveSem(sem) sUSV_GiveSem(sem) +#define tGiveSem(sem) sTSV_GiveSem(sem) +#define iGiveSem(sem) sPSV_GiveSem(sem) + +/* 获取 */ +#define uTakeSem(sem, tc) sUSV_TakeSem(sem, tc) /** \return result */ +#define tTakeSem(sem) sTSV_TakeSem(sem) /** \return result */ + +/* 归还 */ +#define uBackSem(sem) sUSV_BackSem(sem) +#define tBackSem(sem) sTSV_BackSem(sem) + + + +/* + * 私信 + */ + +/* 接收私信 */ +#define uRecvTaskMsg(tc) sUSV_RecvTaskMsg(tc) /** \return result */ + +/* 发送私信 */ +#define uSendTaskMsg(task) sUSV_SendTaskMsg(task) /**< \taskmsg\params ...) >*/ +#define tSendTaskMsg(task) sTSV_SendTaskMsg(task) /**< \taskmsg\params ...) >*/ + +/* API简化 */ +#define uRecvTM uRecvTaskMsg +#define uSendTM uSendTaskMsg +#define tSendTM tSendTaskMsg + + + +/* + * 飞信 + */ + +/* 声明信箱 */ +#define uExternFetion(tbox) \ + sCSV_ExternFetion(tbox) + +/* 创建信箱 */ +#define uCreateFetion(tbox) \ + sCSV_CreateFetion(tbox) + +/* 接收飞信 */ +#define uRecvFetion(tbox, tc) sUSV_RecvFetion(tbox, tc) /** \return fetion */ +#define tRecvFetion(tbox) sTSV_RecvFetion(tbox) /** \return fetion */ +#define iRecvFetion(tbox) sISV_RecvFetion(tbox) /** \return fetion */ + +/* 发送飞信 */ +#define uSendFetion(tbox, tion) sUSV_SendFetion(tbox, tion) +#define tSendFetion(tbox, tion) tbox.fetion = tion +#define iSendFetion(tbox, tion) sPSV_SendFetion(tbox, tion) + +/* API简化 */ +#define uRecvFet uRecvFetion +#define tRecvFet tRecvFetion +#define iRecvFet iRecvFetion +#define uSendFet uSendFetion +#define tSendFet tSendFetion +#define iSendFet iSendFetion + + + +/* + * 消息邮箱 + */ + +/* 声明邮箱 */ +#define uExternMailbox(mbox, type) \ + sCSV_ExternMailbox(mbox, type) + +/* 创建邮箱 */ +#define uCreateMailbox(mbox) \ + sCSV_CreateMailbox(mbox) + +/* 接收邮件 */ +#define uRecvMail(mail, mbox, tc) sUSV_RecvMail(mail, mbox, tc) /** \return result */ +#define tRecvMail(mail, mbox) sTSV_RecvMail(mail, mbox) /** \return result */ +#define iRecvMail(mail, mbox) sISV_RecvMail(mail, mbox) /** \return result */ + +/* 发送邮件 */ +#define uSendMail(mbox, mail) sUSV_SendMail(mbox, mail) +#define tSendMail(mbox, mail) sTSV_SendMail(mbox, mail) +#define iSendMail(mbox, mail) sPSV_SendMail(mbox, mail) + + + +/* + * 消息队列 + */ + +/* 声明静态消息队列 */ +#define uExternMsgQueue_Static(que) \ + sCSV_ExternMsgQueue_Static(que) + +/* 声明动态消息队列 */ +#define uExternMsgQueue_Dynamic(que) \ + sCSV_ExternMsgQueue_Dynamic(que) + +/* 创建静态消息队列 */ +#define uCreateMsgQueue_Static(que, mode, len) \ + sCSV_CreateMsgQueue_Static(que, mode, len) + +/* 创建动态消息队列 */ +#define uCreateMsgQueue_Dynamic(que, mode, len) \ + sCSV_CreateMsgQueue_Dynamic(que, mode, len) + +/* 接收消息 */ +#define uRecvMsg(que, tc) sUSV_RecvMsg((s_msgqueue_tsp)&que, tc) /** \return ptr */ +#define tRecvMsg(que) sTSV_RecvMsg((s_msgqueue_tsp)&que) /** \return ptr */ +#define iRecvMsg(que) sISV_RecvMsg((s_msgqueue_tsp)&que) /** \return ptr */ + +/* 发送消息 */ +#define uSendMsg(que, msg) sUSV_SendMsg((s_msgqueue_tsp)&que, msg) /** \return ecode */ +#define tSendMsg(que, msg) sTSV_SendMsg((s_msgqueue_tsp)&que, msg) /** \return ecode */ +#define iSendMsg(que, msg) sPSV_SendMsg((s_msgqueue_tsp)&que, msg) + + + +/* + * 事件标志组 + */ + +/* 声明标志组 */ +#define uExternFlagGroup(group, bits) \ + sCSV_ExternFlagGroup(group, bits) + +/* 定义标志位 */ +#define uDefFlagBit(bit) sDefBitField(bit) + +/* 定义空位 */ +#define uDefVoidBits(nvb) sDefVoidBits(nvb) + +/* 创建标志组 */ +#define uCreateFlagGroup(group) \ + sCSV_CreateFlagGroup(group) /**[ \init = {...} ]*/ + +/* 等待标志组 */ +#define uWaitFlagGroup(group, tc) sUSV_WaitFlagGroup(group, tc) /** \return result */ + +/* 查询标志组 */ +#define uQueryFlagGroup(group) sUSV_QueryFlagGroup(group) /** \return result */ +#define tQueryFlagGroup(group) sTSV_QueryFlagGroup(group) /** \return result */ +#define iQueryFlagGroup(group) sISV_QueryFlagGroup(group) /** \return result */ + +/* 清除标志组 */ +#define uClearFlagGroup(group) sUSV_ClearFlagGroup(group) +#define tClearFlagGroup(group) sTSV_ClearFlagGroup(group) +#define iClearFlagGroup(group) sPSV_ClearFlagGroup(group) + +/* 查询标志位（任务、滴答、中断中，均直接查询）*/ + +/* 设置标志位（滴答中直接设置，任务中也可在任务临界区中设置）*/ +#define uSetFlagBit(group, bit) sUSV_WriteFlagBit(group, bit, true) +#define iSetFlagBit(group, bit) iSetFlagBits(group, 1) bit) + +/* 清除标志位（滴答中直接清除，任务中也可在任务临界区中清除）*/ +#define uClearFlagBit(group, bit) sUSV_WriteFlagBit(group, bit, false) +#define iClearFlagBit(group, bit) iClearFlagBits(group, 1) bit) + +/* 设置多标志位（滴答中直接设置，任务中在任务临界区中设置）*/ +#define iSetFlagBits(group, nbit) sPSV_WriteFlagBits(group, +, nbit) /**< \bits ...) >*/ + +/* 清除多标志位（滴答中直接清除，任务中在任务临界区中清除）*/ +#define iClearFlagBits(group, nbit) sPSV_WriteFlagBits(group, -, nbit) /**< \bits ...) >*/ + + + +/* + * 全局变量访问 + */ + +/* 更新全局变量副本 */ +#define uUpdateCopy(code) sUpdateCopy(code) +#define tUpdateCopy(code) sUpdateCopy(code) + +/* 读哪一个全局变量？（返回0读正本，返回1读副本）*/ +#define iWhichGVarToRead !s_sign_updatecopy /** \return bool */ + +/* 写全局变量 */ +#define iWriteGVar(gv, lv) sPSV_WriteGVar((void *)&gv, (void *)&lv, sizeof(gv)) + +/* 写全局数组 */ +#define iWriteGAry(gp, lp, size) sPSV_WriteGVar(gp, lp, size) + +/* 写全局字符串 */ +#define iWriteGStr(gs, ls) sPSV_WriteGVar(gs, ls, 0) + +/* 挂起服务调用 */ +#define iPendSVC(fp) sPSV_PendSVC(fp) + +/* 发送信号 */ +#define iSendSign(sign) sPSV_SendSign(sign) + + + +/* + * 软件RTC + */ + +/* 获取时间 */ +#define uGetTime(t) sUSV_GetTime(t) /** \return t */ +#define tGetTime(t) sTSV_GetTime(t) /** \return t */ +#define iGetTime(t) sISV_GetTime(t) /** \return t */ + +/* 设置时间 */ +#define uSetTime(t) sUSV_SetTime(t) +#define tSetTime(t) sTSV_SetTime(t) +#define iSetTime(t) sPSV_SetTime(t) + + + +/* + * 进程内存 + */ + +/* malloc */ +#define uMalloc(size) sUSV_Malloc(size) /** \return ptr */ + +/* calloc */ +#define uCalloc(nmemb, size) sUSV_Calloc(nmemb, size) /** \return ptr */ + +/* realloc */ +#define uRealloc(p, size) sUSV_Realloc(p, size) /** \return ptr */ + +/* free */ +#define uFree(p) sUSV_Free(p) + + + +/* + * 线程内存 + */ + +/* 创建线程内存池 */ +#define uCreateMempool sCSV_CreateMempool + +/* 初始化线程内存池 */ +#define uInitMempool(size) sUSV_InitMempool(size) /** \return result */ + +/* 线程内存分配 */ +#define uTalloc(size) sUSV_Talloc(size) /** \return ptr */ + +/* 释放线程内存池 */ +#define uFreeMempool sUSV_FreeMempool + + + +/* + * DEBUG + */ + +#define iDebugSend iTimQry_ms(OS_TMID_DEBUGHOOK, 30) +#define iDebugRecv iTimInt_ms(OS_TMID_DEBUGGER, 15) + +#if false +/* 应用示例 - 8051/80251 UART1 */ +void UART1_Isr(void) interrupt 4 +{ + if(TI){ + TI = 0; + if(*s_debug_sendptr){ + SBUF = *s_debug_sendptr++; + } + else{ + iDebugSend; + } + } + if(RI){ + RI = 0; + if(s_debug_recvptr - s_debug_recvbuff < OS_DEBUGRECVBUFFSIZE - 1){ + *s_debug_recvptr++ = SBUF; + } + iDebugRecv; + } +} + +/* 应用示例 - STM32 USART1 */ +void USART1_IRQHandler(void) +{ + if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET){ + if(*s_debug_sendptr){ + USART_SendData(USART1, *s_debug_sendptr++); + } + else{ + USART_ITConfig(USART1, USART_IT_TXE, DISABLE); + iDebugSend; + } + } + if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET){ + if(s_debug_recvptr - s_debug_recvbuff < OS_DEBUGRECVBUFFSIZE - 1){ + *s_debug_recvptr++ = USART_ReceiveData(USART1); + } + iDebugRecv; + } +} + +#endif + + + +/* + * 任务调度 + * 由用户手动触发的临时性的任务调度 + */ + +/* 无条件任务调度 */ +#define uTaskScheduling sUSV_TaskScheduling +#define iTaskScheduling sISV_TaskScheduling + +/* 任务优先级调度 */ +#define uTaskPriScheduling(task) sUSV_TaskPriScheduling(u_taskhandle_##task) +#define iTaskPriScheduling(task) sISV_TaskPriScheduling(u_taskhandle_##task) + + + +/* + * 任务临界区 + * 任务级的临界区保护，仅关闭SysTick、PendSV，仅支持在任务中调用。 + */ + +/* 进入临界区 */ +#define uEnterCritical su_enter_critical() + +/* 退出临界区 */ +#define uExitCritical su_exit_critical() + + + +/* + * 全局临界区 + * 系统级的临界区保护，通常会关闭总中断，支持在任意处调用。 + * CosyOS内核中从来不会进入全局临界区，提供此项服务只是为了便于用户对全局公共资源和程序过程的保护。 + */ + +/* [ARM] */#if MCUCFG_ISA == __ARM__ + +/* 方法一：操作PRIMASK */ +#define xDisableIRQ mxDisableIRQ /* 进入全局临界区 *//** \return oldirq */ +#define xResumeIRQ(oldirq) mxResumeIRQ(oldirq) /* 退出全局临界区 */ + +/* 方法二：操作FAULTMASK */ +#define xDisableFIQ mxDisableFIQ /* 进入全局临界区 *//** \return oldfiq */ +#define xResumeFIQ(oldfiq) mxResumeFIQ(oldfiq) /* 退出全局临界区 */ + +/* 方法三：操作BASEPRI */ +#define xMaskingPRI(newpri) mxMaskingPRI(newpri) /* 进入全局临界区 *//** \return oldpri */ +#define xResumePRI(oldpri) mxResumePRI(oldpri) /* 退出全局临界区 */ + +/* [!ARM] */#else + +/* 操作EA */ +#define xDisableIRQ mxDisableIRQ /* 进入全局临界区 */ +#define xResumeIRQ mxResumeIRQ /* 退出全局临界区 */ + +#endif + + + +#endif