Mirrors_Framework/cosyos
1
0
Fork 0
mirror of https://gitee.com/cosyos/cosyos.git synced 2026-02-06 03:41:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

update CosyOS内核文件.

Browse Source 
Signed-off-by: 零中断延迟的RTOS <cosyos@139.com>
This commit is contained in:
零中断延迟的RTOS
2024-03-17 12:44:11 +00:00
committed by Gitee
parent 64f2cbc20c
commit 3262c4666a
7 changed files with 2959 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

289
System/sv_int_pend.c Normal file
View File

@@ -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_
};

230
System/sv_int_pend.h Normal file
View File

@@ -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

844
System/sv_task.c Normal file
View File

File diff suppressed because it is too large Load Diff

419
System/sv_task.h Normal file
View File

@@ -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

282
System/sv_tick.c Normal file
View File

@@ -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

197
System/sv_tick.h Normal file
View File

@@ -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

698
System/ur_api.h Normal file
View File

File diff suppressed because it is too large Load Diff