epoch.h

Go to the documentation of this file.

 
#ifndef INFUSE_SDK_INCLUDE_INFUSE_TIME_EPOCH_H_
#define INFUSE_SDK_INCLUDE_INFUSE_TIME_EPOCH_H_
 
#include <stdint.h>
#include <stdbool.h>
#include <time.h>
 
#include <zephyr/kernel.h>
#include <zephyr/toolchain.h>
#include <zephyr/sys/timeutil.h>
 
/* Time conversion functions */
#include "epoch_units.h"
 
#ifdef __cplusplus
extern "C" {
#endif

 
#define SECONDS_PER_MINUTE (60)
#define SECONDS_PER_HOUR   (60 * SECONDS_PER_MINUTE)
#define SECONDS_PER_DAY    (24 * SECONDS_PER_HOUR)
#define SECONDS_PER_WEEK   (7 * SECONDS_PER_DAY)

#define INFUSE_EPOCH_TIME_GPS_UNIX_OFFSET_SECONDS_LEAP 18

#define INFUSE_EPOCH_TIME_GPS_UNIX_OFFSET_SECONDS_BASE 315964800

#define INFUSE_EPOCH_TIME_TICKS_PER_SEC (UINT16_MAX + 1)
 
/* Source of time knowledge */
enum epoch_time_source {
        /* No time knowledge */
        TIME_SOURCE_NONE = 0,
        /* Time from GNSS constellation (GPS, Beidou, etc) */
        TIME_SOURCE_GNSS,
        /* Time from Network Time Protocol (IP) */
        TIME_SOURCE_NTP,
        /* Time directly set by Remote Procedure Call */
        TIME_SOURCE_RPC,
        /* Time from observed ePacket headers */
        TIME_SOURCE_EPACKET,
        /* Unknown time source value */
        TIME_SOURCE_INVALID,
        /* Time has been preserved across a reboot */
        TIME_SOURCE_RECOVERED = 0x80,
} __packed;

struct epoch_time_cb {
        void (*reference_time_updated)(enum epoch_time_source source,
                                       struct timeutil_sync_instant old,
                                       struct timeutil_sync_instant new, void *user_ctx);
 
        /* User provided context pointer */
        void *user_ctx;
 
        sys_snode_t node;
};

void epoch_time_register_callback(struct epoch_time_cb *cb);

static inline enum epoch_time_source epoch_time_source_base(enum epoch_time_source source)
{
        return source & ~TIME_SOURCE_RECOVERED;
}

static inline bool epoch_time_trusted_source(enum epoch_time_source source, bool recovered_ok)
{
        enum epoch_time_source base = epoch_time_source_base(source);
        bool recovered = !!(source & TIME_SOURCE_RECOVERED);
        bool base_good = IN_RANGE(base, TIME_SOURCE_NONE + 1, TIME_SOURCE_INVALID - 1);
 
        return base_good && (!recovered || recovered_ok);
}

static inline bool epoch_time_precise_source(enum epoch_time_source source)
{
        enum epoch_time_source base = epoch_time_source_base(source);
 
        /* Delays associated with RPC and ePacket methods are not controllable
         * by the device.
         */
        return (base == TIME_SOURCE_GNSS) || (base == TIME_SOURCE_NTP);
}

static inline uint64_t epoch_time_seconds(uint64_t epoch_time)
{
        return epoch_time >> 16;
}

static inline uint16_t epoch_time_subseconds(uint64_t epoch_time)
{
        return epoch_time & 0xFFFF;
}

static inline uint16_t epoch_time_milliseconds(uint64_t epoch_time)
{
        return k_epoch_to_ms_near32(epoch_time_subseconds(epoch_time));
}

static inline uint64_t epoch_time_from(uint64_t seconds, uint16_t subseconds)
{
        return (seconds << 16) | subseconds;
}

static inline uint64_t epoch_time_from_gps(uint16_t week, uint32_t week_seconds,
                                           uint16_t subseconds)
{
        uint64_t seconds = (SECONDS_PER_WEEK * (uint64_t)week) + week_seconds;
 
        return epoch_time_from(seconds, subseconds);
}

static inline uint32_t unix_time_from_epoch(uint64_t epoch_time)
{
        return epoch_time_seconds(epoch_time) + INFUSE_EPOCH_TIME_GPS_UNIX_OFFSET_SECONDS_BASE -
               INFUSE_EPOCH_TIME_GPS_UNIX_OFFSET_SECONDS_LEAP;
}

static inline uint64_t epoch_time_from_unix(uint32_t unix_time, uint16_t subseconds)
{
        uint64_t epoch_seconds = unix_time - INFUSE_EPOCH_TIME_GPS_UNIX_OFFSET_SECONDS_BASE +
                                 INFUSE_EPOCH_TIME_GPS_UNIX_OFFSET_SECONDS_LEAP;
 
        return epoch_time_from(epoch_seconds, subseconds);
}

uint64_t ticks_from_epoch_time(uint64_t epoch_time);

uint64_t epoch_time_from_ticks(uint64_t ticks);

uint32_t epoch_period_from_array_ticks(uint64_t array_ticks, uint16_t array_num);

static inline uint64_t epoch_time_now(void)
{
        return epoch_time_from_ticks(k_uptime_ticks());
}

void epoch_time_unix_calendar(uint64_t epoch_time, struct tm *calendar);

enum epoch_time_source epoch_time_get_source(void);

int epoch_time_set_reference(enum epoch_time_source source,
                             struct timeutil_sync_instant *reference);

uint32_t epoch_time_reference_age(void);

int epoch_time_reference_shift(const struct timeutil_sync_instant *ref_a,
                               const struct timeutil_sync_instant *ref_b, int64_t *epoch_shift);
 
#ifdef CONFIG_ZTEST

void epoch_time_reset(void);
 
#endif /* CONFIG_ZTEST */

 
#ifdef __cplusplus
}
#endif
 
#endif /* INFUSE_SDK_INCLUDE_INFUSE_TIME_EPOCH_H_ */