Mirrors_Framework/cosyos
1
0
Fork 0
mirror of https://gitee.com/cosyos/cosyos.git synced 2026-03-24 14:12:29 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
32ec5ff04ebcb240a2d5e5b21b0df9dbe1e8a671
cosyos/System/os_handler.c
零中断延迟的RTOS 32ec5ff04e update 内核文件. 
Signed-off-by: 零中断延迟的RTOS <cosyos@139.com>
2026-03-01 09:05:14 +00:00

689 lines
18 KiB
C
Raw Blame History

/**************************************************************************//**
* @item CosyOS-III Kernel
* @file os_handler.c
* @brief tCosyTick_Handler and sPendSV_Handler
* @author 迟凯峰
* @version V2.3.1
* @date 2026.03.01
******************************************************************************/
#include "os_var.h"
#include "os_api.h"
#include "sv_com.h"
#include "sv_create.h"
#include "sv_tick.h"
#include "ur_api.h"
#include "ur_eapi.h"
#if defined ( __ICCARM__ )
#define __IAR_WEAK __WEAK
#else
#define __IAR_WEAK
#endif
#if defined ( __GNUC__ )
#define sKill_W(p) p
#else
#define sKill_W(p)
#endif
sCat2Str(SYSCFG_STARTERCREATE, ExternTask(Starter));
#if (SYSCFG_DEBUGGING == __ENABLED__)
__IAR_WEAK s_u32_t usedtime[2]/**/sZeroInstall_Group;
__IAR_WEAK m_stacklen_t _SYS_MEM_ s_taskstacklen;
#endif
__IAR_WEAK void tCosyTick_Handler(void) MCUCFG_SYSTICK_ATTRIBUTE
{
#if (OS_TIMINTTOTAL > 0 || OS_TIMQRYTOTAL > 0)
s_u8_t _SYS_REG_ i;
#endif
#if (SYSCFG_SYSTICKTIME_COUNT == __ENABLED__)
m_tick_t ticktemp_s sKill_W(=0);
#endif
s_tasknode_tsp _SYS_REG_ htask;
/* 清除中断标志位 */
mSysTick_Clear();
if(s_task_current == OS_NULL) return;
/* 系统滴答开始时刻 */// 此刻定义为系统滴答开始时刻 for 系统滴答时间统计。
#if (SYSCFG_SYSTICKTIME_COUNT == __ENABLED__)
if(s_taskmgr_sign){
ticktemp_s = MCUCFG_SYSTICK_CURRVALUE;
}
#endif
/* 软件RTC */
#if (SYSCFG_SOFTRTC == __ENABLED__)
#define counter s_rtc_counter
if(true){
if(counter < 1000000UL / SYSCFG_SYSTICK_CYCLE - 1){
counter++;
if(counter == 1000000UL / SYSCFG_SYSTICK_CYCLE / 2){
s_sign_every.halfsec = true;
}
}
else{
counter = 0;
s_sign_every.halfsec = true;
s_sign_every.second = true;
if(s_rtc.second < 59) s_rtc.second++;
else{
s_rtc.second = 0;
s_sign_every.minute = true;
if(s_rtc.minute < 59) s_rtc.minute++;
else{
s_rtc.minute = 0;
s_sign_every.hour = true;
if(s_rtc.hour < 23) s_rtc.hour++;
else{
s_rtc.hour = 0;
s_sign_every.day = true;
if(s_rtc.day < 7) s_rtc.day++;
else s_rtc.day = 1;
if(s_rtc.date < (s_rtc.month == 2 ? s_month2day : s_month0day[s_rtc.month])) s_rtc.date++;
else{
s_rtc.date = 1;
s_sign_every.month = true;
if(s_rtc.month < 12) s_rtc.month++;
else{
s_rtc.month = 1;
s_sign_every.year = true;
if(s_rtc.year < 99) s_rtc.year++;
else{
s_rtc.year = 0;
s_rtc.yeah++;
}
}
}
}
}
}
}
}
#undef counter
#endif
/* 运行时间统计 */
#if (SYSCFG_RUNTIME_COUNT == __ENABLED__)
if(true){
static m_rtccount_t _SYS_MEM_ counter = 0;
if(counter < 1000000UL / SYSCFG_SYSTICK_CYCLE - 1){
counter++;
}
else{
counter = 0;
if(s_runtime.second < 59) s_runtime.second++;
else{
s_runtime.second = 0;
if(s_runtime.minute < 59) s_runtime.minute++;
else{
s_runtime.minute = 0;
if(s_runtime.hour < 23) s_runtime.hour++;
else{
s_runtime.hour = 0;
s_runtime.day++;
}
}
}
}
}
#endif
/* 滴答钩子 */
#if (SYSCFG_TICKHOOK == __ENABLED__)
if(true){
void tick_hook(void);
tick_hook();
}
#endif
/* 任务管理器 */
#if (SYSCFG_DEBUGGING == __ENABLED__)
if(s_debug_recvlen){
void os_debug_recv(void);
os_debug_recv();
s_debug_recvlen = 0;
}
if(s_debug_sendsign){
s_debug_sendsign = false;
tTimQry_ms(OS_TMID_DEBUGGER, 10);
}
#endif
/* 定时中断 */
#if (OS_TIMINTTOTAL > 0)
i = OS_TIMINTTOTAL;
while(i--){
if(s_timint_handle[i]->timer){
s_timint_handle[i]->timer--;
if(!s_timint_handle[i]->timer){
if(s_timint_handle[i]->autoreload){
s_timint_handle[i]->timer = s_timint_handle[i]->reload;
}
if(s_timint_handle[i]->hookortask){
sResumeTask_TimInt(i);
}
else{
sCallHook_TimInt(i);
}
}
}
}
#endif
/* 定时查询 */
#if (OS_TIMQRYTOTAL > 0)
i = OS_TIMQRYTOTAL;
while(i--){
if(s_timqry_handle[i]->timer && s_timqry_handle[i]->timer < (s_timqry_t)~0){
s_timqry_handle[i]->timer--;
}
if(!s_timqry_handle[i]->timer){
if((*s_timqry_handle[i]->event)()){
if(s_timqry_handle[i]->autoreload){
s_timqry_handle[i]->timer = s_timqry_handle[i]->reload;
}
else{
s_timqry_handle[i]->timer = ~0;
}
if(s_timqry_handle[i]->hookortask){
sResumeTask_TimQry(i);
}
else{
sCallHook_TimQry(i);
}
}
}
}
#endif
/* 任务定时器 */// 定时器链表中的任务状态：就绪、浮动、阻塞、挂起。
if(true){
s_timer_pointer = (s_timer_pointer + 1) & (OS_TIMESLOTNUM - 1UL);
htask = s_timer_list[s_timer_pointer];
if(htask != OS_NULL){
bool loop_sign = true;
s_tasknode_tsp _SYS_REG_ hnext sKill_W(=OS_NULL);
s_tasknode_tsp _SYS_REG_ htail = htask->last_t;
__TIMER_LOOP:
if(htask == htail){
loop_sign = false;
}
else{
hnext = htask->next_t;
}
if(htask->status < OS_STATUS_SUSPENDED){
if( htask->timer.cycle){
htask->timer.cycle--;
}
else if(htask->status == OS_STATUS_READY){
sa_remove_timerlist(htask);
s_sign_delay = false;
}
else{
sa_clear_block(htask);
}
}
if(loop_sign){
htask = hnext;
goto __TIMER_LOOP;
}
}
}
/* 时间片 */
#if (SYSCFG_SAMEPRISCHEDULE == __TIMESHARING__)
if(s_task_current->tc_counter < OS_TIMESHARING(s_task_current)){
s_task_current->tc_counter++;
}
else{
s_sign_schedule.every[1] = false;
}
#endif
/* 安全运行时 */// 超时链表中的任务状态：超时、超时|挂起、停止、删除。
#if (SYSCFG_SAFERUNTIME == __ENABLED__)
if(!s_timeout_sign){
htask = s_timeout_list;
while(htask != OS_VOID){
if(htask->status == OS_STATUS_TIMEOUT){
htask->srt_counter = 0;
sa_add_ready(htask);
htask->status = OS_STATUS_READY;
}
else if(htask->status & OS_STATUS_SUSPENDED){
htask->srt_counter = 0;
htask->status = OS_STATUS_READY | OS_STATUS_SUSPENDED;
}
else if(htask->status == OS_STATUS_DELETED){
if(htask->create){
sa_free_task(htask);
}
}
s_timeout_list = htask->next_o;
htask->next_o = OS_NULL;
htask = s_timeout_list;
}
}
htask = s_task_current;
if(htask->pri && htask->saferuntime){
htask->srt_counter++;
if(htask->srt_counter > htask->saferuntime){
if(htask->status == OS_STATUS_READY){
htask->next_o = s_timeout_list;
s_timeout_list = htask;
sa_remove_ready(htask);
htask->status = OS_STATUS_TIMEOUT;
s_timeout_sign = true;
#if (SYSCFG_DEBUGGING == __ENABLED__)
s_alarm.timeout_saferuntime = true;
#endif
}
}
}
#endif
/* 任务管理器 */
#if (SYSCFG_DEBUGGING == __ENABLED__)
if(s_taskmgr_sign){
/* CPU使用时间计数 */
usedtime[0]++;
s_taskmgr_upspeed++;
/* 系统滴答时间统计 */// 此刻定义为系统滴答结束时刻。
#if (SYSCFG_SYSTICKTIME_COUNT == __ENABLED__)
if(true){
m_tick_t ticktemp_e = MCUCFG_SYSTICK_CURRVALUE;
#if (MCUCFG_SYSTICK_COUNTMODE == 1 || MCUCFG_SYSTICK_COUNTMODE == 3)
if(ticktemp_e > ticktemp_s){
s_tick_count1 += ticktemp_e - ticktemp_s;
}
#elif (MCUCFG_SYSTICK_COUNTMODE == 2 || MCUCFG_SYSTICK_COUNTMODE == 4)
if(ticktemp_s > ticktemp_e){
s_tick_count1 += ticktemp_s - ticktemp_e;
}
#endif
s_tick_count2++;
}
#endif
}
#endif
/* 触发PendSV */
#if (SYSCFG_DEBUGGING == __ENABLED__)
if(true){
mPendSV_Set();
}
#else
if(!s_sign_schedule.total){
mPendSV_Set();
}
#endif
}
#if (SYSCFG_DEBUGGING == __ENABLED__)
__IAR_WEAK void _cpu_usedtime_(m_tick_t ticktemp_0) MCUCFG_OSIT_ATTRIBUTE
{
#if (MCUCFG_SYSTICK_COUNTMODE == 1 || MCUCFG_SYSTICK_COUNTMODE == 3)
if(usedtime[0]){
s_task_current->usedtime[0] += usedtime[0] - 1;
usedtime[0] = 0;
usedtime[1] = (MCUCFG_SYSTICK_MAXVALUE - usedtime[1]) + (ticktemp_0 - MCUCFG_SYSTICK_MINVALUE);
}
else if(ticktemp_0 < usedtime[1]){
usedtime[0] = ~0;
usedtime[1] = (MCUCFG_SYSTICK_MAXVALUE - usedtime[1]) + (ticktemp_0 - MCUCFG_SYSTICK_MINVALUE);
}
else{
usedtime[1] = (ticktemp_0 - usedtime[1]);
}
#elif (MCUCFG_SYSTICK_COUNTMODE == 2 || MCUCFG_SYSTICK_COUNTMODE == 4)
if(usedtime[0]){
s_task_current->usedtime[0] += usedtime[0] - 1;
usedtime[0] = 0;
usedtime[1] = (usedtime[1] - MCUCFG_SYSTICK_MINVALUE) + (MCUCFG_SYSTICK_MAXVALUE - ticktemp_0);
}
else if(usedtime[1] < ticktemp_0){
usedtime[0] = ~0;
usedtime[1] = (usedtime[1] - MCUCFG_SYSTICK_MINVALUE) + (MCUCFG_SYSTICK_MAXVALUE - ticktemp_0);
}
else{
usedtime[1] = (usedtime[1] - ticktemp_0);
}
#endif
s_task_current->usedtime[0] += (s_task_current->usedtime[1] + usedtime[1]) / MCUCFG_SYSTICK_COUNT1CYC;
s_task_current->usedtime[1] = (s_task_current->usedtime[1] + usedtime[1]) % MCUCFG_SYSTICK_COUNT1CYC;
}
#endif
__IAR_WEAK void _float_to_ready_(s_tasknode_tsp htask) MCUCFG_OSIT_ATTRIBUTE
{
htask->status = OS_STATUS_READY;
// if(htask->next_b != OS_NULL){
sa_remove_blocklist(htask);
// }
if(htask->next_t != OS_NULL){
sa_remove_timerlist(htask);
}
}
__IAR_WEAK s_tasknode_tsp _SYS_MEM_ s_task_news/**/sZeroInstall;
__IAR_WEAK s_u8_t _start_task_(void) MCUCFG_OSIT_ATTRIBUTE
{
s_tasknode_tsp _SYS_REG_ node_news;
/* 静态创建 */
if(*s_task_starter->dualhandle != OS_NULL){
node_news = (s_tasknode_tsp)s_task_starter;
if(node_news->stacksize < MCUCFG_BASICSTACKSIZE){
#if (SYSCFG_DEBUGGING == __ENABLED__)
s_fault.failed_startuptask = true;
s_fault.overflow_taskstack = true;
#endif
s_startup_ecode = OS_ECODE_OVERFLOW_TASKSTACK;
goto __STARTUP_END;
}
else{
mTaskStack_INIT();
}
}
/* 动态创建 */
else{
node_news = OS_NULL;
node_news = (s_tasknode_tsp)s_malloc(sizeof(s_tasknode_ts));
if(node_news != OS_NULL){
node_news->stacksize = s_task_starter->stacksize;
if(node_news->stacksize < MCUCFG_BASICSTACKSIZE){
node_news->stacksize = MCUCFG_BASICSTACKSIZE;
node_news->create = 2;
}
else{
node_news->create = 1;
}
node_news->bsp = OS_NULL;
node_news->bsp = (s_u8_t _MALLOC_MEM_ *)s_malloc(node_news->stacksize);
if(node_news->bsp != OS_NULL){
mTaskStack_INIT();
node_news->opri = s_task_starter->opri;
node_news->dualhandle = s_task_starter->dualhandle;
*node_news->dualhandle = node_news;
node_news->entry = s_task_starter->entry;
#if (SYSCFG_DEBUGGING == __ENABLED__)
node_news->name = s_task_starter->name;
#endif
#if (SYSCFG_SAFERUNTIME == __ENABLED__)
node_news->saferuntime = s_task_starter->saferuntime;
#endif
}
else{
s_free(node_news);
#if (SYSCFG_DEBUGGING == __ENABLED__)
s_fault.failed_startuptask = true;
s_fault.mallocfailed_taskstack = true;
#endif
s_startup_ecode = OS_ECODE_MALLOCFAIL_TASKSTACK;
goto __STARTUP_END;
}
}
else{
#if (SYSCFG_DEBUGGING == __ENABLED__)
s_fault.failed_startuptask = true;
s_fault.mallocfailed_tasknode = true;
#endif
s_startup_ecode = OS_ECODE_MALLOCFAIL_TASKNODE;
goto __STARTUP_END;
}
}
/* 公共部分 */
if(node_news->opri <= (s_u8_t)(SYSCFG_TASKPRIORITY - 1)){
node_news->pri = node_news->opri;
}
else{
node_news->pri = SYSCFG_TASKPRIORITY - 1;
#if (SYSCFG_DEBUGGING == __ENABLED__)
s_alarm.outrange_taskpriority = true;
#endif
}
node_news->status = s_task_status0;
node_news->blocktype = 0;
node_news->timer.slots = 0;
node_news->timer.cycle = 0;
node_news->handle = OS_NULL;
#if (SYSCFG_SAMEPRISCHEDULE == __TIMESHARING__)
node_news->tc_counter = 0;
#endif
#if (SYSCFG_DEBUGGING == __ENABLED__)
node_news->usedtime[0] = 0;
node_news->usedtime[1] = 0;
node_news->stacklen_max = MCUCFG_BASICSTACKSIZE;
#endif
#if (SYSCFG_SAFERUNTIME == __ENABLED__)
node_news->srt_counter = 0;
node_news->next_o = OS_NULL;
#endif
node_news->last_b = OS_NULL;
node_news->next_b = OS_NULL;
node_news->last_t = OS_NULL;
node_news->next_t = OS_NULL;
#if (SYSCFG_SAMEPRISCHEDULE && SYSCFG_MUTEX == __ENABLED__)
node_news->link = OS_NULL;
#endif
sa_insert_taskque(node_news);
s_task_queue_count++;
if(s_task_status0 == OS_STATUS_READY){
sa_add_ready(node_news);
}
s_startup_ecode = OS_ECODE_NOERROR;
__STARTUP_END:
s_task_starter = OS_NULL;
if(node_news == Starter){
if(s_startup_ecode == OS_ECODE_NOERROR){
#if (SYSCFG_DEBUGGING == __ENABLED__)
if(s_taskmgr_sign){
usedtime[1] = MCUCFG_SYSTICK_CURRVALUE;
}
#endif
mUserReg_RESc();
s_task_news = Starter;
return 1;
}
else return 0;
}
else return 2;
}
void pendsv_hook(void);
#if (SYSCFG_MCUCORE == 80251)
#pragma functions(static)
#endif
__IAR_WEAK s_u8_t sPendSV_Handler(void) MCUCFG_OSIT_ATTRIBUTE
{
/* 中断FIFO服务 */
#if (MCUCFG_PENDSVFIFO_DEPTH > 0)
mPendSV_FIFOHandle();
#endif
/* 中断FLAG服务 */
#if (SYSCFG_PENDSVHOOK == __ENABLED__)
pendsv_hook();
#endif
/* 每监控（假定入栈）*/
#if (SYSCFG_DEBUGGING == __ENABLED__)
if(s_task_current != OS_NULL){
mTaskStack_LEN();
if(s_task_current->stacklen_max < s_taskstacklen){
s_task_current->stacklen_max = s_taskstacklen;
if(s_task_current->stacksize < s_taskstacklen){
s_alarm.overflow_taskstack = true;
}
}
}
#endif
/* 任务启动 */
if(!s_sign_startup){
s_sign_startup = true;
if(s_task_starter != OS_NULL){
s_u8_t r = _start_task_();
if(r < 2) return r;
}
}
/* 任务调度 */
if(s_sign_schedule.total) return 0;
else{
#if (SYSCFG_DEBUGGING == __ENABLED__)
m_tick_t _SYS_REG_ ticktemp_0 sKill_W(=0);
m_bit_t push_sign = false; /*!< 入栈信号 */
#else
#define push_sign true
#endif
s_u8_t _SYS_REG_ pri;
s_tasknode_tsp _SYS_REG_ node_news;
s_sign_schedule.every[1] = true;
/* 抢占式调度（选择就绪）*/
if(true){
#if (SYSCFG_TASKPRIORITY > 64)
s_u8_t table_index = s_task_pickmap[s_task_table_index >> (SYSCFG_TASKPICKBITMAP & 1)];
s_u8_t bytes_index = s_task_pickmap[s_task_bytes_index[table_index] >> (SYSCFG_TASKPICKBITMAP & 1)];
s_u8_t bit_index = s_task_pickmap[s_task_ready_table[table_index][bytes_index] >> (SYSCFG_TASKPICKBITMAP & 1)];
pri = (table_index << 6) + (bytes_index << 3) + bit_index;
#elif (SYSCFG_TASKPRIORITY > 8)
s_u8_t bytes_index = s_task_pickmap[s_task_bytes_index >> (SYSCFG_TASKPICKBITMAP & 1)];
s_u8_t bit_index = s_task_pickmap[s_task_ready_table[bytes_index] >> (SYSCFG_TASKPICKBITMAP & 1)];
pri = (bytes_index << 3) + bit_index;
#else
pri = s_task_pickmap[s_task_ready_table >> (SYSCFG_TASKPICKBITMAP & 1)];
#endif
node_news = s_task_queue[pri];
}
/* 协作式调度 */
#if (SYSCFG_SAMEPRISCHEDULE == __COOPERATIVE__)
while(true){
if(node_news->status <= OS_STATUS_FLOATING){
break;
}
node_news = node_news->next;
}
/* 时间片轮转调度 */
#elif (SYSCFG_SAMEPRISCHEDULE == __TIMESHARING__)
while(true){
s_tasknode_tsp _SYS_REG_ node_temp sKill_W(=OS_NULL);
if(node_news->status <= OS_STATUS_FLOATING){
if(node_news->tc_counter < OS_TIMESHARING(node_news)){ /* 时间片未到期 */
break;
}
else{ /* 时间片已到期 */
node_news->tc_counter = 0;
node_temp = node_news;
}
}
if(node_news != s_task_queue[pri]->last){
node_news = node_news->next;
}
else{ /* 在该优先级组中，未能找到时间片未到期的就绪任务，继续已到期的就绪任务 */
node_news = node_temp;
break;
}
}
#endif
/* 新任务为事件阻塞 */
if(node_news->blocktype){
node_news->blocktype = 0;
if(node_news->status == OS_STATUS_FLOATING){ /* 浮动变就绪 */
_float_to_ready_(node_news);
}
mSysIRQ_Disable(); /* 内核上锁 */// 使服务层临界区连续。
}
/* 新任务仍为当前任务 -> 返回 */
if(node_news == s_task_current){
return 0;
}
/* 新任务轮转至其优先级组首节点 */
#if (SYSCFG_SAMEPRISCHEDULE)
if(node_news != s_task_queue[pri]){
s_task_queue[pri] = node_news;
}
#endif
/* 入栈监控 */
#if (SYSCFG_DEBUGGING == __ENABLED__)
if(s_task_current->status < OS_STATUS_STOPPED){
if(s_task_current->stacksize < s_taskstacklen){
#if (MCUCFG_TASKSTACK_REALLOC == __ENABLED__)
if(s_task_current->create){
s_task_current->stacksize = s_taskstacklen + SYSCFG_TASKSTACK_REALLOCINC;
s_free(s_task_current->bsp);
s_task_current->bsp = OS_NULL;
s_task_current->bsp = (s_u8_t _MALLOC_MEM_ *)s_malloc(s_task_current->stacksize);
if(s_task_current->bsp != OS_NULL){
push_sign = true;
s_task_current->create = 2;
s_alarm.realloc_taskstack = true;
}
else{
sa_stop_task(s_task_current);
s_fault.reallocfailed_taskstack = true;
}
}
else{
sa_stop_task(s_task_current);
s_fault.overflow_taskstack = true;
}
#else
sa_stop_task(s_task_current);
s_fault.overflow_taskstack = true;
#endif
}
else{
push_sign = true;
}
}
#endif
/* 任务切换时刻 */// 此刻定义为任务切换时刻 for CPU使用率统计。
#if (SYSCFG_DEBUGGING == __ENABLED__)
if(s_taskmgr_sign){
ticktemp_0 = MCUCFG_SYSTICK_CURRVALUE;
}
#endif
/* 当前任务入栈-预处理 */
if(push_sign){
#if (SYSCFG_SAFERUNTIME == __ENABLED__)
if(s_task_current->pri > node_news->pri){
s_task_current->srt_counter = 0;
}
#endif
#if (SYSCFG_DEBUGGING == __ENABLED__)
if(s_taskmgr_sign){
_cpu_usedtime_(ticktemp_0);
}
#endif
mUserReg_SAVEc();
}
/* 新任务出栈-预处理 */
if(true){
#if (SYSCFG_DEBUGGING == __ENABLED__)
if(s_taskmgr_sign){
usedtime[1] = ticktemp_0;
}
#endif
mUserReg_RESc();
s_task_news = node_news;
}
return (s_u8_t)push_sign + 1;
}
}
Reference in New Issue View Git Blame Copy Permalink