📄 mycore.c
字号:
}
#else
while (*pchk-- == 0) {
free++;
}
#endif
dataptr->OSFree = free * sizeof(OS_STK); /* Compute number of free bytes on the stack */
dataptr->OSUsed = (size - free) * sizeof(OS_STK); /* Compute number of bytes used on the stack */
return (OS_NO_ERR);
}
#endif
/***********************************OSTaskSuspend*******************************************************/
#if OS_TASK_SUSPEND_EN
INT8U OSTaskSuspend (INT8U prio)reentrant
{
BOOLEAN self;
OS_TCB *ptcb;
if (prio == OS_IDLE_PRIO) { /* Not allowed to suspend idle task */
return (OS_TASK_SUSPEND_IDLE);
}
if (prio >= OS_LOWEST_PRIO && prio != OS_PRIO_SELF) { /* Task priority valid ? */
return (OS_PRIO_INVALID);
}
OS_ENTER_CRITICAL();
if (prio == OS_PRIO_SELF) { /* See if suspend SELF */
prio = OSTCBCur->OSTCBPrio;
self = TRUE;
} else if (prio == OSTCBCur->OSTCBPrio) { /* See if suspending self */
self = TRUE;
} else {
self = FALSE; /* No suspending another task */
}
if ((ptcb = OSTCBPrioTbl[prio]) == (OS_TCB *)0) { /* Task to suspend must exist */
OS_EXIT_CRITICAL();
return (OS_TASK_SUSPEND_PRIO);
} else {
if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) { /* Make task not ready */
OSRdyGrp &= ~ptcb->OSTCBBitY;
}
ptcb->OSTCBStat |= OS_STAT_SUSPEND; /* Status of task is 'SUSPENDED' */
OS_EXIT_CRITICAL();
if (self == TRUE) { /* Context switch only if SELF */
OSSched();
}
return (OS_NO_ERR);
}
}
#endif
/*************************************OS_Task_Query_EN**************************************************/
#if OS_Task_Query_EN
INT8U OSTaskQuery (INT8U prio, OS_TCB *dataptr)reentrant
{
OS_TCB *ptcb;
if (prio > OS_LOWEST_PRIO && prio != OS_PRIO_SELF) { /* Task priority valid ? */
return (OS_PRIO_INVALID);
}
OS_ENTER_CRITICAL();
if (prio == OS_PRIO_SELF) { /* See if suspend SELF */
prio = OSTCBCur->OSTCBPrio;
}
if ((ptcb = OSTCBPrioTbl[prio]) == (OS_TCB *)0) { /* Task to query must exist */
OS_EXIT_CRITICAL();
return (OS_PRIO_ERR);
}
*dataptr = *ptcb; /* Copy TCB into user storage area */
OS_EXIT_CRITICAL();
return (OS_NO_ERR);
}
#endif
/*********************************OS_TASK.C END*********************************************************/
/*******************************************************************************************************/
/*********************************OS_TIME.C*************************************************************/
/*************************************OS_Time_Dly_EN****************************************************/
#if OS_Time_Dly_EN
void OSTimeDly (INT16U ticks)reentrant
{
if (ticks > 0) { /* 0 means no delay! */
OS_ENTER_CRITICAL();
if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) { /* Delay current task */
OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
}
OSTCBCur->OSTCBDly = ticks; /* Load ticks in TCB */
OS_EXIT_CRITICAL();
OSSched(); /* Find next task to run! */
}
}
#endif
/***************************************OS_Time_DlyHMSM_EN*********************************************/
#if OS_Time_DlyHMSM_EN
INT8U OSTimeDlyHMSM (INT8U hours, INT8U minutes, INT8U seconds, INT16U milli)reentrant
{
INT32U ticks;
INT16U loops;
if (hours > 0 || minutes > 0 || seconds > 0 || milli > 0) {
if (minutes > 59) {
return (OS_TIME_INVALID_MINUTES); /* Validate arguments to be within range */
}
if (seconds > 59) {
return (OS_TIME_INVALID_SECONDS);
}
if (milli > 999) {
return (OS_TIME_INVALID_MILLI);
}
/* Compute the total number of clock ticks required.. */
/* .. (rounded to the nearest tick) */
ticks = ((INT32U)hours * 3600L + (INT32U)minutes * 60L + (INT32U)seconds) * OS_TICKS_PER_SEC
+ OS_TICKS_PER_SEC * ((INT32U)milli + 500L / OS_TICKS_PER_SEC) / 1000L;
loops = ticks / 65536L; /* Compute the integral number of 65536 tick delays */
ticks = ticks % 65536L; /* Obtain the fractional number of ticks */
OSTimeDly(ticks);
while (loops > 0) {
OSTimeDly(32768);
OSTimeDly(32768);
loops--;
}
return (OS_NO_ERR);
} else {
return (OS_TIME_ZERO_DLY);
}
}
#endif
/***************************************OS_Time_DlyResume_EN*******************************************/
#if OS_Time_DlyResume_EN
INT8U OSTimeDlyResume (INT8U prio)reentrant
{
OS_TCB *ptcb;
if (prio >= OS_LOWEST_PRIO) {
return (OS_PRIO_INVALID);
}
OS_ENTER_CRITICAL();
ptcb = (OS_TCB *)OSTCBPrioTbl[prio]; /* Make sure that task exist */
if (ptcb != (OS_TCB *)0) {
if (ptcb->OSTCBDly != 0) { /* See if task is delayed */
ptcb->OSTCBDly = 0; /* Clear the time delay */
if (!(ptcb->OSTCBStat & OS_STAT_SUSPEND)) { /* See if task is ready to run */
OSRdyGrp |= ptcb->OSTCBBitY; /* Make task ready to run */
OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
OS_EXIT_CRITICAL();
OSSched(); /* See if this is new highest priority */
} else {
OS_EXIT_CRITICAL(); /* Task may be suspended */
}
return (OS_NO_ERR);
} else {
OS_EXIT_CRITICAL();
return (OS_TIME_NOT_DLY); /* Indicate that task was not delayed */
}
} else {
OS_EXIT_CRITICAL();
return (OS_TASK_NOT_EXIST); /* The task does not exist */
}
}
#endif
/***************************************OS_Time_Get_EN**************************************************/
#if OS_Time_Get_EN
INT32U OSTimeGet (void)reentrant
{
INT32U ticks;
OS_ENTER_CRITICAL();
ticks = OSTime;
OS_EXIT_CRITICAL();
return (ticks);
}
#endif
/********************************************OS_Time_Set_EN********************************************/
#if OS_Time_Set_EN
void OSTimeSet (INT32U ticks)reentrant
{
OS_ENTER_CRITICAL();
OSTime = ticks;
OS_EXIT_CRITICAL();
}
#endif
/******************************************OS_TIME.C END***********************************************/
/******************************************************************************************************/
/******************************************OS_MEM.C*****************************************************/
#if OS_MEM_EN && OS_MAX_MEM_PART >= 2
/*********************************************************************************************************
* LOCAL GLOBAL VARIABLES
*********************************************************************************************************/
static OS_MEM *OSMemFreeList; /* Pointer to free list of memory partitions */
static OS_MEM OSMemTbl[OS_MAX_MEM_PART];/* Storage for memory partition manager */
/****************************************OSMemCreate****************************************************/
OS_MEM *OSMemCreate (void *addr, INT32U nblks, INT32U blksize, INT8U *err)reentrant
{
OS_MEM *pmem;
INT8U *pblk;
void **plink;
INT32U i;
if (nblks < 2) { /* Must have at least 2 blocks per partition */
*err = OS_MEM_INVALID_BLKS;
return ((OS_MEM *)0);
}
if (blksize < sizeof(void *)) { /* Must contain space for at least a pointer */
*err = OS_MEM_INVALID_SIZE;
return ((OS_MEM *)0);
}
OS_ENTER_CRITICAL();
pmem = OSMemFreeList; /* Get next free memory partition */
if (OSMemFreeList != (OS_MEM *)0) { /* See if pool of free partitions was empty */
OSMemFreeList = (OS_MEM *)OSMemFreeList->OSMemFreeList;
}
OS_EXIT_CRITICAL();
if (pmem == (OS_MEM *)0) { /* See if we have a memory partition */
*err = OS_MEM_INVALID_PART;
return ((OS_MEM *)0);
}
plink = (void **)addr; /* Create linked list of free memory blocks */
pblk = (INT8U *)addr + blksize;
for (i = 0; i < (nblks - 1); i++) {
*plink = (void *)pblk;
plink = (void **)pblk;
pblk = pblk + blksize;
}
*plink = (void *)0; /* Last memory block points to NULL */
OS_ENTER_CRITICAL();
pmem->OSMemAddr = addr; /* Store start address of memory partition */
pmem->OSMemFreeList = addr; /* Initialize pointer to pool of free blocks */
pmem->OSMemNFree = nblks; /* Store number of free blocks in MCB */
pmem->OSMemNBlks = nblks;
pmem->OSMemBlkSize = blksize; /* Store block size of each memory blocks */
OS_EXIT_CRITICAL();
*err = OS_NO_ERR;
return (pmem);
}
/***************************************OSMemGet********************************************************/
void *OSMemGet (OS_MEM *pmem, INT8U *err)reentrant
{
void *pblk;
OS_ENTER_CRITICAL();
if (pmem->OSMemNFree > 0) { /* See if there are any free memory blocks */
pblk = pmem->OSMemFreeList; /* Yes, point to next free memory block */
pmem->OSMemFreeList = *(void **)pblk; /* Adjust pointer to new free list */
pmem->OSMemNFree--; /* One less memory block in this partition */
OS_EXIT_CRITICAL();
*err = OS_NO_ERR; /* No error */
return (pblk); /* Return memory block to caller */
} else {
OS_EXIT_CRITICAL();
*err = OS_MEM_NO_FREE_BLKS; /* No, Notify caller of empty memory partition */
return ((void *)0); /* Return NULL pointer to caller */
}
}
/*********************************************OSMemInit*************************************************/
void OSMemInit (void)reentrant
{
OS_MEM *pmem;
INT16U i;
pmem = (OS_MEM *)&OSMemTbl[0]; /* Point to memory control block (MCB) */
for (i = 0; i < (OS_MAX_MEM_PART - 1); i++) { /* Init. list of free memory partitions */
pmem->OSMemFreeList = (void *)&OSMemTbl[i+1]; /* Chain list of free partitions */
pmem->OSMemAddr = (void *)0; /* Store start address of memory partition */
pmem->OSMemNFree = 0; /* No free blocks */
pmem->OSMemNBlks = 0; /* No blocks */
pmem->OSMemBlkSize = 0; /* Zero size */
pmem++;
}
OSMemTbl[OS_MAX_MEM_PART - 1].OSMemFreeList = (void *)0;
OSMemFreeList = (OS_MEM *)&OSMemTbl[0];
}
INT8U OSMemPut (OS_MEM *pmem, void *pblk)reentrant
{
OS_ENTER_CRITICAL();
if (pmem->OSMemNFree >= pmem->OSMemNBlks) { /* Make su⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -