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>
 
#include <infuse/drivers/imu/data_types.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 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_ */