xtimer.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2015 Kaspar Schleiser <kaspar@schleiser.de>
 * SPDX-FileCopyrightText: 2016 Eistec AB
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once


#define XTIMER_H
 
#include <stdbool.h>
#include <stdint.h>
 
#include "modules.h"
#include "timex.h"
#ifdef MODULE_CORE_MSG
#include "msg.h"
#endif /* MODULE_CORE_MSG */
#include "mutex.h"
#include "sched.h"
#include "rmutex.h"
 
#if IS_USED(MODULE_ZTIMER64_XTIMER_COMPAT)
#include "ztimer64/xtimer_compat.h" /* IWYU pragma: export */
#elif IS_USED(MODULE_ZTIMER_XTIMER_COMPAT)
#include "ztimer/xtimer_compat.h" /* IWYU pragma: export */
#else
#include "board.h"
#if !IS_USED(MODULE_XTIMER_ON_ZTIMER)
#include "periph_conf.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
    uint64_t ticks64;       
} xtimer_ticks64_t;

typedef struct {
    uint32_t ticks32;       
} xtimer_ticks32_t;

typedef void (*xtimer_callback_t)(void*);

typedef struct xtimer {
    struct xtimer *next;         
    uint32_t offset;             
    uint32_t long_offset;        
    uint32_t start_time;         
    uint32_t long_start_time;    
    xtimer_callback_t callback;  
    void *arg;                   
} xtimer_t;

static inline xtimer_ticks32_t xtimer_now(void);

static inline xtimer_ticks64_t xtimer_now64(void);

void xtimer_now_timex(timex_t *out);

static inline uint32_t xtimer_now_usec(void);

static inline uint64_t xtimer_now_usec64(void);

void xtimer_init(void);

static inline void xtimer_sleep(uint32_t seconds);

static inline void xtimer_msleep(uint32_t milliseconds);

static inline void xtimer_usleep(uint32_t microseconds);

static inline void xtimer_usleep64(uint64_t microseconds);

static inline void xtimer_tsleep32(xtimer_ticks32_t ticks);

static inline void xtimer_tsleep64(xtimer_ticks64_t ticks);

static inline void xtimer_spin(xtimer_ticks32_t ticks);

static inline void xtimer_periodic_wakeup(xtimer_ticks32_t *last_wakeup, uint32_t period);

static inline void xtimer_set_wakeup(xtimer_t *timer, uint32_t offset, kernel_pid_t pid);

static inline void xtimer_set_wakeup64(xtimer_t *timer, uint64_t offset, kernel_pid_t pid);

static inline void xtimer_set(xtimer_t *timer, uint32_t offset);

static inline void xtimer_set64(xtimer_t *timer, uint64_t offset_us);

void xtimer_remove(xtimer_t *timer);

static inline bool xtimer_is_set(const xtimer_t *timer);

static inline xtimer_ticks32_t xtimer_ticks_from_usec(uint32_t usec);

static inline xtimer_ticks64_t xtimer_ticks_from_usec64(uint64_t usec);

static inline uint32_t xtimer_usec_from_ticks(xtimer_ticks32_t ticks);

static inline uint64_t xtimer_usec_from_ticks64(xtimer_ticks64_t ticks);

static inline xtimer_ticks32_t xtimer_ticks(uint32_t ticks);

static inline xtimer_ticks64_t xtimer_ticks64(uint64_t ticks);

static inline xtimer_ticks32_t xtimer_diff(xtimer_ticks32_t a, xtimer_ticks32_t b);

static inline xtimer_ticks64_t xtimer_diff64(xtimer_ticks64_t a, xtimer_ticks64_t b);

static inline xtimer_ticks32_t xtimer_diff32_64(xtimer_ticks64_t a, xtimer_ticks64_t b);

static inline bool xtimer_less(xtimer_ticks32_t a, xtimer_ticks32_t b);

static inline bool xtimer_less64(xtimer_ticks64_t a, xtimer_ticks64_t b);

int xtimer_mutex_lock_timeout(mutex_t *mutex, uint64_t us);

int xtimer_rmutex_lock_timeout(rmutex_t *rmutex, uint64_t us);
 
#if defined(MODULE_CORE_THREAD_FLAGS) || defined(DOXYGEN)

void xtimer_set_timeout_flag(xtimer_t *t, uint32_t timeout);

void xtimer_set_timeout_flag64(xtimer_t *t, uint64_t timeout);
#endif

uint64_t xtimer_left_usec(const xtimer_t *timer);
 
#if defined(MODULE_CORE_MSG) || defined(DOXYGEN)
static inline void xtimer_set_msg(xtimer_t *timer, uint32_t offset, msg_t *msg, kernel_pid_t target_pid);

static inline void xtimer_set_msg64(xtimer_t *timer, uint64_t offset, msg_t *msg, kernel_pid_t target_pid);

static inline int xtimer_msg_receive_timeout(msg_t *msg, uint32_t timeout);

static inline int xtimer_msg_receive_timeout64(msg_t *msg, uint64_t timeout);
#endif

#ifndef XTIMER_BACKOFF
#define XTIMER_BACKOFF 30
#endif
 
#ifndef XTIMER_ISR_BACKOFF
#define XTIMER_ISR_BACKOFF 20
#endif
 
/*
 * Default xtimer configuration
 */
#ifndef XTIMER_DEV
#define XTIMER_DEV TIMER_DEV(0)
#define XTIMER_CHAN (0)
 
#if (TIMER_0_MAX_VALUE) == 0xfffffful
#define XTIMER_WIDTH (24)
#elif (TIMER_0_MAX_VALUE) == 0xffff
#define XTIMER_WIDTH (16)
#endif
 
#endif
 
#ifndef XTIMER_WIDTH
#define XTIMER_WIDTH (32)
#endif
 
#if (XTIMER_WIDTH != 32) || DOXYGEN
#define XTIMER_MASK ((0xffffffff >> XTIMER_WIDTH) << XTIMER_WIDTH)
#else
#define XTIMER_MASK (0)
#endif

#define XTIMER_HZ_BASE (1000000ul)
 
#if !defined(XTIMER_HZ) && !defined(MODULE_XTIMER_ON_ZTIMER)
#define XTIMER_HZ XTIMER_HZ_BASE
#endif
 
#if !defined(XTIMER_SHIFT) && !defined(MODULE_XTIMER_ON_ZTIMER)
#if (XTIMER_HZ == 32768ul)
/* No shift necessary, the conversion is not a power of two and is handled by
 * functions in tick_conversion.h */
#define XTIMER_SHIFT (0)
#elif (XTIMER_HZ == XTIMER_HZ_BASE)
#define XTIMER_SHIFT (0)
#elif (XTIMER_HZ >> 1 == XTIMER_HZ_BASE) || (XTIMER_HZ << 1 == XTIMER_HZ_BASE)
#define XTIMER_SHIFT (1)
#elif (XTIMER_HZ >> 2 == XTIMER_HZ_BASE) || (XTIMER_HZ << 2 == XTIMER_HZ_BASE)
#define XTIMER_SHIFT (2)
#elif (XTIMER_HZ >> 3 == XTIMER_HZ_BASE) || (XTIMER_HZ << 3 == XTIMER_HZ_BASE)
#define XTIMER_SHIFT (3)
#elif (XTIMER_HZ >> 4 == XTIMER_HZ_BASE) || (XTIMER_HZ << 4 == XTIMER_HZ_BASE)
#define XTIMER_SHIFT (4)
#elif (XTIMER_HZ >> 5 == XTIMER_HZ_BASE) || (XTIMER_HZ << 5 == XTIMER_HZ_BASE)
#define XTIMER_SHIFT (5)
#elif (XTIMER_HZ >> 6 == XTIMER_HZ_BASE) || (XTIMER_HZ << 6 == XTIMER_HZ_BASE)
#define XTIMER_SHIFT (6)
#else
#error "XTIMER_SHIFT cannot be derived for given XTIMER_HZ, verify settings!"
#endif
#elif !defined(MODULE_XTIMER_ON_ZTIMER)
#error "XTIMER_SHIFT is set relative to XTIMER_HZ, no manual define required!"
#endif
 
#include "xtimer/tick_conversion.h"
 
#include "xtimer/implementation.h"
 
#ifdef __cplusplus
}
#endif
 
#endif /* MODULE_ZTIMER_XTIMER_COMPAT */