mirror of
https://github.com/QuantumLeaps/qpcpp.git
synced 2025-02-04 06:13:00 +08:00
281 lines
11 KiB
C
281 lines
11 KiB
C
/*
|
|
*********************************************************************************************************
|
|
* uC/OS-II
|
|
* The Real-Time Kernel
|
|
*
|
|
* Copyright 1992-2020 Silicon Laboratories Inc. www.silabs.com
|
|
*
|
|
* SPDX-License-Identifier: APACHE-2.0
|
|
*
|
|
* This software is subject to an open source license and is distributed by
|
|
* Silicon Laboratories Inc. pursuant to the terms of the Apache License,
|
|
* Version 2.0 available at www.apache.org/licenses/LICENSE-2.0.
|
|
*
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
*
|
|
* TIME MANAGEMENT
|
|
*
|
|
* Filename : os_time.c
|
|
* Version : V2.93.00
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#ifndef OS_TIME_C
|
|
#define OS_TIME_C
|
|
|
|
#define MICRIUM_SOURCE
|
|
|
|
#ifndef OS_MASTER_FILE
|
|
#include <ucos_ii.h>
|
|
#endif
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DELAY TASK 'n' TICKS
|
|
*
|
|
* Description: This function is called to delay execution of the currently running task until the
|
|
* specified number of system ticks expires. This, of course, directly equates to delaying
|
|
* the current task for some time to expire. No delay will result If the specified delay is
|
|
* 0. If the specified delay is greater than 0 then, a context switch will result.
|
|
*
|
|
* Arguments : ticks is the time delay that the task will be suspended in number of clock 'ticks'.
|
|
* Note that by specifying 0, the task will not be delayed.
|
|
*
|
|
* Returns : none
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
void OSTimeDly (INT32U ticks)
|
|
{
|
|
INT8U y;
|
|
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
|
|
OS_CPU_SR cpu_sr = 0u;
|
|
#endif
|
|
|
|
|
|
|
|
if (OSIntNesting > 0u) { /* See if trying to call from an ISR */
|
|
return;
|
|
}
|
|
if (OSLockNesting > 0u) { /* See if called with scheduler locked */
|
|
return;
|
|
}
|
|
if (ticks > 0u) { /* 0 means no delay! */
|
|
OS_ENTER_CRITICAL();
|
|
y = OSTCBCur->OSTCBY; /* Delay current task */
|
|
OSRdyTbl[y] &= (OS_PRIO)~OSTCBCur->OSTCBBitX;
|
|
OS_TRACE_TASK_SUSPENDED(OSTCBCur);
|
|
if (OSRdyTbl[y] == 0u) {
|
|
OSRdyGrp &= (OS_PRIO)~OSTCBCur->OSTCBBitY;
|
|
}
|
|
OSTCBCur->OSTCBDly = ticks; /* Load ticks in TCB */
|
|
OS_TRACE_TASK_DLY(ticks);
|
|
OS_EXIT_CRITICAL();
|
|
OS_Sched(); /* Find next task to run! */
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DELAY TASK FOR SPECIFIED TIME
|
|
*
|
|
* Description: This function is called to delay execution of the currently running task until some time
|
|
* expires. This call allows you to specify the delay time in HOURS, MINUTES, SECONDS and
|
|
* MILLISECONDS instead of ticks.
|
|
*
|
|
* Arguments : hours specifies the number of hours that the task will be delayed (max. is 255)
|
|
* minutes specifies the number of minutes (max. 59)
|
|
* seconds specifies the number of seconds (max. 59)
|
|
* ms specifies the number of milliseconds (max. 999)
|
|
*
|
|
* Returns : OS_ERR_NONE
|
|
* OS_ERR_TIME_INVALID_MINUTES
|
|
* OS_ERR_TIME_INVALID_SECONDS
|
|
* OS_ERR_TIME_INVALID_MS
|
|
* OS_ERR_TIME_ZERO_DLY
|
|
* OS_ERR_TIME_DLY_ISR
|
|
*
|
|
* Note(s) : The resolution on the milliseconds depends on the tick rate. For example, you can't do
|
|
* a 10 mS delay if the ticker interrupts every 100 mS. In this case, the delay would be
|
|
* set to 0. The actual delay is rounded to the nearest tick.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#if OS_TIME_DLY_HMSM_EN > 0u
|
|
INT8U OSTimeDlyHMSM (INT8U hours,
|
|
INT8U minutes,
|
|
INT8U seconds,
|
|
INT16U ms)
|
|
{
|
|
INT32U ticks;
|
|
|
|
|
|
if (OSIntNesting > 0u) { /* See if trying to call from an ISR */
|
|
return (OS_ERR_TIME_DLY_ISR);
|
|
}
|
|
if (OSLockNesting > 0u) { /* See if called with scheduler locked */
|
|
return (OS_ERR_SCHED_LOCKED);
|
|
}
|
|
#if OS_ARG_CHK_EN > 0u
|
|
if (hours == 0u) {
|
|
if (minutes == 0u) {
|
|
if (seconds == 0u) {
|
|
if (ms == 0u) {
|
|
return (OS_ERR_TIME_ZERO_DLY);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (minutes > 59u) {
|
|
return (OS_ERR_TIME_INVALID_MINUTES); /* Validate arguments to be within range */
|
|
}
|
|
if (seconds > 59u) {
|
|
return (OS_ERR_TIME_INVALID_SECONDS);
|
|
}
|
|
if (ms > 999u) {
|
|
return (OS_ERR_TIME_INVALID_MS);
|
|
}
|
|
#endif
|
|
/* Compute the total number of clock ticks required.. */
|
|
/* .. (rounded to the nearest tick) */
|
|
ticks = ((INT32U)hours * 3600uL + (INT32U)minutes * 60uL + (INT32U)seconds) * OS_TICKS_PER_SEC
|
|
+ OS_TICKS_PER_SEC * ((INT32U)ms + 500uL / OS_TICKS_PER_SEC) / 1000uL;
|
|
OSTimeDly(ticks);
|
|
return (OS_ERR_NONE);
|
|
}
|
|
#endif
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* RESUME A DELAYED TASK
|
|
*
|
|
* Description: This function is used resume a task that has been delayed through a call to either
|
|
* OSTimeDly() or OSTimeDlyHMSM(). Note that you can call this function to resume a
|
|
* task that is waiting for an event with timeout. This would make the task look
|
|
* like a timeout occurred.
|
|
*
|
|
* Arguments : prio specifies the priority of the task to resume
|
|
*
|
|
* Returns : OS_ERR_NONE Task has been resumed
|
|
* OS_ERR_PRIO_INVALID if the priority you specify is higher that the maximum allowed
|
|
* (i.e. >= OS_LOWEST_PRIO)
|
|
* OS_ERR_TIME_NOT_DLY Task is not waiting for time to expire
|
|
* OS_ERR_TASK_NOT_EXIST The desired task has not been created or has been assigned to a Mutex.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#if OS_TIME_DLY_RESUME_EN > 0u
|
|
INT8U OSTimeDlyResume (INT8U prio)
|
|
{
|
|
OS_TCB *ptcb;
|
|
#if OS_CRITICAL_METHOD == 3u /* Storage for CPU status register */
|
|
OS_CPU_SR cpu_sr = 0u;
|
|
#endif
|
|
|
|
|
|
|
|
if (prio >= OS_LOWEST_PRIO) {
|
|
return (OS_ERR_PRIO_INVALID);
|
|
}
|
|
OS_ENTER_CRITICAL();
|
|
ptcb = OSTCBPrioTbl[prio]; /* Make sure that task exist */
|
|
if (ptcb == (OS_TCB *)0) {
|
|
OS_EXIT_CRITICAL();
|
|
return (OS_ERR_TASK_NOT_EXIST); /* The task does not exist */
|
|
}
|
|
if (ptcb == OS_TCB_RESERVED) {
|
|
OS_EXIT_CRITICAL();
|
|
return (OS_ERR_TASK_NOT_EXIST); /* The task does not exist */
|
|
}
|
|
if (ptcb->OSTCBDly == 0u) { /* See if task is delayed */
|
|
OS_EXIT_CRITICAL();
|
|
return (OS_ERR_TIME_NOT_DLY); /* Indicate that task was not delayed */
|
|
}
|
|
|
|
ptcb->OSTCBDly = 0u; /* Clear the time delay */
|
|
if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {
|
|
ptcb->OSTCBStat &= ~OS_STAT_PEND_ANY; /* Yes, Clear status flag */
|
|
ptcb->OSTCBStatPend = OS_STAT_PEND_TO; /* Indicate PEND timeout */
|
|
} else {
|
|
ptcb->OSTCBStatPend = OS_STAT_PEND_OK;
|
|
}
|
|
if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) { /* Is task suspended? */
|
|
OSRdyGrp |= ptcb->OSTCBBitY; /* No, Make ready */
|
|
OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
|
|
OS_TRACE_TASK_READY(ptcb);
|
|
OS_EXIT_CRITICAL();
|
|
OS_Sched(); /* See if this is new highest priority */
|
|
} else {
|
|
OS_EXIT_CRITICAL(); /* Task may be suspended */
|
|
}
|
|
return (OS_ERR_NONE);
|
|
}
|
|
#endif
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* GET CURRENT SYSTEM TIME
|
|
*
|
|
* Description: This function is used by your application to obtain the current value of the 32-bit
|
|
* counter which keeps track of the number of clock ticks.
|
|
*
|
|
* Arguments : none
|
|
*
|
|
* Returns : The current value of OSTime
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#if OS_TIME_GET_SET_EN > 0u
|
|
INT32U OSTimeGet (void)
|
|
{
|
|
INT32U ticks;
|
|
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
|
|
OS_CPU_SR cpu_sr = 0u;
|
|
#endif
|
|
|
|
|
|
|
|
OS_ENTER_CRITICAL();
|
|
ticks = OSTime;
|
|
OS_EXIT_CRITICAL();
|
|
return (ticks);
|
|
}
|
|
#endif
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* SET SYSTEM CLOCK
|
|
*
|
|
* Description: This function sets the 32-bit counter which keeps track of the number of clock ticks.
|
|
*
|
|
* Arguments : ticks specifies the new value that OSTime needs to take.
|
|
*
|
|
* Returns : none
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#if OS_TIME_GET_SET_EN > 0u
|
|
void OSTimeSet (INT32U ticks)
|
|
{
|
|
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
|
|
OS_CPU_SR cpu_sr = 0u;
|
|
#endif
|
|
|
|
|
|
|
|
OS_ENTER_CRITICAL();
|
|
OSTime = ticks;
|
|
OS_EXIT_CRITICAL();
|
|
}
|
|
#endif
|
|
#endif /* OS_TIME_C */
|