gnss.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Trackunit Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_GNSS_H_
#define ZEPHYR_INCLUDE_DRIVERS_GNSS_H_

 
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/data/navigation.h>
#include <errno.h>
 
#ifdef __cplusplus
extern "C" {
#endif

enum gnss_start_mode {
        GNSS_HOT_START = 0,
        GNSS_WARM_START = 1,
        GNSS_COLD_START = 2,
};

enum gnss_pps_mode {
        GNSS_PPS_MODE_DISABLED = 0,
        GNSS_PPS_MODE_ENABLED = 1,
        GNSS_PPS_MODE_ENABLED_AFTER_LOCK = 2,
        GNSS_PPS_MODE_ENABLED_WHILE_LOCKED = 3
};
 
 

enum gnss_navigation_mode {
        GNSS_NAVIGATION_MODE_ZERO_DYNAMICS = 0,
        GNSS_NAVIGATION_MODE_LOW_DYNAMICS = 1,
        GNSS_NAVIGATION_MODE_BALANCED_DYNAMICS = 2,
        GNSS_NAVIGATION_MODE_HIGH_DYNAMICS = 3
};
 
 

enum gnss_system {
        GNSS_SYSTEM_GPS = BIT(0),
        GNSS_SYSTEM_GLONASS = BIT(1),
        GNSS_SYSTEM_GALILEO = BIT(2),
        GNSS_SYSTEM_BEIDOU = BIT(3),
        GNSS_SYSTEM_QZSS = BIT(4),
        GNSS_SYSTEM_IRNSS = BIT(5),
        GNSS_SYSTEM_SBAS = BIT(6),
        GNSS_SYSTEM_IMES = BIT(7),
};

typedef uint32_t gnss_systems_t;
 
 

enum gnss_fix_status {
        GNSS_FIX_STATUS_NO_FIX = 0,
        GNSS_FIX_STATUS_GNSS_FIX = 1,
        GNSS_FIX_STATUS_DGNSS_FIX = 2,
        GNSS_FIX_STATUS_ESTIMATED_FIX = 3,
};

enum gnss_fix_quality {
        GNSS_FIX_QUALITY_INVALID = 0,
        GNSS_FIX_QUALITY_GNSS_SPS = 1,
        GNSS_FIX_QUALITY_DGNSS = 2,
        GNSS_FIX_QUALITY_GNSS_PPS = 3,
        GNSS_FIX_QUALITY_RTK = 4,
        GNSS_FIX_QUALITY_FLOAT_RTK = 5,
        GNSS_FIX_QUALITY_ESTIMATED = 6,
};

struct gnss_info {
        uint16_t satellites_cnt;
        uint32_t hdop;
        int32_t geoid_separation;
        enum gnss_fix_status fix_status;
        enum gnss_fix_quality fix_quality;
};

struct gnss_time {
        uint8_t hour;
        uint8_t minute;
        uint16_t millisecond;
        uint8_t month_day;
        uint8_t month;
        uint8_t century_year;
};


typedef int (*gnss_start_t)(const struct device *dev, enum gnss_start_mode mode);

typedef int (*gnss_stop_t)(const struct device *dev);

typedef int (*gnss_set_fix_rate_t)(const struct device *dev, uint32_t fix_interval_ms);

typedef int (*gnss_get_fix_rate_t)(const struct device *dev, uint32_t *fix_interval_ms);

typedef int (*gnss_set_navigation_mode_t)(const struct device *dev,
                                          enum gnss_navigation_mode mode);

typedef int (*gnss_get_navigation_mode_t)(const struct device *dev,
                                          enum gnss_navigation_mode *mode);

typedef int (*gnss_set_enabled_systems_t)(const struct device *dev, gnss_systems_t systems);

typedef int (*gnss_get_enabled_systems_t)(const struct device *dev, gnss_systems_t *systems);

typedef int (*gnss_get_supported_systems_t)(const struct device *dev, gnss_systems_t *systems);

typedef int (*gnss_get_latest_timepulse_t)(const struct device *dev, k_ticks_t *timestamp);

__subsystem struct gnss_driver_api {
        gnss_start_t start;
        gnss_stop_t stop;
        gnss_set_fix_rate_t set_fix_rate;
        gnss_get_fix_rate_t get_fix_rate;
        gnss_set_navigation_mode_t set_navigation_mode;
        gnss_get_navigation_mode_t get_navigation_mode;
        gnss_set_enabled_systems_t set_enabled_systems;
        gnss_get_enabled_systems_t get_enabled_systems;
        gnss_get_supported_systems_t get_supported_systems;
        gnss_get_latest_timepulse_t get_latest_timepulse;
};


struct gnss_data {
        struct navigation_data nav_data;
        struct gnss_info info;
        struct gnss_time utc;
};

typedef void (*gnss_data_callback_t)(const struct device *dev, const struct gnss_data *data);

struct gnss_data_callback {
        const struct device *dev;
        gnss_data_callback_t callback;
};

struct gnss_satellite {
        uint8_t prn;
        uint8_t snr;
        uint8_t elevation;
        uint16_t azimuth;
        enum gnss_system system;
        uint8_t is_tracked : 1;
        uint8_t is_corrected : 1;
};

typedef void (*gnss_satellites_callback_t)(const struct device *dev,
                                           const struct gnss_satellite *satellites,
                                           uint16_t size);

struct gnss_satellites_callback {
        const struct device *dev;
        gnss_satellites_callback_t callback;
};

__syscall int gnss_start(const struct device *dev, enum gnss_start_mode mode);
 
static inline int z_impl_gnss_start(const struct device *dev, enum gnss_start_mode mode)
{
        const struct gnss_driver_api *api = DEVICE_API_GET(gnss, dev);
 
        if (api->start == NULL) {
                return -ENOSYS;
        }
 
        return api->start(dev, mode);
}

__syscall int gnss_stop(const struct device *dev);
 
static inline int z_impl_gnss_stop(const struct device *dev)
{
        const struct gnss_driver_api *api = DEVICE_API_GET(gnss, dev);
 
        if (api->stop == NULL) {
                return -ENOSYS;
        }
 
        return api->stop(dev);
}

__syscall int gnss_set_fix_rate(const struct device *dev, uint32_t fix_interval_ms);
 
static inline int z_impl_gnss_set_fix_rate(const struct device *dev, uint32_t fix_interval_ms)
{
        const struct gnss_driver_api *api = DEVICE_API_GET(gnss, dev);
 
        if (api->set_fix_rate == NULL) {
                return -ENOSYS;
        }
 
        return api->set_fix_rate(dev, fix_interval_ms);
}

__syscall int gnss_get_fix_rate(const struct device *dev, uint32_t *fix_interval_ms);
 
static inline int z_impl_gnss_get_fix_rate(const struct device *dev, uint32_t *fix_interval_ms)
{
        const struct gnss_driver_api *api = DEVICE_API_GET(gnss, dev);
 
        if (api->get_fix_rate == NULL) {
                return -ENOSYS;
        }
 
        return api->get_fix_rate(dev, fix_interval_ms);
}

__syscall int gnss_set_navigation_mode(const struct device *dev,
                                       enum gnss_navigation_mode mode);
 
static inline int z_impl_gnss_set_navigation_mode(const struct device *dev,
                                                  enum gnss_navigation_mode mode)
{
        const struct gnss_driver_api *api = DEVICE_API_GET(gnss, dev);
 
        if (api->set_navigation_mode == NULL) {
                return -ENOSYS;
        }
 
        return api->set_navigation_mode(dev, mode);
}

__syscall int gnss_get_navigation_mode(const struct device *dev,
                                       enum gnss_navigation_mode *mode);
 
static inline int z_impl_gnss_get_navigation_mode(const struct device *dev,
                                                  enum gnss_navigation_mode *mode)
{
        const struct gnss_driver_api *api = DEVICE_API_GET(gnss, dev);
 
        if (api->get_navigation_mode == NULL) {
                return -ENOSYS;
        }
 
        return api->get_navigation_mode(dev, mode);
}

__syscall int gnss_set_enabled_systems(const struct device *dev, gnss_systems_t systems);
 
static inline int z_impl_gnss_set_enabled_systems(const struct device *dev,
                                                  gnss_systems_t systems)
{
        const struct gnss_driver_api *api = DEVICE_API_GET(gnss, dev);
 
        if (api->set_enabled_systems == NULL) {
                return -ENOSYS;
        }
 
        return api->set_enabled_systems(dev, systems);
}

__syscall int gnss_get_enabled_systems(const struct device *dev, gnss_systems_t *systems);
 
static inline int z_impl_gnss_get_enabled_systems(const struct device *dev,
                                                  gnss_systems_t *systems)
{
        const struct gnss_driver_api *api = DEVICE_API_GET(gnss, dev);
 
        if (api->get_enabled_systems == NULL) {
                return -ENOSYS;
        }
 
        return api->get_enabled_systems(dev, systems);
}

__syscall int gnss_get_supported_systems(const struct device *dev, gnss_systems_t *systems);
 
static inline int z_impl_gnss_get_supported_systems(const struct device *dev,
                                                    gnss_systems_t *systems)
{
        const struct gnss_driver_api *api = DEVICE_API_GET(gnss, dev);
 
        if (api->get_supported_systems == NULL) {
                return -ENOSYS;
        }
 
        return api->get_supported_systems(dev, systems);
}

__syscall int gnss_get_latest_timepulse(const struct device *dev, k_ticks_t *timestamp);
 
static inline int z_impl_gnss_get_latest_timepulse(const struct device *dev,
                                                    k_ticks_t *timestamp)
{
        const struct gnss_driver_api *api = DEVICE_API_GET(gnss, dev);
 
        if (api->get_latest_timepulse == NULL) {
                return -ENOSYS;
        }
 
        return api->get_latest_timepulse(dev, timestamp);
}

#if CONFIG_GNSS
#define GNSS_DATA_CALLBACK_DEFINE(_dev, _callback)                                              \
        static const STRUCT_SECTION_ITERABLE(gnss_data_callback,                                \
                                             _gnss_data_callback__##_callback) = {              \
                .dev = _dev,                                                                    \
                .callback = _callback,                                                          \
        }

#define GNSS_DT_DATA_CALLBACK_DEFINE(_node_id, _callback)                                          \
        static const STRUCT_SECTION_ITERABLE(                                                      \
                gnss_data_callback,                                                                \
                CONCAT(_gnss_data_callback_, DT_DEP_ORD(_node_id), _, _callback)) = {              \
                .dev = DEVICE_DT_GET(_node_id),                                                    \
                .callback = _callback,                                                             \
        }
#else
#define GNSS_DATA_CALLBACK_DEFINE(_dev, _callback)
#define GNSS_DT_DATA_CALLBACK_DEFINE(_node_id, _callback)
#endif

#if CONFIG_GNSS_SATELLITES
#define GNSS_SATELLITES_CALLBACK_DEFINE(_dev, _callback)                                        \
        static const STRUCT_SECTION_ITERABLE(gnss_satellites_callback,                          \
                                             _gnss_satellites_callback__##_callback) = {        \
                .dev = _dev,                                                                    \
                .callback = _callback,                                                          \
        }

#define GNSS_DT_SATELLITES_CALLBACK_DEFINE(_node_id, _callback)                                    \
        static const STRUCT_SECTION_ITERABLE(                                                      \
                gnss_satellites_callback,                                                          \
                CONCAT(_gnss_satellites_callback_, DT_DEP_ORD(_node_id), _, _callback)) = {        \
                .dev = DEVICE_DT_GET(_node_id),                                                    \
                .callback = _callback,                                                             \
        }
#else
#define GNSS_SATELLITES_CALLBACK_DEFINE(_dev, _callback)
#define GNSS_DT_SATELLITES_CALLBACK_DEFINE(_node_id, _callback)
#endif

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/gnss.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_GNSS_H_ */