diff options
Diffstat (limited to 'os/rt/include/chvt.h')
| -rw-r--r-- | os/rt/include/chvt.h | 418 |
1 files changed, 68 insertions, 350 deletions
diff --git a/os/rt/include/chvt.h b/os/rt/include/chvt.h index dc08dbe07..e115bec63 100644 --- a/os/rt/include/chvt.h +++ b/os/rt/include/chvt.h @@ -32,37 +32,6 @@ /* Module constants. */
/*===========================================================================*/
-/**
- * @name Special time constants
- * @{
- */
-/**
- * @brief Zero time specification for some functions with a timeout
- * specification.
- * @note Not all functions accept @p TIME_IMMEDIATE as timeout parameter,
- * see the specific function documentation.
- */
-#define TIME_IMMEDIATE ((systime_t)0)
-
-/**
- * @brief Infinite time specification for all functions with a timeout
- * specification.
- * @note Not all functions accept @p TIME_INFINITE as timeout parameter,
- * see the specific function documentation.
- */
-#define TIME_INFINITE ((systime_t)-1)
-
-/**
- * @brief Maximum time constant.
- */
-#define TIME_MAXIMUM ((systime_t)-2)
-/** @} */
-
-/**
- * @brief Maximum unsigned integer.
- */
-#define __UINT_MAX ((unsigned int)-1)
-
/*===========================================================================*/
/* Module pre-compile time settings. */
/*===========================================================================*/
@@ -71,14 +40,6 @@ /* Derived constants and error checks. */
/*===========================================================================*/
-#if (CH_CFG_ST_RESOLUTION != 16) && (CH_CFG_ST_RESOLUTION != 32)
-#error "invalid CH_CFG_ST_RESOLUTION specified, must be 16 or 32"
-#endif
-
-#if CH_CFG_ST_FREQUENCY <= 0
-#error "invalid CH_CFG_ST_FREQUENCY specified, must be greater than zero"
-#endif
-
#if (CH_CFG_ST_TIMEDELTA < 0) || (CH_CFG_ST_TIMEDELTA == 1)
#error "invalid CH_CFG_ST_TIMEDELTA specified, must " \
"be zero or greater than one"
@@ -100,108 +61,6 @@ /* Module macros. */
/*===========================================================================*/
-/**
- * @name Fast time conversion utilities
- * @{
- */
-/**
- * @brief Seconds to system ticks.
- * @details Converts from seconds to system ticks number.
- * @note The result is rounded upward to the next tick boundary.
- * @note Use of this macro for large values is not secure because
- * integer overflows, make sure your value can be correctly
- * converted.
- *
- * @param[in] sec number of seconds
- * @return The number of ticks.
- *
- * @api
- */
-#define S2ST(sec) \
- ((systime_t)((uint32_t)(sec) * (uint32_t)CH_CFG_ST_FREQUENCY))
-
-/**
- * @brief Milliseconds to system ticks.
- * @details Converts from milliseconds to system ticks number.
- * @note The result is rounded upward to the next tick boundary.
- * @note Use of this macro for large values is not secure because
- * integer overflows, make sure your value can be correctly
- * converted.
- *
- * @param[in] msec number of milliseconds
- * @return The number of ticks.
- *
- * @api
- */
-#define MS2ST(msec) \
- ((systime_t)(((((uint32_t)(msec)) * \
- ((uint32_t)CH_CFG_ST_FREQUENCY)) + 999UL) / 1000UL))
-
-/**
- * @brief Microseconds to system ticks.
- * @details Converts from microseconds to system ticks number.
- * @note The result is rounded upward to the next tick boundary.
- * @note Use of this macro for large values is not secure because
- * integer overflows, make sure your value can be correctly
- * converted.
- *
- * @param[in] usec number of microseconds
- * @return The number of ticks.
- *
- * @api
- */
-#define US2ST(usec) \
- ((systime_t)(((((uint32_t)(usec)) * \
- ((uint32_t)CH_CFG_ST_FREQUENCY)) + 999999UL) / 1000000UL))
-
-/**
- * @brief System ticks to seconds.
- * @details Converts from system ticks number to seconds.
- * @note The result is rounded up to the next second boundary.
- * @note Use of this macro for large values is not secure because
- * integer overflows, make sure your value can be correctly
- * converted.
- *
- * @param[in] n number of system ticks
- * @return The number of seconds.
- *
- * @api
- */
-#define ST2S(n) (((n) + CH_CFG_ST_FREQUENCY - 1UL) / CH_CFG_ST_FREQUENCY)
-
-/**
- * @brief System ticks to milliseconds.
- * @details Converts from system ticks number to milliseconds.
- * @note The result is rounded up to the next millisecond boundary.
- * @note Use of this macro for large values is not secure because
- * integer overflows, make sure your value can be correctly
- * converted.
- *
- * @param[in] n number of system ticks
- * @return The number of milliseconds.
- *
- * @api
- */
-#define ST2MS(n) (((n) * 1000UL + CH_CFG_ST_FREQUENCY - 1UL) / \
- CH_CFG_ST_FREQUENCY)
-
-/**
- * @brief System ticks to microseconds.
- * @details Converts from system ticks number to microseconds.
- * @note The result is rounded up to the next microsecond boundary.
- * @note Use of this macro for large values is not secure because
- * integer overflows, make sure your value can be correctly
- * converted.
- *
- * @param[in] n number of system ticks
- * @return The number of microseconds.
- *
- * @api
- */
-#define ST2US(n) (((n) * 1000000UL + CH_CFG_ST_FREQUENCY - 1UL) / \
- CH_CFG_ST_FREQUENCY)
-/** @} */
-
/*===========================================================================*/
/* External declarations. */
/*===========================================================================*/
@@ -213,7 +72,7 @@ extern "C" {
#endif
void _vt_init(void);
- void chVTDoSetI(virtual_timer_t *vtp, systime_t delay,
+ void chVTDoSetI(virtual_timer_t *vtp, sysinterval_t delay,
vtfunc_t vtfunc, void *par);
void chVTDoResetI(virtual_timer_t *vtp);
#ifdef __cplusplus
@@ -225,142 +84,6 @@ extern "C" { /*===========================================================================*/
/**
- * @name Secure time conversion utilities
- * @{
- */
-/**
- * @brief Seconds to system ticks.
- * @details Converts from seconds to system ticks number.
- * @note The result is rounded upward to the next tick boundary.
- * @note This function uses a 64 bits internal representation,
- * use with non-constant parameters can lead to inefficient
- * code because 64 bits arithmetic would be used at runtime.
- *
- * @param[in] sec number of seconds
- * @return The number of ticks.
- *
- * @api
- */
-static inline systime_t LL_S2ST(unsigned int sec) {
- uint64_t ticks = (uint64_t)sec * (uint64_t)CH_CFG_ST_FREQUENCY;
-
- chDbgAssert(ticks <= (uint64_t)TIME_MAXIMUM, "conversion overflow");
-
- return (systime_t)ticks;
-}
-
-/**
- * @brief Milliseconds to system ticks.
- * @details Converts from milliseconds to system ticks number.
- * @note The result is rounded upward to the next tick boundary.
- * @note This function uses a 64 bits internal representation,
- * use with non-constant parameters can lead to inefficient
- * code because 64 bits arithmetic would be used at runtime.
- *
- * @param[in] msec number of milliseconds
- * @return The number of ticks.
- *
- * @api
- */
-static inline systime_t LL_MS2ST(unsigned int msec) {
- uint64_t ticks = (((uint64_t)msec * (uint64_t)CH_CFG_ST_FREQUENCY) + 999ULL)
- / 1000ULL;
-
- chDbgAssert(ticks <= (uint64_t)TIME_MAXIMUM, "conversion overflow");
-
- return (systime_t)ticks;
-}
-
-/**
- * @brief Microseconds to system ticks.
- * @details Converts from microseconds to system ticks number.
- * @note The result is rounded upward to the next tick boundary.
- * @note This function uses a 64 bits internal representation,
- * use with non-constant parameters can lead to inefficient
- * code because 64 bits arithmetic would be used at runtime.
- *
- * @param[in] usec number of microseconds
- * @return The number of ticks.
- *
- * @api
- */
-static inline systime_t LL_US2ST(unsigned int usec) {
- uint64_t ticks = (((uint64_t)usec * (uint64_t)CH_CFG_ST_FREQUENCY) + 999999ULL)
- / 1000000ULL;
-
- chDbgAssert(ticks <= (uint64_t)TIME_MAXIMUM, "conversion overflow");
-
- return (systime_t)ticks;
-}
-
-/**
- * @brief System ticks to seconds.
- * @details Converts from system ticks number to seconds.
- * @note The result is rounded up to the next second boundary.
- * @note This function uses a 64 bits internal representation,
- * use with non-constant parameters can lead to inefficient
- * code because 64 bits arithmetic would be used at runtime.
- *
- * @param[in] n number of system ticks
- * @return The number of seconds.
- *
- * @api
- */
-static inline unsigned int LL_ST2S(systime_t n) {
- uint64_t sec = ((uint64_t)n + (uint64_t)CH_CFG_ST_FREQUENCY - 1ULL)
- / (uint64_t)CH_CFG_ST_FREQUENCY;
-
- chDbgAssert(sec < (uint64_t)__UINT_MAX, "conversion overflow");
-
- return (unsigned int)sec;
-}
-
-/**
- * @brief System ticks to milliseconds.
- * @details Converts from system ticks number to milliseconds.
- * @note The result is rounded up to the next millisecond boundary.
- * @note This function uses a 64 bits internal representation,
- * use with non-constant parameters can lead to inefficient
- * code because 64 bits arithmetic would be used at runtime.
- *
- * @param[in] n number of system ticks
- * @return The number of milliseconds.
- *
- * @api
- */
-static inline unsigned int LL_ST2MS(systime_t n) {
- uint64_t msec = (((uint64_t)n * 1000ULL) + (uint64_t)CH_CFG_ST_FREQUENCY - 1ULL)
- / (uint64_t)CH_CFG_ST_FREQUENCY;
-
- chDbgAssert(msec < (uint64_t)__UINT_MAX, "conversion overflow");
-
- return (unsigned int)msec;
-}
-
-/**
- * @brief System ticks to microseconds.
- * @details Converts from system ticks number to microseconds.
- * @note The result is rounded up to the next microsecond boundary.
- * @note This function uses a 64 bits internal representation,
- * use with non-constant parameters can lead to inefficient
- * code because 64 bits arithmetic would be used at runtime.
- *
- * @param[in] n number of system ticks
- * @return The number of microseconds.
- *
- * @api
- */
-static inline unsigned int LL_ST2US(systime_t n) {
- uint64_t usec = (((uint64_t)n * 1000000ULL) + (uint64_t)CH_CFG_ST_FREQUENCY - 1ULL)
- / (uint64_t)CH_CFG_ST_FREQUENCY;
-
- chDbgAssert(usec < (uint64_t)__UINT_MAX, "conversion overflow");
-
- return (unsigned int)usec;
-}
-/** @} */
-
-/**
* @brief Initializes a @p virtual_timer_t object.
* @note Initializing a timer object is not strictly required because
* the function @p chVTSetI() initializes the object too. This
@@ -426,30 +149,9 @@ static inline systime_t chVTGetSystemTime(void) { *
* @xclass
*/
-static inline systime_t chVTTimeElapsedSinceX(systime_t start) {
+static inline sysinterval_t chVTTimeElapsedSinceX(systime_t start) {
- return chVTGetSystemTimeX() - start;
-}
-
-/**
- * @brief Checks if the specified time is within the specified time window.
- * @note When start==end then the function returns always true because the
- * whole time range is specified.
- * @note This function can be called from any context.
- *
- * @param[in] time the time to be verified
- * @param[in] start the start of the time window (inclusive)
- * @param[in] end the end of the time window (non inclusive)
- * @retval true current time within the specified time window.
- * @retval false current time not within the specified time window.
- *
- * @xclass
- */
-static inline bool chVTIsTimeWithinX(systime_t time,
- systime_t start,
- systime_t end) {
-
- return (bool)((systime_t)(time - start) < (systime_t)(end - start));
+ return chTimeDiffX(chVTGetSystemTimeX(), start);
}
/**
@@ -467,7 +169,7 @@ static inline bool chVTIsTimeWithinX(systime_t time, */
static inline bool chVTIsSystemTimeWithinX(systime_t start, systime_t end) {
- return chVTIsTimeWithinX(chVTGetSystemTimeX(), start, end);
+ return chTimeIsInRangeX(chVTGetSystemTimeX(), start, end);
}
/**
@@ -485,7 +187,7 @@ static inline bool chVTIsSystemTimeWithinX(systime_t start, systime_t end) { */
static inline bool chVTIsSystemTimeWithin(systime_t start, systime_t end) {
- return chVTIsTimeWithinX(chVTGetSystemTime(), start, end);
+ return chTimeIsInRangeX(chVTGetSystemTime(), start, end);
}
/**
@@ -504,7 +206,7 @@ static inline bool chVTIsSystemTimeWithin(systime_t start, systime_t end) { *
* @iclass
*/
-static inline bool chVTGetTimersStateI(systime_t *timep) {
+static inline bool chVTGetTimersStateI(sysinterval_t *timep) {
chDbgCheckClassI();
@@ -516,8 +218,10 @@ static inline bool chVTGetTimersStateI(systime_t *timep) { #if CH_CFG_ST_TIMEDELTA == 0
*timep = ch.vtlist.next->delta;
#else
- *timep = ch.vtlist.lasttime + ch.vtlist.next->delta +
- CH_CFG_ST_TIMEDELTA - chVTGetSystemTimeX();
+ *timep = chTimeDiffX(chVTGetSystemTimeX(),
+ chTimeAddX(ch.vtlist.lasttime,
+ ch.vtlist.next->delta +
+ (sysinterval_t)CH_CFG_ST_TIMEDELTA));
#endif
}
@@ -617,7 +321,7 @@ static inline void chVTReset(virtual_timer_t *vtp) { *
* @iclass
*/
-static inline void chVTSetI(virtual_timer_t *vtp, systime_t delay,
+static inline void chVTSetI(virtual_timer_t *vtp, sysinterval_t delay,
vtfunc_t vtfunc, void *par) {
chVTResetI(vtp);
@@ -646,7 +350,7 @@ static inline void chVTSetI(virtual_timer_t *vtp, systime_t delay, *
* @api
*/
-static inline void chVTSet(virtual_timer_t *vtp, systime_t delay,
+static inline void chVTSet(virtual_timer_t *vtp, sysinterval_t delay,
vtfunc_t vtfunc, void *par) {
chSysLock();
@@ -672,7 +376,7 @@ static inline void chVTDoTickI(void) { if (&ch.vtlist != (virtual_timers_list_t *)ch.vtlist.next) {
/* The list is not empty, processing elements on top.*/
--ch.vtlist.next->delta;
- while (ch.vtlist.next->delta == (systime_t)0) {
+ while (ch.vtlist.next->delta == (sysinterval_t)0) {
virtual_timer_t *vtp;
vtfunc_t fn;
@@ -688,48 +392,51 @@ static inline void chVTDoTickI(void) { }
#else /* CH_CFG_ST_TIMEDELTA > 0 */
virtual_timer_t *vtp;
- systime_t now, delta;
+ systime_t now;
+ sysinterval_t delta, nowdelta;
- /* First timer to be processed.*/
+ /* Looping through timers.*/
vtp = ch.vtlist.next;
- now = chVTGetSystemTimeX();
-
- /* All timers within the time window are triggered and removed,
- note that the loop is stopped by the timers header having
- "ch.vtlist.vt_delta == (systime_t)-1" which is greater than
- all deltas.*/
- while (vtp->delta <= (systime_t)(now - ch.vtlist.lasttime)) {
- vtfunc_t fn;
-
- /* The "last time" becomes this timer's expiration time.*/
- ch.vtlist.lasttime += vtp->delta;
-
- vtp->next->prev = (virtual_timer_t *)&ch.vtlist;
- ch.vtlist.next = vtp->next;
- fn = vtp->func;
- vtp->func = NULL;
-
- /* if the list becomes empty then the timer is stopped.*/
- if (ch.vtlist.next == (virtual_timer_t *)&ch.vtlist) {
- port_timer_stop_alarm();
+ while (true) {
+
+ /* Getting the system time as reference.*/
+ now = chVTGetSystemTimeX();
+ nowdelta = chTimeDiffX(ch.vtlist.lasttime, now);
+
+ /* The list scan is limited by the timers header having
+ "ch.vtlist.vt_delta == (sysinterval_t)-1" which is
+ greater than all deltas.*/
+ if (nowdelta < vtp->delta) {
+ break;
}
- /* Leaving the system critical zone in order to execute the callback
- and in order to give a preemption chance to higher priority
- interrupts.*/
- chSysUnlockFromISR();
+ /* Consuming all timers between "vtp->lasttime" and now.*/
+ do {
+ vtfunc_t fn;
- /* The callback is invoked outside the kernel critical zone.*/
- fn(vtp->par);
+ /* The "last time" becomes this timer's expiration time.*/
+ ch.vtlist.lasttime += vtp->delta;
+ nowdelta -= vtp->delta;
- /* Re-entering the critical zone in order to continue the exploration
- of the list.*/
- chSysLockFromISR();
+ vtp->next->prev = (virtual_timer_t *)&ch.vtlist;
+ ch.vtlist.next = vtp->next;
+ fn = vtp->func;
+ vtp->func = NULL;
- /* Next element in the list, the current time could have advanced so
- recalculating the time window.*/
- vtp = ch.vtlist.next;
- now = chVTGetSystemTimeX();
+ /* if the list becomes empty then the timer is stopped.*/
+ if (ch.vtlist.next == (virtual_timer_t *)&ch.vtlist) {
+ port_timer_stop_alarm();
+ }
+
+ /* The callback is invoked outside the kernel critical zone.*/
+ chSysUnlockFromISR();
+ fn(vtp->par);
+ chSysLockFromISR();
+
+ /* Next element in the list.*/
+ vtp = ch.vtlist.next;
+ }
+ while (vtp->delta <= nowdelta);
}
/* if the list is empty, nothing else to do.*/
@@ -737,15 +444,26 @@ static inline void chVTDoTickI(void) { return;
}
+ /* The "unprocessed nowdelta" time slice is added to "last time"
+ and subtracted to next timer's delta.*/
+ ch.vtlist.lasttime += nowdelta;
+ ch.vtlist.next->delta -= nowdelta;
+
/* Recalculating the next alarm time.*/
- delta = ch.vtlist.lasttime + vtp->delta - now;
- if (delta < (systime_t)CH_CFG_ST_TIMEDELTA) {
- delta = (systime_t)CH_CFG_ST_TIMEDELTA;
+ delta = chTimeDiffX(now, chTimeAddX(ch.vtlist.lasttime, vtp->delta));
+ if (delta < (sysinterval_t)CH_CFG_ST_TIMEDELTA) {
+ delta = (sysinterval_t)CH_CFG_ST_TIMEDELTA;
}
- port_timer_set_alarm(now + delta);
+#if CH_CFG_INTERVALS_SIZE > CH_CFG_ST_RESOLUTION
+ /* The delta could be too large for the physical timer to handle.*/
+ else if (delta > (sysinterval_t)TIME_MAX_SYSTIME) {
+ delta = (sysinterval_t)TIME_MAX_SYSTIME;
+ }
+#endif
+ port_timer_set_alarm(chTimeAddX(now, delta));
- chDbgAssert((chVTGetSystemTimeX() - ch.vtlist.lasttime) <=
- (now + delta - ch.vtlist.lasttime),
+ chDbgAssert(chTimeDiffX(ch.vtlist.lasttime, chVTGetSystemTimeX()) <=
+ chTimeDiffX(ch.vtlist.lasttime, chTimeAddX(now, delta)),
"exceeding delta");
#endif /* CH_CFG_ST_TIMEDELTA > 0 */
}
|