mirror of
https://github.com/dimoniche/solarium.git
synced 2026-01-30 09:53:30 +03:00
269 lines
11 KiB
Plaintext
269 lines
11 KiB
Plaintext
/*
|
||
*********************************************************************************************************
|
||
* uC/OS-II
|
||
* The Real-Time Kernel
|
||
* TIME MANAGEMENT
|
||
*
|
||
* (c) Copyright 1992-2007, Jean J. Labrosse, Weston, FL
|
||
* All Rights Reserved
|
||
*
|
||
* File : OS_TIME.C
|
||
* By : Jean J. Labrosse
|
||
* Version : V2.85
|
||
*
|
||
* LICENSING TERMS:
|
||
* ---------------
|
||
* uC/OS-II is provided in source form for FREE evaluation, for educational use or for peaceful research.
|
||
* If you plan on using uC/OS-II in a commercial product you need to contact Micriµm to properly license
|
||
* its use in your product. We provide ALL the source code for your convenience and to help you experience
|
||
* uC/OS-II. The fact that the source is provided does NOT mean that you can use it without paying a
|
||
* licensing fee.
|
||
*********************************************************************************************************
|
||
*/
|
||
|
||
#ifndef OS_MASTER_FILE
|
||
#include <ucos_ii.h>
|
||
#endif
|
||
|
||
/*
|
||
*********************************************************************************************************
|
||
* DELAY TASK 'n' TICKS (n from 0 to 65535)
|
||
*
|
||
* 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 (INT16U ticks)
|
||
{
|
||
INT8U y;
|
||
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
|
||
OS_CPU_SR cpu_sr = 0;
|
||
#endif
|
||
|
||
|
||
|
||
if (OSIntNesting > 0) { /* See if trying to call from an ISR */
|
||
return;
|
||
}
|
||
if (ticks > 0) { /* 0 means no delay! */
|
||
OS_ENTER_CRITICAL();
|
||
y = OSTCBCur->OSTCBY; /* Delay current task */
|
||
OSRdyTbl[y] &= ~OSTCBCur->OSTCBBitX;
|
||
if (OSRdyTbl[y] == 0) {
|
||
OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
|
||
}
|
||
OSTCBCur->OSTCBDly = ticks; /* Load ticks in TCB */
|
||
OS_EXIT_CRITICAL();
|
||
OS_Sched(); /* Find next task to run! */
|
||
}
|
||
}
|
||
/*$PAGE*/
|
||
/*
|
||
*********************************************************************************************************
|
||
* 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)
|
||
* milli 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 > 0
|
||
INT8U OSTimeDlyHMSM (INT8U hours, INT8U minutes, INT8U seconds, INT16U ms)
|
||
{
|
||
INT32U ticks;
|
||
INT16U loops;
|
||
|
||
|
||
if (OSIntNesting > 0) { /* See if trying to call from an ISR */
|
||
return (OS_ERR_TIME_DLY_ISR);
|
||
}
|
||
#if OS_ARG_CHK_EN > 0
|
||
if (hours == 0) {
|
||
if (minutes == 0) {
|
||
if (seconds == 0) {
|
||
if (ms == 0) {
|
||
return (OS_ERR_TIME_ZERO_DLY);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (minutes > 59) {
|
||
return (OS_ERR_TIME_INVALID_MINUTES); /* Validate arguments to be within range */
|
||
}
|
||
if (seconds > 59) {
|
||
return (OS_ERR_TIME_INVALID_SECONDS);
|
||
}
|
||
if (ms > 999) {
|
||
return (OS_ERR_TIME_INVALID_MS);
|
||
}
|
||
#endif
|
||
/* 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)ms + 500L / OS_TICKS_PER_SEC) / 1000L;
|
||
loops = (INT16U)(ticks >> 16); /* Compute the integral number of 65536 tick delays */
|
||
ticks = ticks & 0xFFFFL; /* Obtain the fractional number of ticks */
|
||
OSTimeDly((INT16U)ticks);
|
||
while (loops > 0) {
|
||
OSTimeDly((INT16U)32768u);
|
||
OSTimeDly((INT16U)32768u);
|
||
loops--;
|
||
}
|
||
return (OS_ERR_NONE);
|
||
}
|
||
#endif
|
||
/*$PAGE*/
|
||
/*
|
||
*********************************************************************************************************
|
||
* 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.
|
||
*
|
||
* Also, you cannot resume a task that has called OSTimeDlyHMSM() with a combined time that
|
||
* exceeds 65535 clock ticks. In other words, if the clock tick runs at 100 Hz then, you will
|
||
* not be able to resume a delayed task that called OSTimeDlyHMSM(0, 10, 55, 350) or higher:
|
||
*
|
||
* (10 Minutes * 60 + 55 Seconds + 0.35) * 100 ticks/second.
|
||
*
|
||
* 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 > 0
|
||
INT8U OSTimeDlyResume (INT8U prio)
|
||
{
|
||
OS_TCB *ptcb;
|
||
#if OS_CRITICAL_METHOD == 3 /* Storage for CPU status register */
|
||
OS_CPU_SR cpu_sr = 0;
|
||
#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 == 0) { /* See if task is delayed */
|
||
OS_EXIT_CRITICAL();
|
||
return (OS_ERR_TIME_NOT_DLY); /* Indicate that task was not delayed */
|
||
}
|
||
|
||
ptcb->OSTCBDly = 0; /* 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_EXIT_CRITICAL();
|
||
OS_Sched(); /* See if this is new highest priority */
|
||
} else {
|
||
OS_EXIT_CRITICAL(); /* Task may be suspended */
|
||
}
|
||
return (OS_ERR_NONE);
|
||
}
|
||
#endif
|
||
/*$PAGE*/
|
||
/*
|
||
*********************************************************************************************************
|
||
* 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 > 0
|
||
INT32U OSTimeGet (void)
|
||
{
|
||
INT32U ticks;
|
||
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
|
||
OS_CPU_SR cpu_sr = 0;
|
||
#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 > 0
|
||
void OSTimeSet (INT32U ticks)
|
||
{
|
||
#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
|
||
OS_CPU_SR cpu_sr = 0;
|
||
#endif
|
||
|
||
|
||
|
||
OS_ENTER_CRITICAL();
|
||
OSTime = ticks;
|
||
OS_EXIT_CRITICAL();
|
||
}
|
||
#endif
|