=====================
System Time and Clock
=====================
Basic System Timer
==================
**System Timer** In most implementations, system time is provided
by a timer interrupt. That timer interrupt runs at rate determined
by ``CONFIG_USEC_PER_TICK`` (default 10000 microseconds or 100Hz.
If ``CONFIG_SCHED_TICKLESS`` is selected, the default is 100
microseconds). The timer generates an interrupt each
``CONFIG_USEC_PER_TICK`` microseconds and increments a counter
called ``g_system_ticks``. ``g_system_ticks`` then provides a
time-base for calculating *up-time* and elapsed time intervals in
units of ``CONFIG_USEC_PER_TICK``. The range of ``g_system_ticks``
is, by default, 32-bits. However, if the MCU supports type
``long long`` and ``CONFIG_SYSTEM_TIME16`` is selected, a 64-bit
system timer will be supported instead.
**System Timer Accuracy** On many system, the exact timer interval
specified by ``CONFIG_USEC_PER_TICK`` cannot be achieved due to
limitations in frequencies or in dividers. As a result, the time
interval specified by ``CONFIG_USEC_PER_TICK`` may only be
approximate and there may be small errors in the apparent
*up-time* time. These small errors, however, will accumulate over
time and after a long period of time may have an unacceptably
large error in the apparent *up-time* of the MCU.
If the timer tick period generated by the hardware is not exactly
``CONFIG_USEC_PER_TICK`` *and* if there you require accurate
up-time for the MCU, then there are measures that you can take:
- Perhaps you can adjust ``CONFIG_USEC_PER_TICK`` to a different
value so that an exactly ``CONFIG_USEC_PER_TICK`` can be
realized.
- Or you can use a technique known as *Delta-Sigma Modulation*.
(Suggested by Uros Platise). Consider the example below.
**Delta-Sigma Modulation Example**. Consider this case: The system
timer is a count-up timer driven at 32.768KHz. There are dividers
that can be used, but a divider of one yields the highest
accuracy. This counter counts up until the count equals a match
value, then a timer interrupt is generated. The desire frequency
is 100Hz (``CONFIG_USEC_PER_TICK`` is 10000).
This exact frequency of 100Hz cannot be obtained in this case. In
order to obtain that exact frequency a match value of 327.68 would
have to be provided. The closest integer value is 328 but the
ideal match value is between 327 and 328. The closest value, 328,
would yield an actual timer frequency of 99.9Hz! That will may
cause significant timing errors in certain usages.
Use of Delta-Sigma Modulation can eliminate this error in the long
run. Consider this example implementation:
#. Initially an accumulator is zero an the match value is
programmed to 328:
.. code-block:: c
accumulator = 0;
match = 328;
#. On each timer interrupt, accumulator is updated with difference
that, in this reflects, 100\* the error in interval that just
passed. So on the first timer interrupt, the accumulator would
be updated like:
.. code-block:: c
if (match == 328)
{
accumulator += 32; // 100*(328 - 327.68)
}
else
{
accumulator -= 68; // (100*(327 - 327.68)
}
#. And on that same timer interrupt a new match value would be
programmed:
.. code-block:: c
if (accumulator < 0)
{
match = 328;
}
else
{
match = 327;
}
In this way, the timer interval is controlled from
interrupt-to-interrupt to produce an average frequency of exactly
100Hz.
Hardware
========
To enable hardware module use the following configuration options:
``CONFIG_RTC``
Enables general support for a hardware RTC. Specific
architectures may require other specific settings.
``CONFIG_RTC_EXTERNAL``
Most MCUs include RTC hardware built into the chip. Other RTCs,
*external* MCUs, may be provided as separate chips typically
interfacing with the MCU via a serial interface such as SPI or
I2C. These external RTCs differ from the built-in RTCs in that
they cannot be initialized until the operating system is fully
booted and can support the required serial communications.
``CONFIG_RTC_EXTERNAL`` will configure the operating system so
that it defers initialization of its time facilities.
``CONFIG_RTC_DATETIME``
There are two general types of RTC: (1) A simple battery backed
counter that keeps the time when power is down, and (2) A full
date / time RTC the provides the date and time information,
often in BCD format. If ``CONFIG_RTC_DATETIME`` is selected, it
specifies this second kind of RTC. In this case, the RTC is
used to "seed"" the normal NuttX timer and the NuttX system
timer provides for higher resolution time.
``CONFIG_RTC_HIRES``
If ``CONFIG_RTC_DATETIME`` not selected, then the simple,
battery backed counter is used. There are two different
implementations of such simple counters based on the time
resolution of the counter: The typical RTC keeps time to
resolution of 1 second, usually supporting a 32-bit ``time_t``
value. In this case, the RTC is used to "seed" the normal NuttX
timer and the NuttX timer provides for higher resolution time.
If ``CONFIG_RTC_HIRES`` is enabled in the NuttX configuration,
then the RTC provides higher resolution time and completely
replaces the system timer for purpose of date and time.
``CONFIG_RTC_FREQUENCY``
If ``CONFIG_RTC_HIRES`` is defined, then the frequency of the
high resolution RTC must be provided. If ``CONFIG_RTC_HIRES``
is not defined, ``CONFIG_RTC_FREQUENCY`` is assumed to be one.
``CONFIG_RTC_ALARM``
Enable if the RTC hardware supports setting of an alarm. A
callback function will be executed when the alarm goes off
which requires the following base functions to read and set time:
- ``up_rtc_initialize()``. Initialize the built-in, MCU hardware
RTC per the selected configuration. This function is called
once very early in the OS initialization sequence. NOTE that
initialization of external RTC hardware that depends on the
availability of OS resources (such as SPI or I2C) must be
deferred until the system has fully booted. Other, RTC-specific
initialization functions are used in that case.
- ``up_rtc_time()``. Get the current time in seconds. This is
similar to the standard ``time()`` function. This interface is
only required if the low-resolution RTC/counter hardware
implementation selected. It is only used by the RTOS during
initialization to set up the system time when ``CONFIG_RTC`` is
set but neither ``CONFIG_RTC_HIRES`` nor
``CONFIG_RTC_DATETIME`` are set.
- ``up_rtc_gettime()``. Get the current time from the high
resolution RTC clock/counter. This interface is only supported
by the high-resolution RTC/counter hardware implementation. It
is used to replace the system timer (``g_system_ticks``).
- ``up_rtc_settime()``. Set the RTC to the provided time. All RTC
implementations must be able to set their time based on a
standard timespec.
System Tick and Time
====================
The system tick is represented by ``g_system_ticks``.
Running at rate of system base timer, used for time-slicing, and
so forth.
If hardware RTC is present (``CONFIG_RTC``) and and
high-resolution timing is enabled (``CONFIG_RTC_HIRES``), then
after successful initialization variables are overridden by calls
to ``up_rtc_gettime()`` which is running continuously even in
power-down modes.
In the case of ``CONFIG_RTC_HIRES`` is set the ``g_system_ticks``
keeps counting at rate of a system timer, which however, is
disabled in power-down mode. By comparing this time and RTC
(actual time) one may determine the actual system active time. To
retrieve that variable use:
Tickless OS
===========
**Default System Timer**. By default, a NuttX configuration uses a
periodic timer interrupt that drives all system timing. The timer
is provided by architecture-specific code that calls into NuttX at
a rate controlled by ``CONFIG_USEC_PER_TICK``. The default value
of ``CONFIG_USEC_PER_TICK`` is 10000 microseconds which
corresponds to a timer interrupt rate of 100 Hz.
On each timer interrupt, NuttX does these things:
- Increments a counter. This counter is the system time and has a
resolution of ``CONFIG_USEC_PER_TICK`` microseconds.
- Checks if it is time to perform time-slice operations on tasks
that have select round-robin scheduling.
- Checks for expiration of timed events.
What is wrong with this default system timer? Nothing really. It
is reliable and uses only a small fraction of the CPU band width.
But we can do better. Some limitations of default system timer
are, in increasing order of importance:
- **Overhead**: Although the CPU usage of the system timer
interrupt at 100Hz is really very low, it is still mostly
wasted processing time. On most timer interrupts, there is
really nothing that needs to be done other than incrementing the
counter.
- **Resolution**: Resolution of all system timing is also
determined by ``CONFIG_USEC_PER_TICK``. So nothing can be timed
with resolution finer than 10 milliseconds by default. To
increase this resolution, ``CONFIG_USEC_PER_TICK`` can be
reduced. However, then the system timer interrupts use more of
the CPU bandwidth processing useless interrupts.
- **Power Usage**: But the biggest issue is power usage. When the
system is IDLE, it enters a light, low-power mode (for ARMs,
this mode is entered with the ``wfi`` or ``wfe`` instructions
for example). But each interrupt awakens the system from this
low power mode. Therefore, higher rates of interrupts cause
greater power consumption.
**Tickless OS**. The so-called *Tickless OS* provides one solution
to this issue. The basic concept here is that the periodic, timer
interrupt is eliminated and replaced with a one-shot, interval
timer. It becomes event driven instead of polled: The default
system timer is a polled design. On each interrupt, the NuttX
logic checks if it needs to do anything and, if so, it does it.
Using an interval timer, one can anticipate when the next
interesting OS event will occur, program the interval time and
wait for it to fire. When the interval time fires, then the
scheduled activity is performed.
Tickless Platform Support
-------------------------
In order to use the Tickless OS, one must provide special support
from the platform-specific code. Just as with the default system
timer, the platform-specific code must provide the timer resources
to support the OS behavior. Currently these timer resources are
only provided on a few platforms. An example implementation is for
the simulation is at ``nuttx/arch/sim/src/up_tickless.c``. There
is another example for the Atmel SAMA5 at
``nuttx/arch/arm/src/sama5/sam_tickless.c``. These paragraphs will
explain how to provide the Tickless OS support to any platform.
Tickless Configuration Options
------------------------------
- ``CONFIG_ARCH_HAVE_TICKLESS``: If the platform provides
support for the *Tickless OS*, then this setting should be
selected in the ``Kconfig`` file for the architecture. Here is
what the selection looks in the ``arch/Kconfig`` file for the
simulated platform:
.. code-block:: console
config ARCH_SIM
bool "Simulation"
select ARCH_HAVE_TICKLESS
---help---
Linux/Cygwin user-mode simulation.
When the simulation platform is selected,
``ARCH_HAVE_TICKLESS`` is automatically selected, informing the
configuration system that *Tickless OS* options can be
selected.
- ``CONFIG_SCHED_TICKLESS``: If ``CONFIG_ARCH_HAVE_TICKLESS`` is
selected, then you will be able to use this option to enable the
*Tickless OS* features in NuttX.
- ``CONFIG_SCHED_TICKLESS_ALARM``: The tickless option can be
supported either via a simple interval timer (plus elapsed
time) or via an alarm. The interval timer allows programming
events to occur after an interval. With the alarm, you can set
a time in the future and get an event when that alarm goes off.
This option selects the use of an alarm.
The advantage of an alarm is that it avoids some small timing
errors; the advantage of the use of the interval timer is that
the hardware requirement may be simpler.
- ``CONFIG_USEC_PER_TICK``: This option is not unique to
*Tickless OS* operation, but changes its relevance when the
*Tickless OS* is selected. In the default configuration, where
system time is provided by a periodic timer interrupt, the
default system timer is configured for 100Hz, that is,
``CONFIG_USEC_PER_TICK=10000``. If ``CONFIG_SCHED_TICKLESS`` is
selected, then there are no system timer interrupts. In this
case, ``CONFIG_USEC_PER_TICK`` does not control any timer
rates. Rather, it only determines the resolution of time
reported by ``clock_systime_ticks()`` and the resolution of
times that can be set for certain delays including watchdog
timers and delayed work.
In this case there is still a trade-off: It is better to have
the ``CONFIG_USEC_PER_TICK`` as low as possible for higher
timing resolution. However, the time is currently held in
``unsigned int``. On some systems, this may be 16-bits in width
but on most contemporary systems it will be 32-bits. In either
case, smaller values of ``CONFIG_USEC_PER_TICK`` will reduce
the range of values that delays that can be represented. So the
trade-off is between range and resolution (you could also
modify the code to use a 64-bit value if you really want both).
The default, 100 microseconds, will provide for a range of
delays up to 120 hours.
This value should never be less than the underlying resolution
of the timer. Errors may ensue.
Tickless Imported Interfaces
----------------------------
The interfaces that must be provided by the platform specified
code are defined in ``include/nuttx/arch.h``, listed below, and
summarized in the following paragraphs:
- ``<arch>_timer_initialize()`` Initializes
the timer facilities. Called early in the initialization
sequence (by ``up_initialize()``).
- ``up_timer_gettime()``: Returns the
current time from the platform specific time source.
The tickless option can be supported either via a simple interval
timer (plus elapsed time) or via an alarm. The interval timer
allows programming events to occur after an interval. With the
alarm, you can set a time in\* the future and get an event when
that alarm goes off.
If ``CONFIG_SCHED_TICKLESS_ALARM`` is defined, then the platform
code must provide the following:
- ``up_alarm_cancel()``: Cancels the alarm.
- ``up_alarm_start()``: Enables (or
re-enables) the alarm.
If ``CONFIG_SCHED_TICKLESS_ALARM`` is *not*\ defined, then the
platform code must provide the following verify similar functions:
- ``up_timer_cancel()``: Cancels the
interval timer.
- ``up_timer_start()``: Starts (or re-starts)
the interval timer.
Note that a platform-specific implementation would probably require two
hardware timers: (1) A interval timer to satisfy the requirements of
``up_timer_start()`` and ``up_timer_cancel()``, and (2) a counter to
handle the requirement of ``up_timer_gettime()``. Ideally, both timers
would run at the rate determined by ``CONFIG_USEC_PER_TICK`` (and
certainly never slower than that rate).
Since timers are a limited resource, the use of two timers could be an
issue on some systems. The job could be done with a single timer if, for
example, the single timer were kept in a free-running mode at all times.
Some timer/counters have the capability to generate a compare interrupt
when the timer matches a comparison value but also to continue counting
without stopping. If your hardware supports such counters, one might use
the ``CONFIG_SCHED_TICKLESS_ALARM`` option and be able to simply set the
comparison count at the value of the free running timer *PLUS* the
desired delay. Then you could have both with a single timer: An alarm
and a free-running counter with the same timer!
In addition to these imported interfaces, the RTOS will export the
following interfaces for use by the platform-specific interval
timer implementation:
- ``nxsched_alarm_expiration()``: called by the platform-specific logic when the alarm expires.
- ``nxsched_timer_expiration()``: called by the platform-specific logic when the interval time expires.
.. c:function:: void archname_timer_initialize(void)
Initializes all platform-specific timer facilities. This function is
called early in the initialization sequence by up_initialize().
On return, the current up-time should be available from up_timer_gettime()
and the interval timer is ready for use (but not actively timing).
The naming will depend on the architecture so for STM32 ``archname`` will
be ``stm32``.
:return: Zero (OK) on success; a negated errno value on failure.
**Assumptions**: Called early in the initialization sequence before
any special concurrency protections are required.
.. c:function:: int up_timer_gettime(FAR struct timespec *ts)
Return the elapsed time since power-up (or, more correctly, since
*<arch>*\ ``_timer_initialize()`` was called). This function is
functionally equivalent to ``clock_gettime()`` for the clock ID
``CLOCK_MONOTONIC``. This function provides the basis for
reporting the current time and also is used to eliminate error
build-up from small errors in interval time calculations.
:param ts: Provides the location in which to return the up-time..
:return: Zero (OK) on success; a negated errno value on failure.
**Assumptions**: Called from the normal tasking context. The
implementation must provide whatever mutual exclusion is necessary
for correct operation. This can include disabling interrupts in
order to assure atomic register operations.
.. c:function:: int up_alarm_cancel(FAR struct timespec *ts)
Cancel the alarm and return the time of cancellation of the alarm.
These two steps need to be as nearly atomic as possible.
``nxsched_timer_expiration()`` will not be called unless the alarm
is restarted with ``up_alarm_start()``. If, as a race condition,
the alarm has already expired when this function is called, then
time returned is the current time.
:param ts: Location to return the expiration time. The current
time should be returned if the timer is not active. ``ts`` may
be ``NULL`` in which case the time is not returned
:return: Zero (OK) on success; a negated errno value on failure.
**Assumptions**: May be called from interrupt level handling or
from the normal tasking level. interrupts may need to be disabled
internally to assure non-reentrancy.
.. c:function:: int up_alarm_start(FAR const struct timespec *ts)
Start the alarm. ``nxsched_timer_expiration()`` will be called
when the alarm occurs (unless ``up_alarm_cancel`` is called to
stop it).
:param ts: The time in the future at the alarm is expected to
occur. When the alarm occurs the timer logic will call
``nxsched_timer_expiration()``.
:return: Zero (OK) on success; a negated errno value on failure.
**Assumptions**: May be called from interrupt level handling or
from the normal tasking level. Interrupts may need to be
disabled internally to assure non-reentrancy.
.. c:function:: int up_timer_cancel(FAR struct timespec *ts)
Cancel the interval timer and return the time remaining on the
timer. These two steps need to be as nearly atomic as possible.
``nxsched_timer_expiration()`` will not be called unless the timer
is restarted with ``up_timer_start()``. If, as a race condition,
the timer has already expired when this function is called, then
that pending interrupt must be cleared so that
``nxsched_timer_expiration()`` is not called spuriously and the
remaining time of zero should be returned.
:param ts: Location to return the remaining time. Zero should be
returned if the timer is not active.
:return: Zero (OK) on success; a negated errno value on failure.
**Assumptions**: May be called from interrupt level handling or
from the normal tasking level. interrupts may need to be
disabled internally to assure non-reentrancy.
.. c:function:: int up_timer_start(FAR const struct timespec *ts)
Start the interval timer. ``nxsched_timer_expiration()`` will be
called at the completion of the timeout (unless
``up_timer_cancel()`` is called to stop the timing).
:param ts: Provides the time interval until
``nxsched_timer_expiration()`` is called.
:return: Zero (OK) on success; a negated errno value on failure.
**Assumptions**: May be called from interrupt level handling
or from the normal tasking level. Interrupts may need to be
disabled internally to assure non-reentrancy.
Watchdog Timer Interfaces
=========================
NuttX provides a general watchdog timer facility. This facility
allows the NuttX user to specify a watchdog timer function that
will run after a specified delay. The watchdog timer function will
run in the context of the timer interrupt handler. Because of
this, a limited number of NuttX interfaces are available to he
watchdog timer function. However, the watchdog timer function may
use ``mq_send()``, ``sigqueue()``, or ``kill()`` to communicate
with NuttX tasks.
- :c:func:`wd_start`
- :c:func:`wd_cancel`
- :c:func:`wd_gettime`
- Watchdog Timer Callback
.. c:function:: int wd_start(FAR struct wdog_s *wdog, int delay, \
wdentry_t wdentry, wdparm_t arg)
This function adds a watchdog to the timer queue.
The specified watchdog function will be called from the interrupt
level after the specified number of ticks has elapsed. Watchdog
timers may be started from the interrupt level.
Watchdog times execute in the context of the timer interrupt
handler.
Watchdog timers execute only once.
To replace either the timeout delay or the function to be
executed, call wd_start again with the same wdog; only the most
recent wd_start() on a given watchdog ID has any effect.
:param wdog: Watchdog ID
:param delay: Delay count in clock ticks
:param wdentry: Function to call on timeout
:param arg: The parameter to pass to wdentry.
**NOTE**: The parameter must be of type ``wdparm_t``.
:return: Zero (``OK``) is returned on success; a negated ``errno`` value
is return to indicate the nature of any failure.
**Assumptions/Limitations:** The watchdog routine runs in the
context of the timer interrupt handler and is subject to all ISR
restrictions.
**POSIX Compatibility:** This is a NON-POSIX interface. VxWorks
provides the following comparable interface:
.. code-block:: c
STATUS wdStart (WDOG_ID wdog, int delay, FUNCPTR wdentry, int parameter);
Differences from the VxWorks interface include:
- The present implementation supports multiple parameters passed
to wdentry; VxWorks supports only a single parameter. The
maximum number of parameters is determined by
.. c:function:: int wd_cancel(FAR struct wdog_s *wdog)
This function cancels a currently running
watchdog timer. Watchdog timers may be canceled from the interrupt
level.
:param wdog: ID of the watchdog to cancel.
:return: ``OK`` or ``ERROR``
**POSIX Compatibility:** This is a NON-POSIX interface. VxWorks
provides the following comparable interface:
.. code-block:: c
STATUS wdCancel (WDOG_ID wdog);
.. c:function:: int wd_gettime(FAR struct wdog_s *wdog)
Returns the time remaining before
the specified watchdog expires.
:param wdog: Identifies the watchdog that the request is for.
:return: The time in system ticks remaining until the
watchdog time expires. Zero means either that wdog is not valid or
that the wdog has already expired.
.. c:type:: void (*wdentry_t)(wdparm_t arg)
**Watchdog Timer Callback**: when a watchdog expires,
the callback function with this type is
called.
The argument is passed as scalar ``wdparm_t`` values. For
systems where the ``sizeof(pointer) < sizeof(uint32_t)``, the
following union defines the alignment of the pointer within the
``uint32_t``. For example, the SDCC MCS51 general pointer is
24-bits, but ``uint32_t`` is 32-bits (of course).
We always have ``sizeof(pointer) <= sizeof(uintptr_t)`` by
definition.
.. code-block:: c
union wdparm_u
{
FAR void *pvarg; /* The size one generic point */
uint32_t dwarg; /* Big enough for a 32-bit value in any case */
uintptr_t uiarg; /* sizeof(uintptr_t) >= sizeof(pointer) */
};
#if UINTPTR_MAX >= UINT32_MAX
typedef uintptr_t wdparm_t;
#else
typedef uint32_t wdparm_t;
#endif