imu.h

Go to the documentation of this file.

 
#ifndef INFUSE_SDK_INCLUDE_INFUSE_DRIVERS_IMU_H_
#define INFUSE_SDK_INCLUDE_INFUSE_DRIVERS_IMU_H_
 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct imu_config {
        struct {
                uint16_t sample_rate_hz;
                uint8_t full_scale_range;
                bool low_power;
        } accelerometer;
        struct {
                uint16_t sample_rate_hz;
                uint16_t full_scale_range;
                bool low_power;
        } gyroscope;
        struct {
                uint16_t sample_rate_hz;
        } magnetometer;
        uint16_t fifo_sample_buffer;
};
 
struct imu_config_output {
        uint32_t accelerometer_period_us;
        uint32_t gyroscope_period_us;
        uint32_t magnetometer_period_us;
        uint32_t expected_interrupt_period_us;
};
 
struct imu_sample {
        int16_t x;
        int16_t y;
        int16_t z;
} __packed;
 
struct imu_sensor_meta {
        int64_t timestamp_ticks;
        uint32_t buffer_period_ticks;
        uint16_t full_scale_range;
        uint16_t offset;
        uint16_t num;
};
 
struct imu_sample_array {
        struct imu_sensor_meta accelerometer;
        struct imu_sensor_meta gyroscope;
        struct imu_sensor_meta magnetometer;
        struct imu_sample samples[];
};
 
#define IMU_SAMPLE_ARRAY_TYPE_DEFINE(type_name, max_samples)                                       \
        struct type_name {                                                                         \
                struct imu_sample_array header;                                                    \
                struct imu_sample samples[max_samples];                                            \
        }
 
#define IMU_SAMPLE_ARRAY_CREATE(name, max_samples)                                                 \
        IMU_SAMPLE_ARRAY_TYPE_DEFINE(_anon_t_##name, max_samples);                                 \
        static struct _anon_t_##name _anon_##name;                                                 \
        static struct imu_sample_array *name = (void *)&_anon_##name
 
struct infuse_imu_api {
        int (*configure)(const struct device *dev, const struct imu_config *config,
                         struct imu_config_output *output);
        int (*data_wait)(const struct device *dev, k_timeout_t timeout);
        int (*data_read)(const struct device *dev, struct imu_sample_array *samples,
                         uint16_t max_samples);
#if defined(CONFIG_INFUSE_IMU_SELF_TEST) || defined(__DOXYGEN__)
        int (*self_test)(const struct device *dev);
#endif /* defined(CONFIG_INFUSE_IMU_SELF_TEST) || defined(__DOXYGEN__) */
};
 
static inline int imu_configure(const struct device *dev, const struct imu_config *config,
                                struct imu_config_output *output)
{
        const struct infuse_imu_api *api = dev->api;
 
        return api->configure(dev, config, output);
}
 
static inline int imu_data_wait(const struct device *dev, k_timeout_t timeout)
{
        const struct infuse_imu_api *api = dev->api;
 
        return api->data_wait(dev, timeout);
}
 
static inline int imu_data_read(const struct device *dev, struct imu_sample_array *samples,
                                uint16_t max_samples)
{
        const struct infuse_imu_api *api = dev->api;
 
        return api->data_read(dev, samples, max_samples);
}
 
#if defined(CONFIG_INFUSE_IMU_SELF_TEST) || defined(__DOXYGEN__)
static inline int imu_self_test(const struct device *dev)
{
        const struct infuse_imu_api *api = dev->api;
 
        if (api->self_test == NULL) {
                return -ENOTSUP;
        }
        return api->self_test(dev);
}
#endif /* defined(CONFIG_INFUSE_IMU_SELF_TEST) || defined(__DOXYGEN__) */
 
static inline int16_t imu_accelerometer_1g(uint8_t full_scale)
{
        switch (full_scale) {
        case 2:
                return 16384;
        case 4:
                return 8192;
        case 8:
                return 4096;
        case 16:
                return 2048;
        default:
                return -1;
        }
}
 
static inline uint32_t imu_sample_period(const struct imu_sensor_meta *meta)
{
        if (meta->num < 2) {
                return 0;
        }
        return meta->buffer_period_ticks / (meta->num - 1);
}
 
static inline uint16_t imu_sample_rate(const struct imu_sensor_meta *meta)
{
        uint32_t period_us = k_ticks_to_us_near32(imu_sample_period(meta));
 
        if (period_us == 0) {
                return 0;
        }
        return 1000000 / period_us;
}
 
static inline k_ticks_t imu_sample_timestamp(const struct imu_sensor_meta *meta, uint8_t sample)
{
        if (meta->num < 2) {
                return meta->timestamp_ticks;
        }
        return meta->timestamp_ticks + (sample * meta->buffer_period_ticks / (meta->num - 1));
}
 
struct imu_linear_downsample_scaled_state {
        struct imu_sample last_sample;
        float *output_x;
        float *output_y;
        float *output_z;
        uint16_t output_size;
        uint16_t output_offset;
        int16_t scale;
        uint8_t freq_mult;
        uint8_t freq_div;
        uint8_t subsample_idx;
};
 
int imu_linear_downsample_scaled(struct imu_linear_downsample_scaled_state *state,
                                 const struct imu_sample *input, uint16_t num_input);
 
#ifdef __cplusplus
}
#endif
 
#endif /* INFUSE_SDK_INCLUDE_INFUSE_DRIVERS_IMU_H_ */