OB2IMU.hpp

浏览该文件的文档.

#pragma once
 
#include "OB2Types.hpp"
 
extern "C" {
#include "h/ob2imu.h"
}
 
#include <functional>
 
namespace ob2 {
class device;
 
class imu_config {
public:
    imu_config(ob2_imu_config_t &&imu_config_handle) : m_imu_config_handle(imu_config_handle) {
        VALIDATE_NOT_NULL(m_imu_config_handle);
    }
 
    imu_config(imu_config &&config) : m_imu_config_handle(config.m_imu_config_handle) {
        VALIDATE_NOT_NULL(m_imu_config_handle);
        config.m_imu_config_handle = nullptr;
    }
 
    virtual ~imu_config() noexcept {
        ob2_status_t status;
        if(m_imu_config_handle != nullptr) {
            ob2_imu_config_release(m_imu_config_handle, &status);
        }
    }
 
    virtual void set_accel_stream_profile(const ob2_accel_stream_profile_t &stream_profile) {
        ob2_status_t status;
        ob2_imu_config_set_accel_stream_profile(m_imu_config_handle, &stream_profile, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void enable_accel_stream() {
        ob2_status_t status;
        ob2_imu_config_enable_accel_stream(m_imu_config_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void disable_accel_stream() {
        ob2_status_t status;
        ob2_imu_config_disable_accel_stream(m_imu_config_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_gyro_stream_profile(const ob2_gyro_stream_profile_t &stream_profile) {
        ob2_status_t status;
        ob2_imu_config_set_gyro_stream_profile(m_imu_config_handle, &stream_profile, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void enable_gyro_stream(ob2_enable_ctrl_t enable) {
        ob2_status_t status;
        ob2_imu_config_enable_gyro_stream(m_imu_config_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void disable_gyro_stream(ob2_enable_ctrl_t enable) {
        ob2_status_t status;
        ob2_imu_config_disable_gyro_stream(m_imu_config_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual ob2_imu_config_t get_handle() {
        return m_imu_config_handle;
    }
 
protected:
    ob2_imu_config_t m_imu_config_handle;
};
 
class imu_sample {
public:
    imu_sample(ob2_imu_sample_t &&imu_sample_handle) : m_imu_sample_handle(imu_sample_handle) {
        VALIDATE_NOT_NULL(m_imu_sample_handle);
    }
 
    imu_sample(imu_sample &&sample) : m_imu_sample_handle(sample.m_imu_sample_handle) {
        VALIDATE_NOT_NULL(m_imu_sample_handle);
        sample.m_imu_sample_handle = nullptr;
    }
 
    virtual ~imu_sample() noexcept {
        ob2_status_t status;
        if(m_imu_sample_handle != nullptr) {
            ob2_imu_sample_release(m_imu_sample_handle, &status);
        }
    }
 
    virtual uint32_t get_accel_sample_count() {
        ob2_status_t status;
        auto         count = ob2_imu_sample_get_accel_sample_count(m_imu_sample_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return count;
    }
 
    virtual ob2_accel_sample_t get_accel_sample(uint32_t index) {
        ob2_status_t status;
        auto         sample = ob2_imu_sample_get_accel_sample(m_imu_sample_handle, index, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return sample;
    }
 
    virtual uint32_t get_gyro_sample_count() {
        ob2_status_t status;
        auto         count = ob2_imu_sample_get_gyro_sample_count(m_imu_sample_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return count;
    }
 
    virtual ob2_gyro_sample_t get_gyro_sample(uint32_t index) {
        ob2_status_t status;
        auto         sample = ob2_imu_sample_get_gyro_sample(m_imu_sample_handle, index, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return sample;
    }
 
    virtual ob2_imu_sample_t get_handle() {
        return m_imu_sample_handle;
    }
 
protected:
    ob2_imu_sample_t m_imu_sample_handle;
};
 
typedef std::function<void(std::shared_ptr<imu_sample>)> imu_sample_cb;
 
}  // namespace ob2