Counter

Overview

API Reference

group counter_interface

Counter Interface.

Typedefs

typedef void (*counter_alarm_callback_t)(const struct device *dev, uint8_t chan_id, uint32_t ticks, void *user_data)

Alarm callback.

Param dev:

Pointer to the device structure for the driver instance.

Param chan_id:

Channel ID.

Param ticks:

Counter value that triggered the alarm.

Param user_data:

User data.

typedef void (*counter_top_callback_t)(const struct device *dev, void *user_data)

Callback called when counter turns around.

Param dev:

Pointer to the device structure for the driver instance.

Param user_data:

User data provided in counter_set_top_value.

typedef int (*counter_api_start)(const struct device *dev)
typedef int (*counter_api_stop)(const struct device *dev)
typedef int (*counter_api_get_value)(const struct device *dev, uint32_t *ticks)
typedef int (*counter_api_get_value_64)(const struct device *dev, uint64_t *ticks)
typedef int (*counter_api_set_alarm)(const struct device *dev, uint8_t chan_id, const struct counter_alarm_cfg *alarm_cfg)
typedef int (*counter_api_cancel_alarm)(const struct device *dev, uint8_t chan_id)
typedef int (*counter_api_set_top_value)(const struct device *dev, const struct counter_top_cfg *cfg)
typedef uint32_t (*counter_api_get_pending_int)(const struct device *dev)
typedef uint32_t (*counter_api_get_top_value)(const struct device *dev)
typedef uint32_t (*counter_api_get_guard_period)(const struct device *dev, uint32_t flags)
typedef int (*counter_api_set_guard_period)(const struct device *dev, uint32_t ticks, uint32_t flags)
typedef uint32_t (*counter_api_get_freq)(const struct device *dev)

Functions

bool counter_is_counting_up(const struct device *dev)

Function to check if counter is counting up.

Parameters:

  • dev – [in] Pointer to the device structure for the driver instance.

Return values:

  • true – if counter is counting up.

  • false – if counter is counting down.

uint8_t counter_get_num_of_channels(const struct device *dev)

Function to get number of alarm channels.

Parameters:

  • dev – [in] Pointer to the device structure for the driver instance.

Returns:

Number of alarm channels.

uint32_t counter_get_frequency(const struct device *dev)

Function to get counter frequency.

Parameters:

  • dev – [in] Pointer to the device structure for the driver instance.

Returns:

Frequency of the counter in Hz, or zero if the counter does not have a fixed frequency.

uint32_t counter_us_to_ticks(const struct device *dev, uint64_t us)

Function to convert microseconds to ticks.

Parameters:

  • dev – [in] Pointer to the device structure for the driver instance.

  • us – [in] Microseconds.

Returns:

Converted ticks. Ticks will be saturated if exceed 32 bits.

uint64_t counter_ticks_to_us(const struct device *dev, uint32_t ticks)

Function to convert ticks to microseconds.

Parameters:

  • dev – [in] Pointer to the device structure for the driver instance.

  • ticks – [in] Ticks.

Returns:

Converted microseconds.

uint32_t counter_get_max_top_value(const struct device *dev)

Function to retrieve maximum top value that can be set.

Parameters:

  • dev – [in] Pointer to the device structure for the driver instance.

Returns:

Max top value.

int counter_start(const struct device *dev)

Start counter device in free running mode.

Parameters:

  • dev – Pointer to the device structure for the driver instance.

Return values:

  • 0 – If successful.

  • Negative – errno code if failure.

int counter_stop(const struct device *dev)

Stop counter device.

Parameters:

  • dev – Pointer to the device structure for the driver instance.

Return values:

  • 0 – If successful.

  • -ENOTSUP – if the device doesn’t support stopping the counter.

int counter_get_value(const struct device *dev, uint32_t *ticks)

Get current counter value.

Parameters:

  • dev – Pointer to the device structure for the driver instance.

  • ticks – Pointer to where to store the current counter value

Return values:

  • 0 – If successful.

  • Negative – error code on failure getting the counter value

int counter_get_value_64(const struct device *dev, uint64_t *ticks)

Get current counter 64-bit value.

Parameters:

  • dev – Pointer to the device structure for the driver instance.

  • ticks – Pointer to where to store the current counter value

Return values:

  • 0 – If successful.

  • Negative – error code on failure getting the counter value

int counter_set_channel_alarm(const struct device *dev, uint8_t chan_id, const struct counter_alarm_cfg *alarm_cfg)

Set a single shot alarm on a channel.

After expiration alarm can be set again, disabling is not needed. When alarm expiration handler is called, channel is considered available and can be set again in that context.

Note

API is not thread safe.

Parameters:

  • dev – Pointer to the device structure for the driver instance.

  • chan_id – Channel ID.

  • alarm_cfg – Alarm configuration.

Return values:

  • 0 – If successful.

  • -ENOTSUP – if request is not supported (device does not support interrupts or requested channel).

  • -EINVAL – if alarm settings are invalid.

  • -ETIME – if absolute alarm was set too late.

  • -EBUSY – if alarm is already active.

int counter_cancel_channel_alarm(const struct device *dev, uint8_t chan_id)

Cancel an alarm on a channel.

Note

API is not thread safe.

Parameters:

  • dev – Pointer to the device structure for the driver instance.

  • chan_id – Channel ID.

Return values:

  • 0 – If successful.

  • -ENOTSUP – if request is not supported or the counter was not started yet.

int counter_set_top_value(const struct device *dev, const struct counter_top_cfg *cfg)

Set counter top value.

Function sets top value and optionally resets the counter to 0 or top value depending on counter direction. On turnaround, counter can be reset and optional callback is periodically called. Top value can only be changed when there is no active channel alarm.

COUNTER_TOP_CFG_DONT_RESET prevents counter reset. When counter is running while top value is updated, it is possible that counter progresses outside the new top value. In that case, error is returned and optionally driver can reset the counter (see COUNTER_TOP_CFG_RESET_WHEN_LATE).

Parameters:

  • dev – Pointer to the device structure for the driver instance.

  • cfg – Configuration. Cannot be NULL.

Return values:

  • 0 – If successful.

  • -ENOTSUP – if request is not supported (e.g. top value cannot be changed or counter cannot/must be reset during top value update).

  • -EBUSY – if any alarm is active.

  • -ETIME – if COUNTER_TOP_CFG_DONT_RESET was set and new top value is smaller than current counter value (counter counting up).

int counter_get_pending_int(const struct device *dev)

Function to get pending interrupts.

The purpose of this function is to return the interrupt status register for the device. This is especially useful when waking up from low power states to check the wake up source.

Parameters:

  • dev – Pointer to the device structure for the driver instance.

Return values:

  • 1 – if any counter interrupt is pending.

  • 0 – if no counter interrupt is pending.

uint32_t counter_get_top_value(const struct device *dev)

Function to retrieve current top value.

Parameters:

  • dev – [in] Pointer to the device structure for the driver instance.

Returns:

Top value.

int counter_set_guard_period(const struct device *dev, uint32_t ticks, uint32_t flags)

Set guard period in counter ticks.

When setting an absolute alarm value close to the current counter value there is a risk that the counter will have counted past the given absolute value before the driver manages to activate the alarm. If this would go unnoticed then the alarm would only expire after the timer has wrapped and reached the given absolute value again after a full timer period. This could take a long time in case of a 32 bit timer. Setting a sufficiently large guard period will help the driver detect unambiguously whether it is late or not.

The guard period should be as many counter ticks as the driver will need at most to actually activate the alarm after the driver API has been called. If the driver finds that the counter has just passed beyond the given absolute tick value but is still close enough to fall within the guard period, it will assume that it is “late”, i.e. that the intended expiry time has already passed. Depending on the COUNTER_ALARM_CFG_EXPIRE_WHEN_LATE flag the driver will either ignore the alarm or expire it immediately in such a case.

If, however, the counter is past the given absolute tick value but outside the guard period, then the driver will assume that this is intentional and let the counter wrap around to/from zero before it expires.

More precisely:

  • When counting upwards (see COUNTER_CONFIG_INFO_COUNT_UP) the given absolute tick value must be above (now + guard_period) % top_value to be accepted by the driver.

  • When counting downwards, the given absolute tick value must be less than (now + top_value - guard_period) % top_value to be accepted.

Examples:

  • counting upwards, now = 4950, top value = 5000, guard period = 100: absolute tick value >= (4950 + 100) % 5000 = 50

  • counting downwards, now = 50, top value = 5000, guard period = 100: absolute tick value <= (50 + 5000 - * 100) % 5000 = 4950

If you need only short alarm periods, you can set the guard period very high (e.g. half of the counter top value) which will make it highly unlikely that the counter will ever unintentionally wrap.

The guard period is set to 0 on initialization (no protection).

Parameters:

  • dev – Pointer to the device structure for the driver instance.

  • ticks – Guard period in counter ticks.

  • flags – See Counter guard period flags.

Return values:

  • 0 – if successful.

  • -ENOTSUP – if function or flags are not supported.

  • -EINVAL – if ticks value is invalid.

uint32_t counter_get_guard_period(const struct device *dev, uint32_t flags)

Return guard period.

See counter_set_guard_period.

Parameters:

  • dev – Pointer to the device structure for the driver instance.

  • flags – See Counter guard period flags.

Returns:

Guard period given in counter ticks or 0 if function or flags are not supported.

struct counter_alarm_cfg
#include <counter.h>

Alarm callback structure.

Param callback:

Callback called on alarm (cannot be NULL).

Param ticks:

Number of ticks that triggers the alarm. It can be relative (to now) or an absolute value (see COUNTER_ALARM_CFG_ABSOLUTE). Both, relative and absolute, alarm values can be any value between zero and the current top value (see counter_get_top_value). When setting an absolute alarm value close to the current counter value there is a risk that the counter will have counted past the given absolute value before the driver manages to activate the alarm. Therefore a guard period can be defined that lets the driver decide unambiguously whether it is late or not (see counter_set_guard_period). If the counter is clock driven then ticks can be converted to microseconds (see counter_ticks_to_us). Alternatively, the counter implementation may count asynchronous events.

Param user_data:

User data returned in callback.

Param flags:

Alarm flags. See Alarm configuration flags.

struct counter_top_cfg
#include <counter.h>

Top value configuration structure.

Param ticks:

Top value.

Param callback:

Callback function. Can be NULL.

Param user_data:

User data passed to callback function. Not valid if callback is NULL.

Param flags:

Flags. See Flags used by .

struct counter_config_info
#include <counter.h>

Structure with generic counter features.

Param max_top_value:

Maximal (default) top value on which counter is reset (cleared or reloaded).

Param freq:

Frequency of the source clock if synchronous events are counted.

Param flags:

Flags. See Counter device capabilities.

Param channels:

Number of channels that can be used for setting alarm, see counter_set_channel_alarm.

struct counter_driver_api
#include <counter.h>