Cansat
/
esp32_BNO08x
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

turn-table calibration, refactoring

This commit is contained in:
myles-parfeniuk 2024-12-04 22:09:15 -08:00
parent 7af261c73c
commit ba00c4e689
61 changed files with 716 additions and 865 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.clang-format
View File

@ -26,7 +26,7 @@ SpaceAfterCStyleCast: true
CommentPragmas: '^[/!]<' CommentPragmas: '^[/!]<'
ColumnLimit: 100 ColumnLimit: 130
WrapComments: true WrapComments: true
AllowShortCommentsOnASingleLine: true AllowShortCommentsOnASingleLine: true
AlignConsecutiveComments: true AlignConsecutiveComments: true

163
include/BNO08x.hpp
View File

@ -43,11 +43,13 @@ class BNO08x
bool on(); bool on();
bool sleep(); bool sleep();
// sh2_startCal (cmd id 12, calibration) bool calibration_start(uint32_t period_us);
bool enable_dynamic_calibration(BNO08xCalSel sensor); bool calibration_end(sh2_CalStatus_t& status);
bool disable_dynamic_calibration(BNO08xCalSel sensor);
bool enable_autosave_dynamic_calibration(); bool dynamic_calibration_enable(BNO08xCalSel sensor);
bool disable_autosave_dynamic_calibration(); bool dynamic_calibration_disable(BNO08xCalSel sensor);
bool dynamic_calibration_autosave_enable();
bool dynamic_calibration_autosave_disable();
bool save_dynamic_calibration(); bool save_dynamic_calibration();
bool clear_dynamic_calibration(); bool clear_dynamic_calibration();
@ -65,27 +67,64 @@ class BNO08x
static const char* stability_to_str(BNO08xStability stability); static const char* stability_to_str(BNO08xStability stability);
static const char* accuracy_to_str(BNO08xAccuracy accuracy); static const char* accuracy_to_str(BNO08xAccuracy accuracy);
BNO08xRptAcceleration rpt_accelerometer; /// @brief Contains report implementations.
BNO08xRptLinearAcceleration rpt_linear_accelerometer; typedef struct bno08x_reports_t
BNO08xRptGravity rpt_gravity; {
BNO08xRptCalMagnetometer rpt_cal_magnetometer; BNO08xRptAcceleration accelerometer;
BNO08xRptUncalMagnetometer rpt_uncal_magnetometer; BNO08xRptLinearAcceleration linear_accelerometer;
BNO08xRptCalGyro rpt_cal_gyro; BNO08xRptGravity gravity;
BNO08xRptUncalGyro rpt_uncal_gyro; BNO08xRptCalMagnetometer cal_magnetometer;
BNO08xRptRV rpt_rv; BNO08xRptUncalMagnetometer uncal_magnetometer;
BNO08xRptGameRV rpt_rv_game; BNO08xRptCalGyro cal_gyro;
BNO08xRptARVRStabilizedRV rpt_rv_ARVR_stabilized; BNO08xRptUncalGyro uncal_gyro;
BNO08xRptARVRStabilizedGameRV rpt_rv_ARVR_stabilized_game; BNO08xRptRV rv;
BNO08xRptIGyroRV rpt_rv_gyro_integrated; BNO08xRptGameRV rv_game;
BNO08xRptRVGeomag rpt_rv_geomagnetic; BNO08xRptARVRStabilizedRV rv_ARVR_stabilized;
BNO08xRptRawMEMSGyro rpt_raw_gyro; BNO08xRptARVRStabilizedGameRV rv_ARVR_stabilized_game;
BNO08xRptRawMEMSAccelerometer rpt_raw_accelerometer; BNO08xRptIGyroRV rv_gyro_integrated;
BNO08xRptRawMEMSMagnetometer rpt_raw_magnetometer; BNO08xRptRVGeomag rv_geomagnetic;
BNO08xRptStepCounter rpt_step_counter; BNO08xRptRawMEMSGyro raw_gyro;
BNO08xRptActivityClassifier rpt_activity_classifier; BNO08xRptRawMEMSAccelerometer raw_accelerometer;
BNO08xStabilityClassifier rpt_stability_classifier; BNO08xRptRawMEMSMagnetometer raw_magnetometer;
BNO08xShakeDetector rpt_shake_detector; BNO08xRptStepCounter step_counter;
BNO08xTapDetector rpt_tap_detector; BNO08xRptActivityClassifier activity_classifier;
BNO08xRptStabilityClassifier stability_classifier;
BNO08xRptShakeDetector shake_detector;
BNO08xRptTapDetector tap_detector;
bno08x_reports_t(BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: accelerometer(SH2_ACCELEROMETER, BNO08xPrivateTypes::EVT_GRP_RPT_ACCELEROMETER_BIT, sync_ctx)
, linear_accelerometer(
SH2_LINEAR_ACCELERATION, BNO08xPrivateTypes::EVT_GRP_RPT_LINEAR_ACCELEROMETER_BIT, sync_ctx)
, gravity(SH2_GRAVITY, BNO08xPrivateTypes::EVT_GRP_RPT_GRAVITY_BIT, sync_ctx)
, cal_magnetometer(
SH2_MAGNETIC_FIELD_CALIBRATED, BNO08xPrivateTypes::EVT_GRP_RPT_CAL_MAGNETOMETER_BIT, sync_ctx)
, uncal_magnetometer(
SH2_MAGNETIC_FIELD_UNCALIBRATED, BNO08xPrivateTypes::EVT_GRP_RPT_UNCAL_MAGNETOMETER_BIT, sync_ctx)
, cal_gyro(SH2_GYROSCOPE_CALIBRATED, BNO08xPrivateTypes::EVT_GRP_RPT_CAL_GYRO_BIT, sync_ctx)
, uncal_gyro(SH2_GYROSCOPE_UNCALIBRATED, BNO08xPrivateTypes::EVT_GRP_RPT_UNCAL_GYRO_BIT, sync_ctx)
, rv(SH2_ROTATION_VECTOR, BNO08xPrivateTypes::EVT_GRP_RPT_RV_BIT, sync_ctx)
, rv_game(SH2_GAME_ROTATION_VECTOR, BNO08xPrivateTypes::EVT_GRP_RPT_RV_GAME_BIT, sync_ctx)
, rv_ARVR_stabilized(SH2_ARVR_STABILIZED_RV, BNO08xPrivateTypes::EVT_GRP_RPT_RV_ARVR_S_BIT, sync_ctx)
, rv_ARVR_stabilized_game(
SH2_ARVR_STABILIZED_GRV, BNO08xPrivateTypes::EVT_GRP_RPT_RV_ARVR_S_GAME_BIT, sync_ctx)
, rv_gyro_integrated(SH2_GYRO_INTEGRATED_RV, BNO08xPrivateTypes::EVT_GRP_RPT_GYRO_INTEGRATED_RV_BIT, sync_ctx)
, rv_geomagnetic(SH2_GEOMAGNETIC_ROTATION_VECTOR, BNO08xPrivateTypes::EVT_GRP_RPT_GEOMAG_RV_BIT, sync_ctx)
, raw_gyro(SH2_RAW_GYROSCOPE, BNO08xPrivateTypes::EVT_GRP_RPT_RAW_GYRO_BIT, sync_ctx)
, raw_accelerometer(SH2_RAW_ACCELEROMETER, BNO08xPrivateTypes::EVT_GRP_RPT_RAW_ACCELEROMETER_BIT, sync_ctx)
, raw_magnetometer(SH2_RAW_MAGNETOMETER, BNO08xPrivateTypes::EVT_GRP_RPT_RAW_MAGNETOMETER_BIT, sync_ctx)
, step_counter(SH2_STEP_COUNTER, BNO08xPrivateTypes::EVT_GRP_RPT_STEP_COUNTER_BIT, sync_ctx)
, activity_classifier(
SH2_PERSONAL_ACTIVITY_CLASSIFIER, BNO08xPrivateTypes::EVT_GRP_RPT_ACTIVITY_CLASSIFIER_BIT, sync_ctx)
, stability_classifier(
SH2_STABILITY_CLASSIFIER, BNO08xPrivateTypes::EVT_GRP_RPT_STABILITY_CLASSIFIER_BIT, sync_ctx)
, shake_detector(SH2_SHAKE_DETECTOR, BNO08xPrivateTypes::EVT_GRP_RPT_SHAKE_DETECTOR_BIT, sync_ctx)
, tap_detector(SH2_TAP_DETECTOR, BNO08xPrivateTypes::EVT_GRP_RPT_TAP_DETECTOR_BIT, sync_ctx)
{
}
} bno08x_reports_t;
bno08x_reports_t rpt;
private: private:
// data processing task // data processing task
@ -109,10 +148,6 @@ class BNO08x
static void cb_task_trampoline(void* arg); static void cb_task_trampoline(void* arg);
void cb_task(); void cb_task();
SemaphoreHandle_t
sh2_HAL_lock; ///<Mutex to prevent sh2 HAL lib functions from being accessed at same time.
SemaphoreHandle_t
data_lock; ///<Mutex to prevent user from reading data while data_proc_task() updates it, and vice versa.
SemaphoreHandle_t sem_kill_tasks; ///<Counting Semaphore to count amount of killed tasks. SemaphoreHandle_t sem_kill_tasks; ///<Counting Semaphore to count amount of killed tasks.
void lock_sh2_HAL(); void lock_sh2_HAL();
@ -149,18 +184,10 @@ class BNO08x
sh2_Hal_t sh2_HAL; ///< sh2 hardware abstraction layer struct for use with sh2 HAL lib. sh2_Hal_t sh2_HAL; ///< sh2 hardware abstraction layer struct for use with sh2 HAL lib.
EventGroupHandle_t
evt_grp_bno08x_task; ///<Event group for indicating various BNO08x related events between tasks.
EventGroupHandle_t
evt_grp_report_en; ///<Event group for indicating which reports are currently enabled.
EventGroupHandle_t
evt_grp_report_data_available; ///< Event group for indicating to BNO08xRpt::has_new_data() that a module received a new report.
QueueHandle_t QueueHandle_t
queue_rx_sensor_event; ///< Queue to send sensor events from sh2 HAL sensor event callback (BNO08xSH2HAL::sensor_event_cb()) to data_proc_task() queue_rx_sensor_event; ///< Queue to send sensor events from sh2 HAL sensor event callback (BNO08xSH2HAL::sensor_event_cb()) to data_proc_task()
QueueHandle_t QueueHandle_t queue_cb_report_id; ///< Queue to send report ID of most recent report to cb_task()
queue_cb_report_id; ///< Queue to send report ID of most recent report to cb_task()
bno08x_config_t imu_config{}; ///<IMU configuration settings bno08x_config_t imu_config{}; ///<IMU configuration settings
spi_bus_config_t bus_config{}; ///<SPI bus GPIO configuration settings spi_bus_config_t bus_config{}; ///<SPI bus GPIO configuration settings
@ -169,39 +196,33 @@ class BNO08x
spi_transaction_t spi_transaction{}; ///<SPI transaction handle spi_transaction_t spi_transaction{}; ///<SPI transaction handle
BNO08xPrivateTypes::bno08x_init_status_t BNO08xPrivateTypes::bno08x_init_status_t
init_status; ///<Initialization status of various functionality, used by deconstructor during cleanup, set during initialization. init_status; ///<Initialization status of various functionality, used by deconstructor during cleanup, set during initialization.
BNO08xPrivateTypes::bno08x_sync_ctx_t sync_ctx; ///< Holds context used to synchronize tasks and callback execution.
sh2_ProductIds_t sh2_ProductIds_t product_IDs; ///< Product ID info returned IMU at initialization, can be viewed with print_product_ids()
product_IDs; ///< Product ID info returned IMU at initialization, can be viewed with print_product_ids()
BNO08xPrivateTypes::bno08x_cb_list_t cb_list; ///< Vector to contain registered callbacks.
etl::vector<uint8_t, TOTAL_RPT_COUNT>
en_report_ids; ///< Vector to contain IDs of currently enabled reports
// clang-format off // clang-format off
etl::map<uint8_t, BNO08xRpt*, TOTAL_RPT_COUNT, etl::less<uint8_t>> usr_reports = etl::map<uint8_t, BNO08xRpt*, TOTAL_RPT_COUNT, etl::less<uint8_t>> usr_reports =
{ {
{SH2_ACCELEROMETER, &rpt_accelerometer}, {SH2_ACCELEROMETER, &rpt.accelerometer},
{SH2_LINEAR_ACCELERATION, &rpt_linear_accelerometer}, {SH2_LINEAR_ACCELERATION, &rpt.linear_accelerometer},
{SH2_GRAVITY, &rpt_gravity}, {SH2_GRAVITY, &rpt.gravity},
{SH2_MAGNETIC_FIELD_CALIBRATED, &rpt_cal_magnetometer}, {SH2_MAGNETIC_FIELD_CALIBRATED, &rpt.cal_magnetometer},
{SH2_MAGNETIC_FIELD_UNCALIBRATED, &rpt_uncal_magnetometer}, {SH2_MAGNETIC_FIELD_UNCALIBRATED, &rpt.uncal_magnetometer},
{SH2_GYROSCOPE_CALIBRATED, &rpt_cal_gyro}, {SH2_GYROSCOPE_CALIBRATED, &rpt.cal_gyro},
{SH2_GYROSCOPE_UNCALIBRATED, &rpt_uncal_gyro}, {SH2_GYROSCOPE_UNCALIBRATED, &rpt.uncal_gyro},
{SH2_ROTATION_VECTOR, &rpt_rv}, {SH2_ROTATION_VECTOR, &rpt.rv},
{SH2_GAME_ROTATION_VECTOR, &rpt_rv_game}, {SH2_GAME_ROTATION_VECTOR, &rpt.rv_game},
{SH2_ARVR_STABILIZED_RV, &rpt_rv_ARVR_stabilized}, {SH2_ARVR_STABILIZED_RV, &rpt.rv_ARVR_stabilized},
{SH2_ARVR_STABILIZED_GRV, &rpt_rv_ARVR_stabilized_game}, {SH2_ARVR_STABILIZED_GRV, &rpt.rv_ARVR_stabilized_game},
{SH2_GYRO_INTEGRATED_RV, &rpt_rv_gyro_integrated}, {SH2_GYRO_INTEGRATED_RV, &rpt.rv_gyro_integrated},
{SH2_GEOMAGNETIC_ROTATION_VECTOR, &rpt_rv_geomagnetic}, {SH2_GEOMAGNETIC_ROTATION_VECTOR, &rpt.rv_geomagnetic},
{SH2_RAW_GYROSCOPE, &rpt_raw_gyro}, {SH2_RAW_GYROSCOPE, &rpt.raw_gyro},
{SH2_RAW_ACCELEROMETER, &rpt_raw_accelerometer}, {SH2_RAW_ACCELEROMETER, &rpt.raw_accelerometer},
{SH2_RAW_MAGNETOMETER, &rpt_raw_magnetometer}, {SH2_RAW_MAGNETOMETER, &rpt.raw_magnetometer},
{SH2_STEP_COUNTER, &rpt_step_counter}, {SH2_STEP_COUNTER, &rpt.step_counter},
{SH2_PERSONAL_ACTIVITY_CLASSIFIER, &rpt_activity_classifier}, {SH2_PERSONAL_ACTIVITY_CLASSIFIER, &rpt.activity_classifier},
{SH2_STABILITY_CLASSIFIER, &rpt_stability_classifier}, {SH2_STABILITY_CLASSIFIER, &rpt.stability_classifier},
{SH2_SHAKE_DETECTOR, &rpt_shake_detector}, {SH2_SHAKE_DETECTOR, &rpt.shake_detector},
{SH2_TAP_DETECTOR, &rpt_tap_detector}, {SH2_TAP_DETECTOR, &rpt.tap_detector},
// not implemented, see include/report for existing implementations to add your own // not implemented, see include/report for existing implementations to add your own
{SH2_PRESSURE, nullptr}, // requires auxilary i2c sensor {SH2_PRESSURE, nullptr}, // requires auxilary i2c sensor
@ -225,8 +246,7 @@ class BNO08x
static void IRAM_ATTR hint_handler(void* arg); static void IRAM_ATTR hint_handler(void* arg);
static const constexpr uint16_t RX_DATA_LENGTH = static const constexpr uint16_t RX_DATA_LENGTH = 300U; ///<length buffer containing data received over spi
300U; ///<length buffer containing data received over spi
static const constexpr TickType_t HOST_INT_TIMEOUT_DEFAULT_MS = static const constexpr TickType_t HOST_INT_TIMEOUT_DEFAULT_MS =
CONFIG_ESP32_BNO08X_HINT_TIMEOUT_MS / CONFIG_ESP32_BNO08X_HINT_TIMEOUT_MS /
@ -240,8 +260,7 @@ class BNO08x
CONFIG_ESP32_BNO08X_HARD_RESET_DELAY_MS / CONFIG_ESP32_BNO08X_HARD_RESET_DELAY_MS /
portTICK_PERIOD_MS; ///<How long RST pin is held low during hard reset (min 10ns according to datasheet, but should be longer for stable operation) portTICK_PERIOD_MS; ///<How long RST pin is held low during hard reset (min 10ns according to datasheet, but should be longer for stable operation)
static const constexpr uint32_t SCLK_MAX_SPEED = static const constexpr uint32_t SCLK_MAX_SPEED = 3000000UL; ///<Max SPI SCLK speed BNO08x is capable of.
3000000UL; ///<Max SPI SCLK speed BNO08x is capable of.
static const constexpr char* TAG = "BNO08x"; ///< Class tag used for serial print statements static const constexpr char* TAG = "BNO08x"; ///< Class tag used for serial print statements

8
include/BNO08xGlobalTypes.hpp
View File

@ -64,9 +64,8 @@ typedef struct bno08x_config_t
} }
/// @brief Overloaded IMU configuration settings constructor for custom pin settings /// @brief Overloaded IMU configuration settings constructor for custom pin settings
bno08x_config_t(spi_host_device_t spi_peripheral, gpio_num_t io_mosi, gpio_num_t io_miso, bno08x_config_t(spi_host_device_t spi_peripheral, gpio_num_t io_mosi, gpio_num_t io_miso, gpio_num_t io_sclk,
gpio_num_t io_sclk, gpio_num_t io_cs, gpio_num_t io_int, gpio_num_t io_rst, gpio_num_t io_cs, gpio_num_t io_int, gpio_num_t io_rst, uint32_t sclk_speed, bool install_isr_service = true)
uint32_t sclk_speed, bool install_isr_service = true)
: spi_peripheral(spi_peripheral) : spi_peripheral(spi_peripheral)
, io_mosi(io_mosi) , io_mosi(io_mosi)
, io_miso(io_miso) , io_miso(io_miso)
@ -801,5 +800,4 @@ typedef struct bno08x_meta_data_t
} }
} bno08x_meta_data_t; } bno08x_meta_data_t;
static const constexpr uint8_t TOTAL_RPT_COUNT = static const constexpr uint8_t TOTAL_RPT_COUNT = 38; ///< Amount of possible reports returned from BNO08x.
38; ///< Amount of possible reports returned from BNO08x.

125
include/BNO08xPrivateTypes.hpp
View File

@ -51,98 +51,61 @@ namespace BNO08xPrivateTypes
} }
} bno08x_init_status_t; } bno08x_init_status_t;
/// @brief Holds info used to initialize report modules. /// @brief Holds context used to synchronize tasks and callback execution.
typedef struct bno08x_report_info_t typedef struct bno08x_sync_ctx_t
{ {
uint8_t ID; SemaphoreHandle_t sh2_HAL_lock; ///<Mutex to prevent sh2 HAL lib functions from being accessed at same time.
EventBits_t rpt_bit; SemaphoreHandle_t
SemaphoreHandle_t* _sh2_HAL_lock; data_lock; ///<Mutex to prevent user from reading data while data_proc_task() updates it, and vice versa.
SemaphoreHandle_t* _data_lock; EventGroupHandle_t evt_grp_rpt_en; ///<Event group for indicating which reports are currently enabled.
EventGroupHandle_t* _evt_grp_rpt_en; EventGroupHandle_t
EventGroupHandle_t* _evt_grp_rpt_data_available; evt_grp_rpt_data_available; ///< Event group for indicating to BNO08xRpt::has_new_data() that a module received a new report.
EventGroupHandle_t* _evt_grp_bno08x_task; EventGroupHandle_t evt_grp_task; ///<Event group for indicating various BNO08x related events between tasks.
etl::vector<uint8_t, TOTAL_RPT_COUNT>* _en_report_ids; etl::vector<uint8_t, TOTAL_RPT_COUNT> en_report_ids; ///< Vector to contain IDs of currently enabled reports
bno08x_cb_list_t* _cb_list; bno08x_cb_list_t cb_list; ///< Vector to contain registered callbacks.
bno08x_report_info_t(uint8_t ID, EventBits_t rpt_bit, SemaphoreHandle_t* _sh2_HAL_lock, bno08x_sync_ctx_t()
SemaphoreHandle_t* _data_lock, EventGroupHandle_t* _evt_grp_rpt_en, : sh2_HAL_lock(xSemaphoreCreateMutex())
EventGroupHandle_t* _evt_grp_rpt_data_available, , data_lock(xSemaphoreCreateMutex())
EventGroupHandle_t* _evt_grp_bno08x_task, , evt_grp_rpt_en(xEventGroupCreate())
etl::vector<uint8_t, TOTAL_RPT_COUNT>* _en_report_ids, , evt_grp_rpt_data_available(xEventGroupCreate())
bno08x_cb_list_t* _cb_list) , evt_grp_task(xEventGroupCreate())
: ID(ID)
, rpt_bit(rpt_bit)
, _sh2_HAL_lock(_sh2_HAL_lock)
, _data_lock(_data_lock)
, _evt_grp_rpt_en(_evt_grp_rpt_en)
, _evt_grp_rpt_data_available(_evt_grp_rpt_data_available)
, _evt_grp_bno08x_task(_evt_grp_bno08x_task)
, _en_report_ids(_en_report_ids)
, _cb_list(_cb_list)
{ {
} }
} bno08x_report_info_t; } bno08x_sync_ctx_t;
inline static sh2_SensorConfig default_sensor_cfg = {.changeSensitivityEnabled = false, ///<TODO
.changeSensitivityRelative = false,
.wakeupEnabled = false,
.alwaysOnEnabled = false,
.changeSensitivity = 0,
.reportInterval_us = 0,
.batchInterval_us = 0,
.sensorSpecific = 0};
/// @brief Bits for evt_grp_rpt_en & evt_grp_rpt_data_available /// @brief Bits for evt_grp_rpt_en & evt_grp_rpt_data_available
enum bno08x_rpt_bit_t : EventBits_t enum bno08x_rpt_bit_t : EventBits_t
{ {
EVT_GRP_RPT_RV_BIT = (1UL << 0U), ///< When set, rotation vector reports are active. EVT_GRP_RPT_RV_BIT = (1UL << 0U), ///< When set, rotation vector reports are active.
EVT_GRP_RPT_RV_GAME_BIT = EVT_GRP_RPT_RV_GAME_BIT = (1UL << 1U), ///< When set, game rotation vector reports are active.
(1UL << 1U), ///< When set, game rotation vector reports are active. EVT_GRP_RPT_RV_ARVR_S_BIT = (1UL << 2U), ///< When set, ARVR stabilized rotation vector reports are active.
EVT_GRP_RPT_RV_ARVR_S_BIT = EVT_GRP_RPT_RV_ARVR_S_GAME_BIT = (1UL << 3U), ///< When set, ARVR stabilized game rotation vector reports are active.
(1UL << 2U), ///< When set, ARVR stabilized rotation vector reports are active. EVT_GRP_RPT_GYRO_INTEGRATED_RV_BIT = (1UL << 4U), ///< When set, gyro integrator rotation vector reports are active.
EVT_GRP_RPT_RV_ARVR_S_GAME_BIT = EVT_GRP_RPT_GEOMAG_RV_BIT = (1UL << 5U), ///< When set, geomagnetic rotation vector reports are active.
(1UL << 3U), ///< When set, ARVR stabilized game rotation vector reports are active. EVT_GRP_RPT_ACCELEROMETER_BIT = (1UL << 6U), ///< When set, accelerometer reports are active.
EVT_GRP_RPT_GYRO_INTEGRATED_RV_BIT = EVT_GRP_RPT_LINEAR_ACCELEROMETER_BIT = (1UL << 7U), ///< When set, linear accelerometer reports are active.
(1UL << 4U), ///< When set, gyro integrator rotation vector reports are active.
EVT_GRP_RPT_GEOMAG_RV_BIT =
(1UL << 5U), ///< When set, geomagnetic rotation vector reports are active.
EVT_GRP_RPT_ACCELEROMETER_BIT =
(1UL << 6U), ///< When set, accelerometer reports are active.
EVT_GRP_RPT_LINEAR_ACCELEROMETER_BIT =
(1UL << 7U), ///< When set, linear accelerometer reports are active.
EVT_GRP_RPT_GRAVITY_BIT = (1UL << 8U), ///< When set, gravity reports are active. EVT_GRP_RPT_GRAVITY_BIT = (1UL << 8U), ///< When set, gravity reports are active.
EVT_GRP_RPT_CAL_GYRO_BIT = (1UL << 9U), ///< When set, calibrated gyro reports are active. EVT_GRP_RPT_CAL_GYRO_BIT = (1UL << 9U), ///< When set, calibrated gyro reports are active.
EVT_GRP_RPT_UNCAL_GYRO_BIT = EVT_GRP_RPT_UNCAL_GYRO_BIT = (1UL << 10U), ///< When set, uncalibrated gyro reports are active.
(1UL << 10U), ///< When set, uncalibrated gyro reports are active. EVT_GRP_RPT_CAL_MAGNETOMETER_BIT = (1UL << 11U), ///< When set, calibrated magnetometer reports are active.
EVT_GRP_RPT_CAL_MAGNETOMETER_BIT = EVT_GRP_RPT_UNCAL_MAGNETOMETER_BIT = (1UL << 12U), ///< When set, uncalibrated magnetometer reports are active.
(1UL << 11U), ///< When set, calibrated magnetometer reports are active.
EVT_GRP_RPT_UNCAL_MAGNETOMETER_BIT =
(1UL << 12U), ///< When set, uncalibrated magnetometer reports are active.
EVT_GRP_RPT_TAP_DETECTOR_BIT = (1UL << 13U), ///< When set, tap detector reports are active. EVT_GRP_RPT_TAP_DETECTOR_BIT = (1UL << 13U), ///< When set, tap detector reports are active.
EVT_GRP_RPT_STEP_COUNTER_BIT = (1UL << 14U), ///< When set, step counter reports are active. EVT_GRP_RPT_STEP_COUNTER_BIT = (1UL << 14U), ///< When set, step counter reports are active.
EVT_GRP_RPT_STABILITY_CLASSIFIER_BIT = EVT_GRP_RPT_STABILITY_CLASSIFIER_BIT = (1UL << 15U), ///< When set, stability classifier reports are active.
(1UL << 15U), ///< When set, stability classifier reports are active. EVT_GRP_RPT_ACTIVITY_CLASSIFIER_BIT = (1UL << 16U), ///< When set, activity classifier reports are active.
EVT_GRP_RPT_ACTIVITY_CLASSIFIER_BIT = EVT_GRP_RPT_SHAKE_DETECTOR_BIT = (1UL << 17U), ///< When set, shake detector reports are active.
(1UL << 16U), ///< When set, activity classifier reports are active. EVT_GRP_RPT_RAW_ACCELEROMETER_BIT = (1UL << 18U), ///< When set, raw accelerometer reports are active.
EVT_GRP_RPT_SHAKE_DETECTOR_BIT =
(1UL << 17U), ///< When set, shake detector reports are active.
EVT_GRP_RPT_RAW_ACCELEROMETER_BIT =
(1UL << 18U), ///< When set, raw accelerometer reports are active.
EVT_GRP_RPT_RAW_GYRO_BIT = (1UL << 19U), ///< When set, raw gyro reports are active. EVT_GRP_RPT_RAW_GYRO_BIT = (1UL << 19U), ///< When set, raw gyro reports are active.
EVT_GRP_RPT_RAW_MAGNETOMETER_BIT = EVT_GRP_RPT_RAW_MAGNETOMETER_BIT = (1UL << 20U), ///< When set, raw magnetometer reports are active.
(1UL << 20U), ///< When set, raw magnetometer reports are active.
EVT_GRP_RPT_ALL = EVT_GRP_RPT_RV_BIT | EVT_GRP_RPT_RV_GAME_BIT | EVT_GRP_RPT_RV_ARVR_S_BIT | EVT_GRP_RPT_ALL = EVT_GRP_RPT_RV_BIT | EVT_GRP_RPT_RV_GAME_BIT | EVT_GRP_RPT_RV_ARVR_S_BIT |
EVT_GRP_RPT_RV_ARVR_S_GAME_BIT | EVT_GRP_RPT_LINEAR_ACCELEROMETER_BIT | EVT_GRP_RPT_RV_ARVR_S_GAME_BIT | EVT_GRP_RPT_LINEAR_ACCELEROMETER_BIT | EVT_GRP_RPT_GRAVITY_BIT |
EVT_GRP_RPT_GRAVITY_BIT | EVT_GRP_RPT_CAL_GYRO_BIT | EVT_GRP_RPT_CAL_GYRO_BIT | EVT_GRP_RPT_UNCAL_GYRO_BIT | EVT_GRP_RPT_CAL_MAGNETOMETER_BIT |
EVT_GRP_RPT_UNCAL_GYRO_BIT | EVT_GRP_RPT_CAL_MAGNETOMETER_BIT | EVT_GRP_RPT_TAP_DETECTOR_BIT | EVT_GRP_RPT_STEP_COUNTER_BIT | EVT_GRP_RPT_STABILITY_CLASSIFIER_BIT |
EVT_GRP_RPT_TAP_DETECTOR_BIT | EVT_GRP_RPT_STEP_COUNTER_BIT | EVT_GRP_RPT_ACTIVITY_CLASSIFIER_BIT | EVT_GRP_RPT_RAW_ACCELEROMETER_BIT | EVT_GRP_RPT_RAW_GYRO_BIT |
EVT_GRP_RPT_STABILITY_CLASSIFIER_BIT | EVT_GRP_RPT_RAW_MAGNETOMETER_BIT | EVT_GRP_RPT_UNCAL_MAGNETOMETER_BIT | EVT_GRP_RPT_SHAKE_DETECTOR_BIT |
EVT_GRP_RPT_ACTIVITY_CLASSIFIER_BIT | EVT_GRP_RPT_RAW_ACCELEROMETER_BIT | EVT_GRP_RPT_ACCELEROMETER_BIT | EVT_GRP_RPT_GEOMAG_RV_BIT | EVT_GRP_RPT_GYRO_INTEGRATED_RV_BIT
EVT_GRP_RPT_RAW_GYRO_BIT | EVT_GRP_RPT_RAW_MAGNETOMETER_BIT |
EVT_GRP_RPT_UNCAL_MAGNETOMETER_BIT | EVT_GRP_RPT_SHAKE_DETECTOR_BIT |
EVT_GRP_RPT_ACCELEROMETER_BIT | EVT_GRP_RPT_GEOMAG_RV_BIT |
EVT_GRP_RPT_GYRO_INTEGRATED_RV_BIT
}; };
/// @brief Bits for evt_grp_bno08x_task /// @brief Bits for evt_grp_bno08x_task
@ -157,4 +120,14 @@ namespace BNO08xPrivateTypes
EVT_GRP_BNO08x_TASK_DATA_AVAILABLE = EVT_GRP_BNO08x_TASK_DATA_AVAILABLE =
(1UL << 3U) ///< When this bit is set it indicates a report has been received for the user to read, cleared in data_available() set/cleared in handle_sensor_report(). (1UL << 3U) ///< When this bit is set it indicates a report has been received for the user to read, cleared in data_available() set/cleared in handle_sensor_report().
}; };
inline static sh2_SensorConfig default_sensor_cfg = { ///<Default sensor config passed to enable report functions.
.changeSensitivityEnabled = false,
.changeSensitivityRelative = false,
.wakeupEnabled = false,
.alwaysOnEnabled = false,
.changeSensitivity = 0,
.reportInterval_us = 0,
.batchInterval_us = 0,
.sensorSpecific = 0};
}; // namespace BNO08xPrivateTypes }; // namespace BNO08xPrivateTypes

3
include/BNO08xSH2HAL.hpp
View File

@ -58,8 +58,7 @@
* @return Length of SHTP packet. * @return Length of SHTP packet.
*/ */
#define PARSE_PACKET_LENGTH(header) \ #define PARSE_PACKET_LENGTH(header) \
(UINT16_CLR_LSB(static_cast<uint16_t>(header[1]) << 8U) | \ (UINT16_CLR_LSB(static_cast<uint16_t>(header[1]) << 8U) | UINT16_CLR_MSB(static_cast<uint16_t>(header[0])))
UINT16_CLR_MSB(static_cast<uint16_t>(header[0])))
// forward dec to prevent compile errors // forward dec to prevent compile errors
class BNO08x; class BNO08x;

3
include/BNO08xTestHelper.hpp
View File

@ -31,8 +31,7 @@ class BNO08xTestHelper
*/ */
static void print_test_start_banner(const char* TEST_TAG) static void print_test_start_banner(const char* TEST_TAG)
{ {
printf("------------------------ BEGIN TEST: %s ------------------------\n\r", printf("------------------------ BEGIN TEST: %s ------------------------\n\r", TEST_TAG);
TEST_TAG);
} }
/** /**

6
include/BNO08xTestSuite.hpp
View File

@ -21,14 +21,12 @@ class BNO08xTestSuite
private: private:
static void print_begin_tests_banner(const char* test_set_name) static void print_begin_tests_banner(const char* test_set_name)
{ {
printf("####################### BEGIN TESTS: %s #######################\n\r", printf("####################### BEGIN TESTS: %s #######################\n\r", test_set_name);
test_set_name);
} }
static void print_end_tests_banner(const char* test_set_name) static void print_end_tests_banner(const char* test_set_name)
{ {
printf("####################### END TESTS: %s #######################\n\r", printf("####################### END TESTS: %s #######################\n\r", test_set_name);
test_set_name);
} }
public: public:

6
include/report/BNO08xReports.hpp
View File

@ -18,6 +18,6 @@
#include "BNO08xRptRawMEMSMagnetometer.hpp" #include "BNO08xRptRawMEMSMagnetometer.hpp"
#include "BNO08xRptStepCounter.hpp" #include "BNO08xRptStepCounter.hpp"
#include "BNO08xRptActivityClassifier.hpp" #include "BNO08xRptActivityClassifier.hpp"
#include "BNO08xStabilityClassifier.hpp" #include "BNO08xRptStabilityClassifier.hpp"
#include "BNO08xShakeDetector.hpp" #include "BNO08xRptShakeDetector.hpp"
#include "BNO08xTapDetector.hpp" #include "BNO08xRptTapDetector.hpp"

42
include/report/BNO08xRpt.hpp
View File

@ -23,8 +23,7 @@
class BNO08xRpt class BNO08xRpt
{ {
public: public:
bool enable(uint32_t time_between_reports, bool enable(uint32_t time_between_reports, sh2_SensorConfig_t sensor_cfg = BNO08xPrivateTypes::default_sensor_cfg);
sh2_SensorConfig_t sensor_cfg = BNO08xPrivateTypes::default_sensor_cfg);
bool disable(sh2_SensorConfig_t sensor_cfg = BNO08xPrivateTypes::default_sensor_cfg); bool disable(sh2_SensorConfig_t sensor_cfg = BNO08xPrivateTypes::default_sensor_cfg);
bool register_cb(std::function<void(void)> cb_fxn); bool register_cb(std::function<void(void)> cb_fxn);
bool has_new_data(); bool has_new_data();
@ -33,25 +32,11 @@ class BNO08xRpt
bool clear_sample_counts(); bool clear_sample_counts();
bool get_meta_data(bno08x_meta_data_t& meta_data); bool get_meta_data(bno08x_meta_data_t& meta_data);
uint8_t ID; ///< Report ID, ex. SH2_ACCELERATION.
EventBits_t
rpt_bit; ///< Respective enable and data bit for report in BNO08x::evt_grp_report_en and BNO08x::evt_grp_report_data
uint32_t period_us; ///< The period/interval of the report in microseconds.
protected: protected:
SemaphoreHandle_t* uint8_t ID; ///< Report ID, ex. SH2_ACCELERATION.
_sh2_HAL_lock; ///<Mutex to prevent sh2 HAL lib functions from being accessed at same time. EventBits_t rpt_bit; ///< Respective enable and data bit for report in evt_grp_rpt_en and evt_grp_rpt_data
SemaphoreHandle_t* uint32_t period_us; ///< The period/interval of the report in microseconds.
_data_lock; ///<Mutex to prevent user from reading data while data_proc_task() updates it, and vice versa. BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx;
EventGroupHandle_t*
_evt_grp_rpt_en; ///<Event group for indicating which reports are currently enabled.
EventGroupHandle_t*
_evt_grp_rpt_data_available; ///< Event group for indicating to BNO08xRpt::has_new_data() that a module received a new report since the last time it was called (note this group is unaffected by data read through callbacks).
EventGroupHandle_t*
_evt_grp_bno08x_task; ///<Event group for indicating various BNO08x related events between tasks.
etl::vector<uint8_t, TOTAL_RPT_COUNT>*
_en_report_ids; ///< Vector to contain IDs of currently enabled reports
BNO08xPrivateTypes::bno08x_cb_list_t* _cb_list; ///< Vector to contain registered callbacks.
virtual void update_data(sh2_SensorValue_t* sensor_val) = 0; virtual void update_data(sh2_SensorValue_t* sensor_val) = 0;
@ -67,17 +52,11 @@ class BNO08xRpt
* *
* @return void, nothing to return * @return void, nothing to return
*/ */
BNO08xRpt(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRpt(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: ID(info.ID) : ID(ID)
, rpt_bit(info.rpt_bit) , rpt_bit(rpt_bit)
, period_us(0UL) , period_us(0UL)
, _sh2_HAL_lock(info._sh2_HAL_lock) , sync_ctx(sync_ctx)
, _data_lock(info._data_lock)
, _evt_grp_rpt_en(info._evt_grp_rpt_en)
, _evt_grp_rpt_data_available(info._evt_grp_rpt_data_available)
, _evt_grp_bno08x_task(info._evt_grp_bno08x_task)
, _en_report_ids(info._en_report_ids)
, _cb_list(info._cb_list)
{ {
} }
@ -89,8 +68,7 @@ class BNO08xRpt
void signal_data_available(); void signal_data_available();
static const constexpr float RAD_2_DEG = static const constexpr float RAD_2_DEG =
(180.0f / (180.0f / M_PI); ///< Constant for radian to degree conversions, sed in quaternion to euler function conversions.
M_PI); ///< Constant for radian to degree conversions, sed in quaternion to euler function conversions.
static const constexpr char* TAG = "BNO08xRpt"; static const constexpr char* TAG = "BNO08xRpt";

4
include/report/BNO08xRptARVRStabilizedGameRV.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptARVRStabilizedGameRV : public BNO08xRptRVGeneric class BNO08xRptARVRStabilizedGameRV : public BNO08xRptRVGeneric
{ {
public: public:
BNO08xRptARVRStabilizedGameRV(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptARVRStabilizedGameRV(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRptRVGeneric(info) : BNO08xRptRVGeneric(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptARVRStabilizedRV.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptARVRStabilizedRV : public BNO08xRptRVGeneric class BNO08xRptARVRStabilizedRV : public BNO08xRptRVGeneric
{ {
public: public:
BNO08xRptARVRStabilizedRV(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptARVRStabilizedRV(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRptRVGeneric(info) : BNO08xRptRVGeneric(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptAcceleration.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptAcceleration : public BNO08xRpt class BNO08xRptAcceleration : public BNO08xRpt
{ {
public: public:
BNO08xRptAcceleration(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptAcceleration(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

7
include/report/BNO08xRptActivityClassifier.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptActivityClassifier : public BNO08xRpt class BNO08xRptActivityClassifier : public BNO08xRpt
{ {
public: public:
BNO08xRptActivityClassifier(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptActivityClassifier(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }
@ -27,7 +27,6 @@ class BNO08xRptActivityClassifier : public BNO08xRpt
private: private:
void update_data(sh2_SensorValue_t* sensor_val) override; void update_data(sh2_SensorValue_t* sensor_val) override;
bno08x_activity_classifier_t bno08x_activity_classifier_t data; ///< Most recent report data, doesn't account for step rollover.
data; ///< Most recent report data, doesn't account for step rollover.
static const constexpr char* TAG = "BNO08xRptActivityClassifier"; static const constexpr char* TAG = "BNO08xRptActivityClassifier";
}; };

4
include/report/BNO08xRptCalGyro.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptCalGyro : public BNO08xRpt class BNO08xRptCalGyro : public BNO08xRpt
{ {
public: public:
BNO08xRptCalGyro(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptCalGyro(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptCalMagnetometer.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptCalMagnetometer : public BNO08xRpt class BNO08xRptCalMagnetometer : public BNO08xRpt
{ {
public: public:
BNO08xRptCalMagnetometer(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptCalMagnetometer(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptGameRV.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptGameRV : public BNO08xRptRVGeneric class BNO08xRptGameRV : public BNO08xRptRVGeneric
{ {
public: public:
BNO08xRptGameRV(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptGameRV(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRptRVGeneric(info) : BNO08xRptRVGeneric(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptGravity.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptGravity : public BNO08xRpt class BNO08xRptGravity : public BNO08xRpt
{ {
public: public:
BNO08xRptGravity(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptGravity(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptIGyroRV.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptIGyroRV : public BNO08xRptRVGeneric class BNO08xRptIGyroRV : public BNO08xRptRVGeneric
{ {
public: public:
BNO08xRptIGyroRV(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptIGyroRV(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRptRVGeneric(info) : BNO08xRptRVGeneric(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptLinearAcceleration.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptLinearAcceleration : public BNO08xRpt class BNO08xRptLinearAcceleration : public BNO08xRpt
{ {
public: public:
BNO08xRptLinearAcceleration(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptLinearAcceleration(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptRV.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptRV : public BNO08xRptRVGeneric class BNO08xRptRV : public BNO08xRptRVGeneric
{ {
public: public:
BNO08xRptRV(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptRV(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRptRVGeneric(info) : BNO08xRptRVGeneric(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptRVGeneric.hpp
View File

@ -19,8 +19,8 @@ class BNO08xRptRVGeneric : public BNO08xRpt
bno08x_euler_angle_t get_euler(bool in_degrees = true); bno08x_euler_angle_t get_euler(bool in_degrees = true);
protected: protected:
BNO08xRptRVGeneric(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptRVGeneric(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }
bool tare(bool x, bool y, bool z, sh2_TareBasis_t basis); bool tare(bool x, bool y, bool z, sh2_TareBasis_t basis);

4
include/report/BNO08xRptRVGeomag.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptRVGeomag : public BNO08xRptRVGeneric class BNO08xRptRVGeomag : public BNO08xRptRVGeneric
{ {
public: public:
BNO08xRptRVGeomag(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptRVGeomag(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRptRVGeneric(info) : BNO08xRptRVGeneric(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptRawMEMSAccelerometer.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptRawMEMSAccelerometer : public BNO08xRpt class BNO08xRptRawMEMSAccelerometer : public BNO08xRpt
{ {
public: public:
BNO08xRptRawMEMSAccelerometer(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptRawMEMSAccelerometer(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptRawMEMSGyro.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptRawMEMSGyro : public BNO08xRpt class BNO08xRptRawMEMSGyro : public BNO08xRpt
{ {
public: public:
BNO08xRptRawMEMSGyro(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptRawMEMSGyro(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptRawMEMSMagnetometer.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptRawMEMSMagnetometer : public BNO08xRpt class BNO08xRptRawMEMSMagnetometer : public BNO08xRpt
{ {
public: public:
BNO08xRptRawMEMSMagnetometer(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptRawMEMSMagnetometer(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

12
include/report/BNO08xShakeDetector.hpp → include/report/BNO08xRptShakeDetector.hpp
View File

@ -1,5 +1,5 @@
/** /**
* @file BNO08xShakeDetector.hpp * @file BNO08xRptShakeDetector.hpp
* @author Myles Parfeniuk * @author Myles Parfeniuk
*/ */
@ -8,15 +8,15 @@
#include "BNO08xRpt.hpp" #include "BNO08xRpt.hpp"
/** /**
* @class BNO08xShakeDetector * @class BNO08xRptShakeDetector
* *
* @brief Class to represent shake detector reports. (See Ref. Manual 6.5.32) * @brief Class to represent shake detector reports. (See Ref. Manual 6.5.32)
*/ */
class BNO08xShakeDetector : public BNO08xRpt class BNO08xRptShakeDetector : public BNO08xRpt
{ {
public: public:
BNO08xShakeDetector(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptShakeDetector(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }
@ -25,5 +25,5 @@ class BNO08xShakeDetector : public BNO08xRpt
private: private:
void update_data(sh2_SensorValue_t* sensor_val) override; void update_data(sh2_SensorValue_t* sensor_val) override;
bno08x_shake_detector_t data; bno08x_shake_detector_t data;
static const constexpr char* TAG = "BNO08xShakeDetector"; static const constexpr char* TAG = "BNO08xRptShakeDetector";
}; };

12
include/report/BNO08xStabilityClassifier.hpp → include/report/BNO08xRptStabilityClassifier.hpp
View File

@ -1,5 +1,5 @@
/** /**
* @file BNO08xStabilityClassifier.hpp * @file BNO08xRptStabilityClassifier.hpp
* @author Myles Parfeniuk * @author Myles Parfeniuk
*/ */
@ -8,15 +8,15 @@
#include "BNO08xRpt.hpp" #include "BNO08xRpt.hpp"
/** /**
* @class BNO08xStabilityClassifier * @class BNO08xRptStabilityClassifier
* *
* @brief Class to represent stability classifier reports. (See Ref. Manual 6.5.31) * @brief Class to represent stability classifier reports. (See Ref. Manual 6.5.31)
*/ */
class BNO08xStabilityClassifier : public BNO08xRpt class BNO08xRptStabilityClassifier : public BNO08xRpt
{ {
public: public:
BNO08xStabilityClassifier(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptStabilityClassifier(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }
@ -26,5 +26,5 @@ class BNO08xStabilityClassifier : public BNO08xRpt
private: private:
void update_data(sh2_SensorValue_t* sensor_val) override; void update_data(sh2_SensorValue_t* sensor_val) override;
bno08x_stability_classifier_t data; bno08x_stability_classifier_t data;
static const constexpr char* TAG = "BNO08xStabilityClassifier"; static const constexpr char* TAG = "BNO08xRptStabilityClassifier";
}; };

4
include/report/BNO08xRptStepCounter.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptStepCounter : public BNO08xRpt class BNO08xRptStepCounter : public BNO08xRpt
{ {
public: public:
BNO08xRptStepCounter(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptStepCounter(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

30
include/report/BNO08xRptTapDetector.hpp Normal file
View File

@ -0,0 +1,30 @@
/**
* @file BNO08xRptTapDetector.hpp
* @author Myles Parfeniuk
*/
#pragma once
#include "BNO08xRpt.hpp"
/**
* @class BNO08xRptTapDetector
*
* @brief Class to represent tap detector reports. (See Ref. Manual 6.5.27)
*/
class BNO08xRptTapDetector : public BNO08xRpt
{
public:
BNO08xRptTapDetector(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(ID, rpt_bit, sync_ctx)
{
}
bool enable(uint32_t time_between_reports, sh2_SensorConfig_t sensor_cfg = BNO08xPrivateTypes::default_sensor_cfg);
bno08x_tap_detector_t get();
private:
void update_data(sh2_SensorValue_t* sensor_val) override;
bno08x_tap_detector_t data;
static const constexpr char* TAG = "BNO08xRptTapDetector";
};

4
include/report/BNO08xRptUncalGyro.hpp
View File

@ -15,8 +15,8 @@
class BNO08xRptUncalGyro : public BNO08xRpt class BNO08xRptUncalGyro : public BNO08xRpt
{ {
public: public:
BNO08xRptUncalGyro(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptUncalGyro(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

4
include/report/BNO08xRptUncalMagnetometer.hpp
View File

@ -16,8 +16,8 @@
class BNO08xRptUncalMagnetometer : public BNO08xRpt class BNO08xRptUncalMagnetometer : public BNO08xRpt
{ {
public: public:
BNO08xRptUncalMagnetometer(BNO08xPrivateTypes::bno08x_report_info_t info) BNO08xRptUncalMagnetometer(uint8_t ID, EventBits_t rpt_bit, BNO08xPrivateTypes::bno08x_sync_ctx_t* sync_ctx)
: BNO08xRpt(info) : BNO08xRpt(ID, rpt_bit, sync_ctx)
{ {
} }

31
include/report/BNO08xTapDetector.hpp
View File

@ -1,31 +0,0 @@
/**
* @file BNO08xTapDetector.hpp
* @author Myles Parfeniuk
*/
#pragma once
#include "BNO08xRpt.hpp"
/**
* @class BNO08xTapDetector
*
* @brief Class to represent tap detector reports. (See Ref. Manual 6.5.27)
*/
class BNO08xTapDetector : public BNO08xRpt
{
public:
BNO08xTapDetector(BNO08xPrivateTypes::bno08x_report_info_t info)
: BNO08xRpt(info)
{
}
bool enable(uint32_t time_between_reports,
sh2_SensorConfig_t sensor_cfg = BNO08xPrivateTypes::default_sensor_cfg);
bno08x_tap_detector_t get();
private:
void update_data(sh2_SensorValue_t* sensor_val) override;
bno08x_tap_detector_t data;
static const constexpr char* TAG = "BNO08xTapDetector";
};

217
source/BNO08x.cpp
View File

@ -18,78 +18,11 @@ using namespace BNO08xPrivateTypes;
* @return void, nothing to return * @return void, nothing to return
*/ */
BNO08x::BNO08x(bno08x_config_t imu_config) BNO08x::BNO08x(bno08x_config_t imu_config)
: rpt_accelerometer(bno08x_report_info_t(SH2_ACCELEROMETER, EVT_GRP_RPT_ACCELEROMETER_BIT, : rpt(bno08x_reports_t(&sync_ctx))
&sh2_HAL_lock, &data_lock, &evt_grp_report_en, &evt_grp_report_data_available,
&evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_linear_accelerometer(bno08x_report_info_t(SH2_LINEAR_ACCELERATION,
EVT_GRP_RPT_LINEAR_ACCELEROMETER_BIT, &sh2_HAL_lock, &data_lock, &evt_grp_report_en,
&evt_grp_report_data_available, &evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_gravity(bno08x_report_info_t(SH2_GRAVITY, EVT_GRP_RPT_GRAVITY_BIT, &sh2_HAL_lock,
&data_lock, &evt_grp_report_en, &evt_grp_report_data_available, &evt_grp_bno08x_task,
&en_report_ids, &cb_list))
, rpt_cal_magnetometer(bno08x_report_info_t(SH2_MAGNETIC_FIELD_CALIBRATED,
EVT_GRP_RPT_CAL_MAGNETOMETER_BIT, &sh2_HAL_lock, &data_lock, &evt_grp_report_en,
&evt_grp_report_data_available, &evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_uncal_magnetometer(bno08x_report_info_t(SH2_MAGNETIC_FIELD_UNCALIBRATED,
EVT_GRP_RPT_UNCAL_MAGNETOMETER_BIT, &sh2_HAL_lock, &data_lock, &evt_grp_report_en,
&evt_grp_report_data_available, &evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_cal_gyro(bno08x_report_info_t(SH2_GYROSCOPE_CALIBRATED, EVT_GRP_RPT_CAL_GYRO_BIT,
&sh2_HAL_lock, &data_lock, &evt_grp_report_en, &evt_grp_report_data_available,
&evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_uncal_gyro(bno08x_report_info_t(SH2_GYROSCOPE_UNCALIBRATED, EVT_GRP_RPT_UNCAL_GYRO_BIT,
&sh2_HAL_lock, &data_lock, &evt_grp_report_en, &evt_grp_report_data_available,
&evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_rv(bno08x_report_info_t(SH2_ROTATION_VECTOR, EVT_GRP_RPT_RV_BIT, &sh2_HAL_lock,
&data_lock, &evt_grp_report_en, &evt_grp_report_data_available, &evt_grp_bno08x_task,
&en_report_ids, &cb_list))
, rpt_rv_game(bno08x_report_info_t(SH2_GAME_ROTATION_VECTOR, EVT_GRP_RPT_RV_GAME_BIT,
&sh2_HAL_lock, &data_lock, &evt_grp_report_en, &evt_grp_report_data_available,
&evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_rv_ARVR_stabilized(bno08x_report_info_t(SH2_ARVR_STABILIZED_RV, EVT_GRP_RPT_RV_ARVR_S_BIT,
&sh2_HAL_lock, &data_lock, &evt_grp_report_en, &evt_grp_report_data_available,
&evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_rv_ARVR_stabilized_game(bno08x_report_info_t(SH2_ARVR_STABILIZED_GRV,
EVT_GRP_RPT_RV_ARVR_S_GAME_BIT, &sh2_HAL_lock, &data_lock, &evt_grp_report_en,
&evt_grp_report_data_available, &evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_rv_gyro_integrated(bno08x_report_info_t(SH2_GYRO_INTEGRATED_RV,
EVT_GRP_RPT_GYRO_INTEGRATED_RV_BIT, &sh2_HAL_lock, &data_lock, &evt_grp_report_en,
&evt_grp_report_data_available, &evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_rv_geomagnetic(bno08x_report_info_t(SH2_GEOMAGNETIC_ROTATION_VECTOR,
EVT_GRP_RPT_GEOMAG_RV_BIT, &sh2_HAL_lock, &data_lock, &evt_grp_report_en,
&evt_grp_report_data_available, &evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_raw_gyro(bno08x_report_info_t(SH2_RAW_GYROSCOPE, EVT_GRP_RPT_RAW_GYRO_BIT, &sh2_HAL_lock,
&data_lock, &evt_grp_report_en, &evt_grp_report_data_available, &evt_grp_bno08x_task,
&en_report_ids, &cb_list))
, rpt_raw_accelerometer(bno08x_report_info_t(SH2_RAW_ACCELEROMETER,
EVT_GRP_RPT_RAW_ACCELEROMETER_BIT, &sh2_HAL_lock, &data_lock, &evt_grp_report_en,
&evt_grp_report_data_available, &evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_raw_magnetometer(bno08x_report_info_t(SH2_RAW_MAGNETOMETER,
EVT_GRP_RPT_RAW_MAGNETOMETER_BIT, &sh2_HAL_lock, &data_lock, &evt_grp_report_en,
&evt_grp_report_data_available, &evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_step_counter(bno08x_report_info_t(SH2_STEP_COUNTER, EVT_GRP_RPT_STEP_COUNTER_BIT,
&sh2_HAL_lock, &data_lock, &evt_grp_report_en, &evt_grp_report_data_available,
&evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_activity_classifier(bno08x_report_info_t(SH2_PERSONAL_ACTIVITY_CLASSIFIER,
EVT_GRP_RPT_ACTIVITY_CLASSIFIER_BIT, &sh2_HAL_lock, &data_lock, &evt_grp_report_en,
&evt_grp_report_data_available, &evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_stability_classifier(bno08x_report_info_t(SH2_STABILITY_CLASSIFIER,
EVT_GRP_RPT_STABILITY_CLASSIFIER_BIT, &sh2_HAL_lock, &data_lock, &evt_grp_report_en,
&evt_grp_report_data_available, &evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_shake_detector(bno08x_report_info_t(SH2_SHAKE_DETECTOR, EVT_GRP_RPT_SHAKE_DETECTOR_BIT,
&sh2_HAL_lock, &data_lock, &evt_grp_report_en, &evt_grp_report_data_available,
&evt_grp_bno08x_task, &en_report_ids, &cb_list))
, rpt_tap_detector(bno08x_report_info_t(SH2_TAP_DETECTOR, EVT_GRP_RPT_TAP_DETECTOR_BIT,
&sh2_HAL_lock, &data_lock, &evt_grp_report_en, &evt_grp_report_data_available,
&evt_grp_bno08x_task, &en_report_ids, &cb_list))
, data_proc_task_hdl(NULL) , data_proc_task_hdl(NULL)
, sh2_HAL_service_task_hdl(NULL) , sh2_HAL_service_task_hdl(NULL)
, cb_task_hdl(NULL) , cb_task_hdl(NULL)
, sh2_HAL_lock(xSemaphoreCreateMutex())
, data_lock(xSemaphoreCreateMutex())
, sem_kill_tasks(NULL) , sem_kill_tasks(NULL)
, evt_grp_bno08x_task(xEventGroupCreate())
, evt_grp_report_en(xEventGroupCreate())
, evt_grp_report_data_available(xEventGroupCreate())
, queue_rx_sensor_event(xQueueCreate(10, sizeof(sh2_SensorEvent_t))) , queue_rx_sensor_event(xQueueCreate(10, sizeof(sh2_SensorEvent_t)))
, queue_cb_report_id(xQueueCreate(CONFIG_ESP32_BNO08X_CB_QUEUE_SZ, sizeof(uint8_t))) , queue_cb_report_id(xQueueCreate(CONFIG_ESP32_BNO08X_CB_QUEUE_SZ, sizeof(uint8_t)))
, imu_config(imu_config) , imu_config(imu_config)
@ -121,15 +54,15 @@ BNO08x::~BNO08x()
ESP_ERROR_CHECK(deinit_gpio()); ESP_ERROR_CHECK(deinit_gpio());
// delete all semaphores // delete all semaphores
vSemaphoreDelete(sh2_HAL_lock); vSemaphoreDelete(sync_ctx.sh2_HAL_lock);
vSemaphoreDelete(data_lock); vSemaphoreDelete(sync_ctx.data_lock);
if (sem_kill_tasks != NULL) if (sem_kill_tasks != NULL)
vSemaphoreDelete(sem_kill_tasks); vSemaphoreDelete(sem_kill_tasks);
// delete event groups // delete event groups
vEventGroupDelete(evt_grp_bno08x_task); vEventGroupDelete(sync_ctx.evt_grp_task);
vEventGroupDelete(evt_grp_report_en); vEventGroupDelete(sync_ctx.evt_grp_rpt_en);
vEventGroupDelete(evt_grp_report_data_available); vEventGroupDelete(sync_ctx.evt_grp_rpt_data_available);
// delete all queues // delete all queues
vQueueDelete(queue_rx_sensor_event); vQueueDelete(queue_rx_sensor_event);
@ -219,7 +152,7 @@ void BNO08x::data_proc_task()
} }
queue_rx_success = xQueueReceive(queue_rx_sensor_event, &sensor_evt, portMAX_DELAY); queue_rx_success = xQueueReceive(queue_rx_sensor_event, &sensor_evt, portMAX_DELAY);
evt_grp_bno08x_task_bits = xEventGroupGetBits(evt_grp_bno08x_task); evt_grp_bno08x_task_bits = xEventGroupGetBits(sync_ctx.evt_grp_task);
} while (evt_grp_bno08x_task_bits & EVT_GRP_BNO08x_TASKS_RUNNING); } while (evt_grp_bno08x_task_bits & EVT_GRP_BNO08x_TASKS_RUNNING);
@ -275,9 +208,8 @@ void BNO08x::sh2_HAL_service_task()
unlock_sh2_HAL(); unlock_sh2_HAL();
} }
evt_grp_bno08x_task_bits = xEventGroupWaitBits(evt_grp_bno08x_task, evt_grp_bno08x_task_bits = xEventGroupWaitBits(sync_ctx.evt_grp_task,
EVT_GRP_BNO08x_TASK_HINT_ASSRT_BIT | EVT_GRP_BNO08x_TASK_RESET_OCCURRED, pdFALSE, EVT_GRP_BNO08x_TASK_HINT_ASSRT_BIT | EVT_GRP_BNO08x_TASK_RESET_OCCURRED, pdFALSE, pdFALSE, portMAX_DELAY);
pdFALSE, portMAX_DELAY);
} while (evt_grp_bno08x_task_bits & EVT_GRP_BNO08x_TASKS_RUNNING); } while (evt_grp_bno08x_task_bits & EVT_GRP_BNO08x_TASKS_RUNNING);
@ -314,7 +246,7 @@ void BNO08x::cb_task()
do do
{ {
// execute callbacks // execute callbacks
for (auto& cb_entry : cb_list) for (auto& cb_entry : sync_ctx.cb_list)
{ {
BNO08xCbGeneric* cb_ptr = nullptr; BNO08xCbGeneric* cb_ptr = nullptr;
@ -330,7 +262,7 @@ void BNO08x::cb_task()
xQueueReceive(queue_cb_report_id, &rpt_ID, portMAX_DELAY); xQueueReceive(queue_cb_report_id, &rpt_ID, portMAX_DELAY);
evt_grp_bno08x_task_bits = xEventGroupGetBits(evt_grp_bno08x_task); evt_grp_bno08x_task_bits = xEventGroupGetBits(sync_ctx.evt_grp_task);
} while (evt_grp_bno08x_task_bits & EVT_GRP_BNO08x_TASKS_RUNNING); } while (evt_grp_bno08x_task_bits & EVT_GRP_BNO08x_TASKS_RUNNING);
@ -346,7 +278,7 @@ void BNO08x::cb_task()
*/ */
void BNO08x::lock_sh2_HAL() void BNO08x::lock_sh2_HAL()
{ {
xSemaphoreTake(sh2_HAL_lock, portMAX_DELAY); xSemaphoreTake(sync_ctx.sh2_HAL_lock, portMAX_DELAY);
} }
/** /**
@ -356,7 +288,7 @@ void BNO08x::lock_sh2_HAL()
*/ */
void BNO08x::unlock_sh2_HAL() void BNO08x::unlock_sh2_HAL()
{ {
xSemaphoreGive(sh2_HAL_lock); xSemaphoreGive(sync_ctx.sh2_HAL_lock);
} }
/** /**
@ -366,7 +298,7 @@ void BNO08x::unlock_sh2_HAL()
*/ */
void BNO08x::lock_user_data() void BNO08x::lock_user_data()
{ {
xSemaphoreTake(data_lock, portMAX_DELAY); xSemaphoreTake(sync_ctx.data_lock, portMAX_DELAY);
} }
/** /**
@ -376,7 +308,7 @@ void BNO08x::lock_user_data()
*/ */
void BNO08x::unlock_user_data() void BNO08x::unlock_user_data()
{ {
xSemaphoreGive(data_lock); xSemaphoreGive(sync_ctx.data_lock);
} }
/** /**
@ -398,12 +330,12 @@ void BNO08x::handle_sensor_report(sh2_SensorValue_t* sensor_val)
return; return;
// send report ids to cb_task for callback execution (only if this report is enabled) // send report ids to cb_task for callback execution (only if this report is enabled)
if (rpt->rpt_bit & xEventGroupGetBits(evt_grp_report_en)) if (rpt->rpt_bit & xEventGroupGetBits(sync_ctx.evt_grp_rpt_en))
{ {
// update respective report with new data // update respective report with new data
rpt->update_data(sensor_val); rpt->update_data(sensor_val);
if (cb_list.size() != 0) if (sync_ctx.cb_list.size() != 0)
if (xQueueSend(queue_cb_report_id, &rpt_ID, 0) != pdTRUE) if (xQueueSend(queue_cb_report_id, &rpt_ID, 0) != pdTRUE)
{ {
// clang-format off // clang-format off
@ -518,11 +450,9 @@ esp_err_t BNO08x::init_config_args()
imu_spi_config.clock_speed_hz = imu_config.sclk_speed; // assign SCLK speed imu_spi_config.clock_speed_hz = imu_config.sclk_speed; // assign SCLK speed
imu_spi_config.address_bits = 0; // 0 address bits, not using this system imu_spi_config.address_bits = 0; // 0 address bits, not using this system
imu_spi_config.command_bits = 0; // 0 command bits, not using this system imu_spi_config.command_bits = 0; // 0 command bits, not using this system
imu_spi_config.spics_io_num = imu_spi_config.spics_io_num = -1; // due to esp32 silicon issue, chip select cannot be used with full-duplex mode
-1; // due to esp32 silicon issue, chip select cannot be used with full-duplex mode
// driver, it must be handled via calls to gpio pins // driver, it must be handled via calls to gpio pins
imu_spi_config.queue_size = static_cast<int>( imu_spi_config.queue_size = static_cast<int>(CONFIG_ESP32_BNO08X_SPI_QUEUE_SZ); // set max allowable queued SPI transactions
CONFIG_ESP32_BNO08X_SPI_QUEUE_SZ); // set max allowable queued SPI transactions
return ESP_OK; return ESP_OK;
} }
@ -650,8 +580,7 @@ esp_err_t BNO08x::init_hint_isr()
} }
else else
{ {
init_status.isr_service = init_status.isr_service = true; // set isr service to initialized such that deconstructor knows to clean it up
true; // set isr service to initialized such that deconstructor knows to clean it up
// (this will be ignored if imu_config.install_isr_service == false) // (this will be ignored if imu_config.install_isr_service == false)
} }
@ -669,8 +598,7 @@ esp_err_t BNO08x::init_hint_isr()
} }
else else
{ {
init_status.isr_handler = init_status.isr_handler = true; // set isr handler to initialized such that deconstructor knows to clean it up
true; // set isr handler to initialized such that deconstructor knows to clean it up
} }
return ret; return ret;
@ -685,11 +613,11 @@ esp_err_t BNO08x::init_tasks()
{ {
BaseType_t task_created = pdFALSE; BaseType_t task_created = pdFALSE;
xEventGroupSetBits(evt_grp_bno08x_task, EVT_GRP_BNO08x_TASKS_RUNNING); xEventGroupSetBits(sync_ctx.evt_grp_task, EVT_GRP_BNO08x_TASKS_RUNNING);
// launch data processing task // launch data processing task
task_created = xTaskCreate(&data_proc_task_trampoline, "bno08x_data_processing_task", task_created = xTaskCreate(
DATA_PROC_TASK_SZ, this, 6, &data_proc_task_hdl); &data_proc_task_trampoline, "bno08x_data_processing_task", DATA_PROC_TASK_SZ, this, 6, &data_proc_task_hdl);
if (task_created != pdTRUE) if (task_created != pdTRUE)
{ {
@ -707,8 +635,7 @@ esp_err_t BNO08x::init_tasks()
} }
// launch cb task // launch cb task
task_created = task_created = xTaskCreate(&cb_task_trampoline, "bno08x_cb_task", CB_TASK_SZ, this, 5, &cb_task_hdl);
xTaskCreate(&cb_task_trampoline, "bno08x_cb_task", CB_TASK_SZ, this, 5, &cb_task_hdl);
if (task_created != pdTRUE) if (task_created != pdTRUE)
{ {
@ -726,8 +653,8 @@ esp_err_t BNO08x::init_tasks()
} }
// launch sh2 hal service task // launch sh2 hal service task
task_created = xTaskCreate(&sh2_HAL_service_task_trampoline, "bno08x_sh2_HAL_service_task", task_created = xTaskCreate(&sh2_HAL_service_task_trampoline, "bno08x_sh2_HAL_service_task", SH2_HAL_SERVICE_TASK_SZ, this, 7,
SH2_HAL_SERVICE_TASK_SZ, this, 7, &sh2_HAL_service_task_hdl); &sh2_HAL_service_task_hdl);
if (task_created != pdTRUE) if (task_created != pdTRUE)
{ {
@ -1038,14 +965,13 @@ esp_err_t BNO08x::deinit_tasks()
// disable interrupts before beginning so we can ensure SPI transaction doesn't attempt to run // disable interrupts before beginning so we can ensure SPI transaction doesn't attempt to run
gpio_intr_disable(imu_config.io_int); gpio_intr_disable(imu_config.io_int);
init_count += (static_cast<uint8_t>(init_status.cb_task) + init_count += (static_cast<uint8_t>(init_status.cb_task) + static_cast<uint8_t>(init_status.data_proc_task) +
static_cast<uint8_t>(init_status.data_proc_task) +
static_cast<uint8_t>(init_status.sh2_HAL_service_task)); static_cast<uint8_t>(init_status.sh2_HAL_service_task));
if (init_count != 0) if (init_count != 0)
{ {
sem_kill_tasks = xSemaphoreCreateCounting(init_count, 0); sem_kill_tasks = xSemaphoreCreateCounting(init_count, 0);
xEventGroupClearBits(evt_grp_bno08x_task, xEventGroupClearBits(sync_ctx.evt_grp_task,
EVT_GRP_BNO08x_TASKS_RUNNING); // clear task running bit request deletion of tasks EVT_GRP_BNO08x_TASKS_RUNNING); // clear task running bit request deletion of tasks
if (init_status.cb_task) if (init_status.cb_task)
@ -1055,7 +981,7 @@ esp_err_t BNO08x::deinit_tasks()
xQueueSend(queue_rx_sensor_event, &empty_event, 0); xQueueSend(queue_rx_sensor_event, &empty_event, 0);
if (init_status.sh2_HAL_service_task) if (init_status.sh2_HAL_service_task)
xEventGroupSetBits(evt_grp_bno08x_task, EVT_GRP_BNO08x_TASK_HINT_ASSRT_BIT); xEventGroupSetBits(sync_ctx.evt_grp_task, EVT_GRP_BNO08x_TASK_HINT_ASSRT_BIT);
for (uint8_t i = 0; i < init_count; i++) for (uint8_t i = 0; i < init_count; i++)
if (xSemaphoreTake(sem_kill_tasks, TASK_DELETE_TIMEOUT_MS) == pdTRUE) if (xSemaphoreTake(sem_kill_tasks, TASK_DELETE_TIMEOUT_MS) == pdTRUE)
@ -1258,6 +1184,47 @@ bool BNO08x::sleep()
return (op_success == SH2_OK); return (op_success == SH2_OK);
} }
/**
* @brief Starts simple calibration, see ref. manual 6.4.10.1
*
* @param period_us This interval should be set to whatever rate the sensor hub is expected to run
* at after calibration.
*
* After the calibration is started, the IMU should be rotated 180 degrees.
* After the IMU has been rotated call calibration_end().
* See ref. manual 6.4.10 for more detailed instructions.
*
* @return True if start simple calibration operation succeeded.
*/
bool BNO08x::calibration_start(uint32_t period_us)
{
int op_success = SH2_ERR;
lock_sh2_HAL();
op_success = sh2_startCal(period_us);
unlock_sh2_HAL();
return (op_success == SH2_OK);
}
/**
* @brief Ends turn-table calibration, see ref. manual 6.4.10.2
*
* @param status Returned status bits indicating result of turntable calibration.
*
* @return True if enable start turn-table calibration operation succeeded.
*/
bool BNO08x::calibration_end(sh2_CalStatus_t& status)
{
int op_success = SH2_ERR;
lock_sh2_HAL();
op_success = sh2_finishCal(&status);
unlock_sh2_HAL();
return (op_success == SH2_OK);
}
/** /**
* @brief Enables dynamic/motion engine calibration for specified sensor(s), see ref. manual 6.4.6.1 * @brief Enables dynamic/motion engine calibration for specified sensor(s), see ref. manual 6.4.6.1
* *
@ -1265,7 +1232,7 @@ bool BNO08x::sleep()
* *
* @return True if enable dynamic/ME calibration succeeded. * @return True if enable dynamic/ME calibration succeeded.
*/ */
bool BNO08x::enable_dynamic_calibration(BNO08xCalSel sensor) bool BNO08x::dynamic_calibration_enable(BNO08xCalSel sensor)
{ {
int op_success = SH2_ERR; int op_success = SH2_ERR;
@ -1284,7 +1251,7 @@ bool BNO08x::enable_dynamic_calibration(BNO08xCalSel sensor)
* *
* @return True if disable dynamic/ME calibration succeeded. * @return True if disable dynamic/ME calibration succeeded.
*/ */
bool BNO08x::disable_dynamic_calibration(BNO08xCalSel sensor) bool BNO08x::dynamic_calibration_disable(BNO08xCalSel sensor)
{ {
int op_success = SH2_ERR; int op_success = SH2_ERR;
uint8_t active_sensors = 0U; uint8_t active_sensors = 0U;
@ -1311,7 +1278,7 @@ bool BNO08x::disable_dynamic_calibration(BNO08xCalSel sensor)
* *
* @return True if dynamic/ME calibration autosave data enable succeeded. * @return True if dynamic/ME calibration autosave data enable succeeded.
*/ */
bool BNO08x::enable_autosave_dynamic_calibration() bool BNO08x::dynamic_calibration_autosave_enable()
{ {
int op_success = SH2_ERR; int op_success = SH2_ERR;
@ -1328,7 +1295,7 @@ bool BNO08x::enable_autosave_dynamic_calibration()
* *
* @return True if dynamic/ME calibration autosave data enable succeeded. * @return True if dynamic/ME calibration autosave data enable succeeded.
*/ */
bool BNO08x::disable_autosave_dynamic_calibration() bool BNO08x::dynamic_calibration_autosave_disable()
{ {
int op_success = SH2_ERR; int op_success = SH2_ERR;
@ -1458,8 +1425,8 @@ esp_err_t BNO08x::wait_for_hint()
{ {
EventBits_t spi_evt_bits; EventBits_t spi_evt_bits;
spi_evt_bits = xEventGroupWaitBits(evt_grp_bno08x_task, EVT_GRP_BNO08x_TASK_HINT_ASSRT_BIT, spi_evt_bits = xEventGroupWaitBits(
pdTRUE, pdFALSE, HOST_INT_TIMEOUT_DEFAULT_MS); sync_ctx.evt_grp_task, EVT_GRP_BNO08x_TASK_HINT_ASSRT_BIT, pdTRUE, pdFALSE, HOST_INT_TIMEOUT_DEFAULT_MS);
if (spi_evt_bits & EVT_GRP_BNO08x_TASK_HINT_ASSRT_BIT) if (spi_evt_bits & EVT_GRP_BNO08x_TASK_HINT_ASSRT_BIT)
return ESP_OK; return ESP_OK;
@ -1475,8 +1442,8 @@ esp_err_t BNO08x::wait_for_hint()
*/ */
esp_err_t BNO08x::wait_for_reset() esp_err_t BNO08x::wait_for_reset()
{ {
if (xEventGroupWaitBits(evt_grp_bno08x_task, EVT_GRP_BNO08x_TASK_RESET_OCCURRED, pdFALSE, if (xEventGroupWaitBits(
pdFALSE, HOST_INT_TIMEOUT_DEFAULT_MS) & sync_ctx.evt_grp_task, EVT_GRP_BNO08x_TASK_RESET_OCCURRED, pdFALSE, pdFALSE, HOST_INT_TIMEOUT_DEFAULT_MS) &
EVT_GRP_BNO08x_TASK_RESET_OCCURRED) EVT_GRP_BNO08x_TASK_RESET_OCCURRED)
return ESP_OK; return ESP_OK;
else else
@ -1509,9 +1476,9 @@ void BNO08x::toggle_reset()
*/ */
esp_err_t BNO08x::re_enable_reports() esp_err_t BNO08x::re_enable_reports()
{ {
EventBits_t report_en_bits = xEventGroupGetBits(evt_grp_report_en); EventBits_t report_en_bits = xEventGroupGetBits(sync_ctx.evt_grp_rpt_en);
for (const auto& rpt_ID : en_report_ids) for (const auto& rpt_ID : sync_ctx.en_report_ids)
{ {
BNO08xRpt* rpt = usr_reports.at(rpt_ID); BNO08xRpt* rpt = usr_reports.at(rpt_ID);
if (rpt == nullptr) if (rpt == nullptr)
@ -1538,7 +1505,7 @@ esp_err_t BNO08x::re_enable_reports()
} }
} }
xEventGroupClearBits(evt_grp_bno08x_task, EVT_GRP_BNO08x_TASK_RESET_OCCURRED); xEventGroupClearBits(sync_ctx.evt_grp_task, EVT_GRP_BNO08x_TASK_RESET_OCCURRED);
return ESP_OK; return ESP_OK;
} }
@ -1551,8 +1518,8 @@ esp_err_t BNO08x::re_enable_reports()
bool BNO08x::data_available() bool BNO08x::data_available()
{ {
if (xEventGroupWaitBits(evt_grp_bno08x_task, EVT_GRP_BNO08x_TASK_DATA_AVAILABLE, pdTRUE, if (xEventGroupWaitBits(
pdFALSE, DATA_AVAILABLE_TIMEOUT_MS) & sync_ctx.evt_grp_task, EVT_GRP_BNO08x_TASK_DATA_AVAILABLE, pdTRUE, pdFALSE, DATA_AVAILABLE_TIMEOUT_MS) &
EVT_GRP_BNO08x_TASK_DATA_AVAILABLE) EVT_GRP_BNO08x_TASK_DATA_AVAILABLE)
return true; return true;
@ -1569,9 +1536,9 @@ bool BNO08x::data_available()
bool BNO08x::register_cb(std::function<void(void)> cb_fxn) bool BNO08x::register_cb(std::function<void(void)> cb_fxn)
{ {
if (cb_list.size() < CONFIG_ESP32_BNO08X_CB_MAX) if (sync_ctx.cb_list.size() < CONFIG_ESP32_BNO08X_CB_MAX)
{ {
cb_list.push_back(BNO08xCbParamVoid(cb_fxn, 0U)); sync_ctx.cb_list.push_back(BNO08xCbParamVoid(cb_fxn, 0U));
return true; return true;
} }
return false; return false;
@ -1588,9 +1555,9 @@ bool BNO08x::register_cb(std::function<void(void)> cb_fxn)
*/ */
bool BNO08x::register_cb(std::function<void(uint8_t report_ID)> cb_fxn) bool BNO08x::register_cb(std::function<void(uint8_t report_ID)> cb_fxn)
{ {
if (cb_list.size() < CONFIG_ESP32_BNO08X_CB_MAX) if (sync_ctx.cb_list.size() < CONFIG_ESP32_BNO08X_CB_MAX)
{ {
cb_list.push_back(BNO08xCbParamRptID(cb_fxn, 0U)); sync_ctx.cb_list.push_back(BNO08xCbParamRptID(cb_fxn, 0U));
return true; return true;
} }
return false; return false;
@ -1614,9 +1581,8 @@ void BNO08x::print_product_ids()
" SW Build Number: 0x%" PRIx32 "\n\r" " SW Build Number: 0x%" PRIx32 "\n\r"
" SW Version Patch: 0x%" PRIx16 "\n\r" " SW Version Patch: 0x%" PRIx16 "\n\r"
" ---------------------------\n\r", " ---------------------------\n\r",
i, product_IDs.entry->swPartNumber, product_IDs.entry->swVersionMajor, i, product_IDs.entry->swPartNumber, product_IDs.entry->swVersionMajor, product_IDs.entry->swVersionMinor,
product_IDs.entry->swVersionMinor, product_IDs.entry->swBuildNumber, product_IDs.entry->swBuildNumber, product_IDs.entry->swVersionPatch);
product_IDs.entry->swVersionPatch);
} }
} }
@ -1715,7 +1681,6 @@ void IRAM_ATTR BNO08x::hint_handler(void* arg)
// to imu object created by constructor call) // to imu object created by constructor call)
// notify any tasks/function calls waiting for HINT assertion // notify any tasks/function calls waiting for HINT assertion
xEventGroupSetBitsFromISR( xEventGroupSetBitsFromISR(imu->sync_ctx.evt_grp_task, EVT_GRP_BNO08x_TASK_HINT_ASSRT_BIT, &xHighPriorityTaskWoken);
imu->evt_grp_bno08x_task, EVT_GRP_BNO08x_TASK_HINT_ASSRT_BIT, &xHighPriorityTaskWoken);
portYIELD_FROM_ISR(xHighPriorityTaskWoken); // perform context switch if necessary portYIELD_FROM_ISR(xHighPriorityTaskWoken); // perform context switch if necessary
} }

35
source/BNO08xRpt.cpp
View File

@ -18,7 +18,7 @@ bool BNO08xRpt::enable(uint32_t time_between_reports, sh2_SensorConfig_t sensor_
{ {
int sh2_res = SH2_OK; int sh2_res = SH2_OK;
EventBits_t report_en_bits = xEventGroupGetBits(*_evt_grp_rpt_en); EventBits_t report_en_bits = xEventGroupGetBits(sync_ctx->evt_grp_rpt_en);
sensor_cfg.reportInterval_us = time_between_reports; sensor_cfg.reportInterval_us = time_between_reports;
@ -38,8 +38,8 @@ bool BNO08xRpt::enable(uint32_t time_between_reports, sh2_SensorConfig_t sensor_
// if not already enabled (ie user called this, not re_enable_reports()) // if not already enabled (ie user called this, not re_enable_reports())
if (!(report_en_bits & rpt_bit)) if (!(report_en_bits & rpt_bit))
{ {
_en_report_ids->push_back(ID); // add report ID to enabled report IDs sync_ctx->en_report_ids.push_back(ID); // add report ID to enabled report IDs
xEventGroupSetBits(*_evt_grp_rpt_en, rpt_bit); // set the event group bit xEventGroupSetBits(sync_ctx->evt_grp_rpt_en, rpt_bit); // set the event group bit
} }
return true; return true;
@ -65,9 +65,9 @@ bool BNO08xRpt::disable(sh2_SensorConfig_t sensor_cfg)
} }
else else
{ {
for (int i = 0; i < _en_report_ids->size(); i++) for (int i = 0; i < sync_ctx->en_report_ids.size(); i++)
{ {
if (_en_report_ids->at(i) == ID) if (sync_ctx->en_report_ids[i] == ID)
{ {
idx = i; idx = i;
break; break;
@ -78,9 +78,9 @@ bool BNO08xRpt::disable(sh2_SensorConfig_t sensor_cfg)
period_us = 0UL; // update the period period_us = 0UL; // update the period
if (idx != -1) if (idx != -1)
_en_report_ids->erase(_en_report_ids->begin() + idx); sync_ctx->en_report_ids.erase(sync_ctx->en_report_ids.begin() + idx);
xEventGroupClearBits(*_evt_grp_rpt_en, rpt_bit); // Set the event group bit xEventGroupClearBits(sync_ctx->evt_grp_rpt_en, rpt_bit); // Set the event group bit
} }
return true; return true;
@ -95,9 +95,9 @@ bool BNO08xRpt::disable(sh2_SensorConfig_t sensor_cfg)
*/ */
bool BNO08xRpt::register_cb(std::function<void(void)> cb_fxn) bool BNO08xRpt::register_cb(std::function<void(void)> cb_fxn)
{ {
if (_cb_list->size() < CONFIG_ESP32_BNO08X_CB_MAX) if (sync_ctx->cb_list.size() < CONFIG_ESP32_BNO08X_CB_MAX)
{ {
_cb_list->push_back(BNO08xCbParamVoid(cb_fxn, ID)); sync_ctx->cb_list.push_back(BNO08xCbParamVoid(cb_fxn, ID));
return true; return true;
} }
return false; return false;
@ -113,10 +113,10 @@ bool BNO08xRpt::has_new_data()
{ {
bool new_data = false; bool new_data = false;
if (xEventGroupGetBits(*_evt_grp_rpt_data_available) & rpt_bit) if (xEventGroupGetBits(sync_ctx->evt_grp_rpt_data_available) & rpt_bit)
{ {
new_data = true; new_data = true;
xEventGroupClearBits(*_evt_grp_rpt_data_available, rpt_bit); xEventGroupClearBits(sync_ctx->evt_grp_rpt_data_available, rpt_bit);
} }
return new_data; return new_data;
@ -213,7 +213,7 @@ bool BNO08xRpt::get_meta_data(bno08x_meta_data_t& meta_data)
*/ */
void BNO08xRpt::lock_sh2_HAL() void BNO08xRpt::lock_sh2_HAL()
{ {
xSemaphoreTake(*_sh2_HAL_lock, portMAX_DELAY); xSemaphoreTake(sync_ctx->sh2_HAL_lock, portMAX_DELAY);
} }
/** /**
@ -223,7 +223,7 @@ void BNO08xRpt::lock_sh2_HAL()
*/ */
void BNO08xRpt::unlock_sh2_HAL() void BNO08xRpt::unlock_sh2_HAL()
{ {
xSemaphoreGive(*_sh2_HAL_lock); xSemaphoreGive(sync_ctx->sh2_HAL_lock);
} }
/** /**
@ -233,7 +233,7 @@ void BNO08xRpt::unlock_sh2_HAL()
*/ */
void BNO08xRpt::lock_user_data() void BNO08xRpt::lock_user_data()
{ {
xSemaphoreTake(*_data_lock, portMAX_DELAY); xSemaphoreTake(sync_ctx->data_lock, portMAX_DELAY);
} }
/** /**
@ -243,7 +243,7 @@ void BNO08xRpt::lock_user_data()
*/ */
void BNO08xRpt::unlock_user_data() void BNO08xRpt::unlock_user_data()
{ {
xSemaphoreGive(*_data_lock); xSemaphoreGive(sync_ctx->data_lock);
} }
/** /**
@ -253,7 +253,6 @@ void BNO08xRpt::unlock_user_data()
*/ */
void BNO08xRpt::signal_data_available() void BNO08xRpt::signal_data_available()
{ {
xEventGroupSetBits(*_evt_grp_rpt_data_available, rpt_bit); xEventGroupSetBits(sync_ctx->evt_grp_rpt_data_available, rpt_bit);
xEventGroupSetBits( xEventGroupSetBits(sync_ctx->evt_grp_task, BNO08xPrivateTypes::EVT_GRP_BNO08x_TASK_DATA_AVAILABLE);
*_evt_grp_bno08x_task, BNO08xPrivateTypes::EVT_GRP_BNO08x_TASK_DATA_AVAILABLE);
} }

3
source/BNO08xSH2HAL.cpp
View File

@ -137,8 +137,7 @@ uint32_t BNO08xSH2HAL::get_time_us(sh2_Hal_t* self)
void BNO08xSH2HAL::hal_cb(void* cookie, sh2_AsyncEvent_t* pEvent) void BNO08xSH2HAL::hal_cb(void* cookie, sh2_AsyncEvent_t* pEvent)
{ {
if (pEvent->eventId == SH2_RESET) if (pEvent->eventId == SH2_RESET)
xEventGroupSetBits( xEventGroupSetBits(imu->sync_ctx.evt_grp_task, BNO08xPrivateTypes::EVT_GRP_BNO08x_TASK_RESET_OCCURRED);
imu->evt_grp_bno08x_task, BNO08xPrivateTypes::EVT_GRP_BNO08x_TASK_RESET_OCCURRED);
} }
/** /**

2
source/report/BNO08xRptARVRStabilizedGameRV.cpp
View File

@ -19,6 +19,6 @@ void BNO08xRptARVRStabilizedGameRV::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptARVRStabilizedRV.cpp
View File

@ -19,6 +19,6 @@ void BNO08xRptARVRStabilizedRV::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptAcceleration.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptAcceleration::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

9
source/report/BNO08xRptActivityClassifier.cpp
View File

@ -15,11 +15,10 @@
* *
* @return True if report was successfully enabled. * @return True if report was successfully enabled.
*/ */
bool BNO08xRptActivityClassifier::enable(uint32_t time_between_reports, bool BNO08xRptActivityClassifier::enable(
BNO08xActivityEnable activities_to_enable, sh2_SensorConfig_t sensor_cfg) uint32_t time_between_reports, BNO08xActivityEnable activities_to_enable, sh2_SensorConfig_t sensor_cfg)
{ {
sensor_cfg.sensorSpecific = sensor_cfg.sensorSpecific = static_cast<uint8_t>(activities_to_enable); // this must be set regardless of user cfg
static_cast<uint8_t>(activities_to_enable); // this must be set regardless of user cfg
// or no reports will be received // or no reports will be received
return BNO08xRpt::enable(time_between_reports, sensor_cfg); return BNO08xRpt::enable(time_between_reports, sensor_cfg);
@ -39,7 +38,7 @@ void BNO08xRptActivityClassifier::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptCalGyro.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptCalGyro::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptCalMagnetometer.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptCalMagnetometer::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptGameRV.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptGameRV::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptGravity.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptGravity::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptIGyroRV.cpp
View File

@ -20,7 +20,7 @@ void BNO08xRptIGyroRV::update_data(sh2_SensorValue_t* sensor_val)
data_vel = sensor_val->un.gyroIntegratedRV; data_vel = sensor_val->un.gyroIntegratedRV;
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptLinearAcceleration.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptLinearAcceleration::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptRV.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptRV::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptRVGeomag.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptRVGeomag::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptRawMEMSAccelerometer.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptRawMEMSAccelerometer::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptRawMEMSGyro.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptRawMEMSGyro::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptRawMEMSMagnetometer.cpp
View File

@ -19,7 +19,7 @@ void BNO08xRptRawMEMSMagnetometer::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

10
source/report/BNO08xShakeDetector.cpp → source/report/BNO08xRptShakeDetector.cpp
View File

@ -1,9 +1,9 @@
/** /**
* @file BNO08xShakeDetector.cpp * @file BNO08xRptShakeDetector.cpp
* @author Myles Parfeniuk * @author Myles Parfeniuk
*/ */
#include "BNO08xShakeDetector.hpp" #include "BNO08xRptShakeDetector.hpp"
/** /**
* @brief Updates shake detector data from decoded sensor event. * @brief Updates shake detector data from decoded sensor event.
@ -12,14 +12,14 @@
* *
* @return void, nothing to return * @return void, nothing to return
*/ */
void BNO08xShakeDetector::update_data(sh2_SensorValue_t* sensor_val) void BNO08xRptShakeDetector::update_data(sh2_SensorValue_t* sensor_val)
{ {
lock_user_data(); lock_user_data();
data = sensor_val->un.shakeDetector; data = sensor_val->un.shakeDetector;
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }
@ -28,7 +28,7 @@ void BNO08xShakeDetector::update_data(sh2_SensorValue_t* sensor_val)
* *
* @return Struct containing the requested data. * @return Struct containing the requested data.
*/ */
bno08x_shake_detector_t BNO08xShakeDetector::get() bno08x_shake_detector_t BNO08xRptShakeDetector::get()
{ {
lock_user_data(); lock_user_data();
bno08x_shake_detector_t rqdata = data; bno08x_shake_detector_t rqdata = data;

12
source/report/BNO08xStabilityClassifier.cpp → source/report/BNO08xRptStabilityClassifier.cpp
View File

@ -1,9 +1,9 @@
/** /**
* @file BNO08xStabilityClassifier.cpp * @file BNO08xRptStabilityClassifier.cpp
* @author Myles Parfeniuk * @author Myles Parfeniuk
*/ */
#include "BNO08xStabilityClassifier.hpp" #include "BNO08xRptStabilityClassifier.hpp"
/** /**
* @brief Updates stability classifier data from decoded sensor event. * @brief Updates stability classifier data from decoded sensor event.
@ -12,14 +12,14 @@
* *
* @return void, nothing to return * @return void, nothing to return
*/ */
void BNO08xStabilityClassifier::update_data(sh2_SensorValue_t* sensor_val) void BNO08xRptStabilityClassifier::update_data(sh2_SensorValue_t* sensor_val)
{ {
lock_user_data(); lock_user_data();
data = sensor_val->un.stabilityClassifier; data = sensor_val->un.stabilityClassifier;
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }
@ -28,7 +28,7 @@ void BNO08xStabilityClassifier::update_data(sh2_SensorValue_t* sensor_val)
* *
* @return BNO08xStability enum object with detected state. * @return BNO08xStability enum object with detected state.
*/ */
bno08x_stability_classifier_t BNO08xStabilityClassifier::get() bno08x_stability_classifier_t BNO08xRptStabilityClassifier::get()
{ {
lock_user_data(); lock_user_data();
bno08x_stability_classifier_t rqdata = data; bno08x_stability_classifier_t rqdata = data;
@ -41,7 +41,7 @@ bno08x_stability_classifier_t BNO08xStabilityClassifier::get()
* *
* @return BNO08xStability enum object with detected state. * @return BNO08xStability enum object with detected state.
*/ */
BNO08xStability BNO08xStabilityClassifier::get_stability() BNO08xStability BNO08xRptStabilityClassifier::get_stability()
{ {
lock_user_data(); lock_user_data();
BNO08xStability rqdata = data.stability; BNO08xStability rqdata = data.stability;

2
source/report/BNO08xRptStepCounter.cpp
View File

@ -30,7 +30,7 @@ void BNO08xRptStepCounter::update_data(sh2_SensorValue_t* sensor_val)
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

18
source/report/BNO08xTapDetector.cpp → source/report/BNO08xRptTapDetector.cpp
View File

@ -1,9 +1,9 @@
/** /**
* @file BNO08xTapDetector.cpp * @file BNO08xRptTapDetector.cpp
* @author Myles Parfeniuk * @author Myles Parfeniuk
*/ */
#include "BNO08xTapDetector.hpp" #include "BNO08xRptTapDetector.hpp"
/** /**
* @brief Enables tap detector reports such that the BNO08x begins sending them (only sends reports * @brief Enables tap detector reports such that the BNO08x begins sending them (only sends reports
@ -15,12 +15,10 @@
* *
* @return True if report was successfully enabled. * @return True if report was successfully enabled.
*/ */
bool BNO08xTapDetector::enable(uint32_t time_between_reports, sh2_SensorConfig_t sensor_cfg) bool BNO08xRptTapDetector::enable(uint32_t time_between_reports, sh2_SensorConfig_t sensor_cfg)
{ {
sensor_cfg.changeSensitivityEnabled = sensor_cfg.changeSensitivityEnabled = true; // this must be set regardless of user cfg or no reports will be received
true; // this must be set regardless of user cfg or no reports will be received sensor_cfg.changeSensitivity = 0U; // this must be set regardless of user cfg or no reports will be received
sensor_cfg.changeSensitivity =
0U; // this must be set regardless of user cfg or no reports will be received
return BNO08xRpt::enable(time_between_reports, sensor_cfg); return BNO08xRpt::enable(time_between_reports, sensor_cfg);
} }
@ -32,14 +30,14 @@ bool BNO08xTapDetector::enable(uint32_t time_between_reports, sh2_SensorConfig_t
* *
* @return void, nothing to return * @return void, nothing to return
*/ */
void BNO08xTapDetector::update_data(sh2_SensorValue_t* sensor_val) void BNO08xRptTapDetector::update_data(sh2_SensorValue_t* sensor_val)
{ {
lock_user_data(); lock_user_data();
data = sensor_val->un.tapDetector; data = sensor_val->un.tapDetector;
data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status); data.accuracy = static_cast<BNO08xAccuracy>(sensor_val->status);
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }
@ -48,7 +46,7 @@ void BNO08xTapDetector::update_data(sh2_SensorValue_t* sensor_val)
* *
* @return Struct containing requested data; * @return Struct containing requested data;
*/ */
bno08x_tap_detector_t BNO08xTapDetector::get() bno08x_tap_detector_t BNO08xRptTapDetector::get()
{ {
lock_user_data(); lock_user_data();
bno08x_tap_detector_t rqdata = data; bno08x_tap_detector_t rqdata = data;

2
source/report/BNO08xRptUncalGyro.cpp
View File

@ -20,7 +20,7 @@ void BNO08xRptUncalGyro::update_data(sh2_SensorValue_t* sensor_val)
bias_data = sensor_val->un.gyroscopeUncal; bias_data = sensor_val->un.gyroscopeUncal;
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

2
source/report/BNO08xRptUncalMagnetometer.cpp
View File

@ -20,7 +20,7 @@ void BNO08xRptUncalMagnetometer::update_data(sh2_SensorValue_t* sensor_val)
bias_data = sensor_val->un.magneticFieldUncal; bias_data = sensor_val->un.magneticFieldUncal;
unlock_user_data(); unlock_user_data();
if (rpt_bit & xEventGroupGetBits(*_evt_grp_rpt_en)) if (rpt_bit & xEventGroupGetBits(sync_ctx->evt_grp_rpt_en))
signal_data_available(); signal_data_available();
} }

195
test/CallbackTests.cpp
View File

@ -11,11 +11,9 @@
#include "unity.h" #include "unity.h"
#include "../include/BNO08xTestHelper.hpp" #include "../include/BNO08xTestHelper.hpp"
TEST_CASE("BNO08x Driver Creation for [CallbackAllReportVoidInputParam] Tests", TEST_CASE("BNO08x Driver Creation for [CallbackAllReportVoidInputParam] Tests", "[CallbackAllReportVoidInputParam]")
"[CallbackAllReportVoidInputParam]")
{ {
const constexpr char* TEST_TAG = const constexpr char* TEST_TAG = "BNO08x Driver Creation for [CallbackAllReportVoidInputParam] Tests";
"BNO08x Driver Creation for [CallbackAllReportVoidInputParam] Tests";
BNO08x* imu = nullptr; BNO08x* imu = nullptr;
@ -59,74 +57,68 @@ TEST_CASE("Void Input Param Flavor Cb", "[CallbackAllReportVoidInputParam]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
imu->register_cb( imu->register_cb(
[&imu, &data_available_accel, &data_available_lin_accel, &data_available_grav, [&imu, &data_available_accel, &data_available_lin_accel, &data_available_grav, &data_available_cal_gyro,
&data_available_cal_gyro, &data_available_cal_magnetometer, &data_accel, &data_available_cal_magnetometer, &data_accel, &data_available_rv, &data_available_rv_game,
&data_available_rv, &data_available_rv_game, &data_available_rv_geomagnetic, &data_available_rv_geomagnetic, &data_quat, &data_vel, &data_magf, &msg_buff, &test_running]()
&data_quat, &data_vel, &data_magf, &msg_buff, &test_running]()
{ {
static int i = 0; static int i = 0;
if (i < RX_REPORT_TRIAL_CNT) if (i < RX_REPORT_TRIAL_CNT)
{ {
if (imu->rpt_accelerometer.has_new_data()) if (imu->rpt.accelerometer.has_new_data())
{ {
data_available_accel = true; data_available_accel = true;
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f " "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f "
"accuracy: %s ", "accuracy: %s ",
(i + 1), data_accel.x, data_accel.y, data_accel.z, (i + 1), data_accel.x, data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
else if (imu->rpt_linear_accelerometer.has_new_data()) else if (imu->rpt.linear_accelerometer.has_new_data())
{ {
data_available_lin_accel = true; data_available_lin_accel = true;
data_accel = imu->rpt_linear_accelerometer.get(); data_accel = imu->rpt.linear_accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: LinAccel: [m/s^2] x: %.2f y: %.2f z: " "Rx Data Trial %d Success: LinAccel: [m/s^2] x: %.2f y: %.2f z: "
"%.2f accuracy: %s ", "%.2f accuracy: %s ",
(i + 1), data_accel.x, data_accel.y, data_accel.z, (i + 1), data_accel.x, data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
else if (imu->rpt_gravity.has_new_data()) else if (imu->rpt.gravity.has_new_data())
{ {
data_available_grav = true; data_available_grav = true;
data_accel = imu->rpt_gravity.get(); data_accel = imu->rpt.gravity.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: Gravity: [m/s^2] x: %.2f y: %.2f z: " "Rx Data Trial %d Success: Gravity: [m/s^2] x: %.2f y: %.2f z: "
"%.2f accuracy: %s ", "%.2f accuracy: %s ",
(i + 1), data_accel.x, data_accel.y, data_accel.z, (i + 1), data_accel.x, data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
else if (imu->rpt_cal_gyro.has_new_data()) else if (imu->rpt.cal_gyro.has_new_data())
{ {
data_available_cal_gyro = true; data_available_cal_gyro = true;
data_vel = imu->rpt_cal_gyro.get(); data_vel = imu->rpt.cal_gyro.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: CalGyro: [rad/s] x: %.2f y: %.2f z: " "Rx Data Trial %d Success: CalGyro: [rad/s] x: %.2f y: %.2f z: "
"%.2f accuracy: %s ", "%.2f accuracy: %s ",
(i + 1), data_vel.x, data_vel.y, data_vel.z, (i + 1), data_vel.x, data_vel.y, data_vel.z, BNO08x::accuracy_to_str(data_vel.accuracy));
BNO08x::accuracy_to_str(data_vel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
else if (imu->rpt_cal_magnetometer.has_new_data()) else if (imu->rpt.cal_magnetometer.has_new_data())
{ {
data_available_cal_magnetometer = true; data_available_cal_magnetometer = true;
data_magf = imu->rpt_cal_magnetometer.get(); data_magf = imu->rpt.cal_magnetometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: CalMagnetometer: [uTesla] x: %.2f y: " "Rx Data Trial %d Success: CalMagnetometer: [uTesla] x: %.2f y: "
"%.2f z: %.2f accuracy: %s ", "%.2f z: %.2f accuracy: %s ",
(i + 1), data_magf.x, data_magf.y, data_magf.z, (i + 1), data_magf.x, data_magf.y, data_magf.z, BNO08x::accuracy_to_str(data_magf.accuracy));
BNO08x::accuracy_to_str(data_magf.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
else if (imu->rpt_rv.has_new_data()) else if (imu->rpt.rv.has_new_data())
{ {
data_available_rv = true; data_available_rv = true;
data_quat = imu->rpt_rv.get_quat(); data_quat = imu->rpt.rv.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV: [n/a] real: %.2f i: %.2f j: %.2f k: " "Rx Data Trial %d Success: RV: [n/a] real: %.2f i: %.2f j: %.2f k: "
"%.2f accuracy: %s ", "%.2f accuracy: %s ",
@ -134,10 +126,10 @@ TEST_CASE("Void Input Param Flavor Cb", "[CallbackAllReportVoidInputParam]")
BNO08x::accuracy_to_str(data_quat.accuracy)); BNO08x::accuracy_to_str(data_quat.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
else if (imu->rpt_rv_game.has_new_data()) else if (imu->rpt.rv_game.has_new_data())
{ {
data_available_rv_game = true; data_available_rv_game = true;
data_quat = imu->rpt_rv_game.get_quat(); data_quat = imu->rpt.rv_game.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV Game: [n/a] real: %.2f i: %.2f j: " "Rx Data Trial %d Success: RV Game: [n/a] real: %.2f i: %.2f j: "
"%.2f k: %.2f accuracy: %s ", "%.2f k: %.2f accuracy: %s ",
@ -145,10 +137,10 @@ TEST_CASE("Void Input Param Flavor Cb", "[CallbackAllReportVoidInputParam]")
BNO08x::accuracy_to_str(data_quat.accuracy)); BNO08x::accuracy_to_str(data_quat.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
else if (imu->rpt_rv_geomagnetic.has_new_data()) else if (imu->rpt.rv_geomagnetic.has_new_data())
{ {
data_available_rv_geomagnetic = true; data_available_rv_geomagnetic = true;
data_quat = imu->rpt_rv_geomagnetic.get_quat(); data_quat = imu->rpt.rv_geomagnetic.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV Geomagnetic: [n/a] real: %.2f i: " "Rx Data Trial %d Success: RV Geomagnetic: [n/a] real: %.2f i: "
"%.2f j: %.2f k: %.2f accuracy: %s ", "%.2f j: %.2f k: %.2f accuracy: %s ",
@ -161,26 +153,26 @@ TEST_CASE("Void Input Param Flavor Cb", "[CallbackAllReportVoidInputParam]")
} }
else if (test_running) else if (test_running)
{ {
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_gravity.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.gravity.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_cal_gyro.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.cal_gyro.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_cal_magnetometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.cal_magnetometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_rv.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_rv_game.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_game.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_rv_geomagnetic.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_geomagnetic.disable());
test_running = false; test_running = false;
} }
}); });
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_gravity.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.gravity.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_cal_gyro.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.cal_gyro.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_cal_magnetometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.cal_magnetometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_rv.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_rv_game.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_game.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_rv_geomagnetic.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_geomagnetic.enable(REPORT_PERIOD));
while (test_running) while (test_running)
{ {
@ -198,11 +190,9 @@ TEST_CASE("Void Input Param Flavor Cb", "[CallbackAllReportVoidInputParam]")
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
TEST_CASE("BNO08x Driver Cleanup for [CallbackAllReportVoidInputParam] Tests", TEST_CASE("BNO08x Driver Cleanup for [CallbackAllReportVoidInputParam] Tests", "[CallbackAllReportVoidInputParam]")
"[CallbackAllReportVoidInputParam]")
{ {
const constexpr char* TEST_TAG = const constexpr char* TEST_TAG = "BNO08x Driver Cleanup for [CallbackAllReportVoidInputParam] Tests";
"BNO08x Driver Cleanup for [CallbackAllReportVoidInputParam] Tests";
BNO08xTestHelper::print_test_start_banner(TEST_TAG); BNO08xTestHelper::print_test_start_banner(TEST_TAG);
BNO08xTestHelper::print_test_msg(TEST_TAG, "Destroying BNO08x Driver."); BNO08xTestHelper::print_test_msg(TEST_TAG, "Destroying BNO08x Driver.");
@ -211,11 +201,9 @@ TEST_CASE("BNO08x Driver Cleanup for [CallbackAllReportVoidInputParam] Tests",
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
TEST_CASE("BNO08x Driver Creation for [CallbackAllReportIDInputParam] Tests", TEST_CASE("BNO08x Driver Creation for [CallbackAllReportIDInputParam] Tests", "[CallbackAllReportIDInputParam]")
"[CallbackAllReportIDInputParam]")
{ {
const constexpr char* TEST_TAG = const constexpr char* TEST_TAG = "BNO08x Driver Creation for [CallbackAllReportIDInputParam] Tests";
"BNO08x Driver Creation for [CallbackAllReportIDInputParam] Tests";
BNO08x* imu = nullptr; BNO08x* imu = nullptr;
@ -258,10 +246,10 @@ TEST_CASE("Report ID Input Param Flavor Cb", "[CallbackAllReportIDInputParam]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
imu->register_cb( imu->register_cb(
[&imu, &data_available_accel, &data_available_lin_accel, &data_available_grav, [&imu, &data_available_accel, &data_available_lin_accel, &data_available_grav, &data_available_cal_gyro,
&data_available_cal_gyro, &data_available_cal_magnetometer, &data_accel, &data_available_cal_magnetometer, &data_accel, &data_available_rv, &data_available_rv_game,
&data_available_rv, &data_available_rv_game, &data_available_rv_geomagnetic, &data_available_rv_geomagnetic, &data_quat, &data_vel, &data_magf, &msg_buff,
&data_quat, &data_vel, &data_magf, &msg_buff, &test_running](uint8_t report_ID) &test_running](uint8_t report_ID)
{ {
static int i = 0; static int i = 0;
if (i < RX_REPORT_TRIAL_CNT) if (i < RX_REPORT_TRIAL_CNT)
@ -271,7 +259,7 @@ TEST_CASE("Report ID Input Param Flavor Cb", "[CallbackAllReportIDInputParam]")
case SH2_ACCELEROMETER: case SH2_ACCELEROMETER:
data_available_accel = true; data_available_accel = true;
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: " "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: "
"%.2f accuracy: %s ", "%.2f accuracy: %s ",
@ -282,7 +270,7 @@ TEST_CASE("Report ID Input Param Flavor Cb", "[CallbackAllReportIDInputParam]")
case SH2_LINEAR_ACCELERATION: case SH2_LINEAR_ACCELERATION:
data_available_lin_accel = true; data_available_lin_accel = true;
data_accel = imu->rpt_linear_accelerometer.get(); data_accel = imu->rpt.linear_accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: LinAccel: [m/s^2] x: %.2f y: %.2f " "Rx Data Trial %d Success: LinAccel: [m/s^2] x: %.2f y: %.2f "
"z: %.2f accuracy: %s ", "z: %.2f accuracy: %s ",
@ -293,7 +281,7 @@ TEST_CASE("Report ID Input Param Flavor Cb", "[CallbackAllReportIDInputParam]")
case SH2_GRAVITY: case SH2_GRAVITY:
data_available_grav = true; data_available_grav = true;
data_accel = imu->rpt_gravity.get(); data_accel = imu->rpt.gravity.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: Gravity: [m/s^2] x: %.2f y: %.2f z: " "Rx Data Trial %d Success: Gravity: [m/s^2] x: %.2f y: %.2f z: "
"%.2f accuracy: %s ", "%.2f accuracy: %s ",
@ -304,29 +292,27 @@ TEST_CASE("Report ID Input Param Flavor Cb", "[CallbackAllReportIDInputParam]")
case SH2_GYROSCOPE_CALIBRATED: case SH2_GYROSCOPE_CALIBRATED:
data_available_cal_gyro = true; data_available_cal_gyro = true;
data_vel = imu->rpt_cal_gyro.get(); data_vel = imu->rpt.cal_gyro.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: CalGyro: [rad/s] x: %.2f y: %.2f z: " "Rx Data Trial %d Success: CalGyro: [rad/s] x: %.2f y: %.2f z: "
"%.2f accuracy: %s ", "%.2f accuracy: %s ",
(i + 1), data_vel.x, data_vel.y, data_vel.z, (i + 1), data_vel.x, data_vel.y, data_vel.z, BNO08x::accuracy_to_str(data_vel.accuracy));
BNO08x::accuracy_to_str(data_vel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
break; break;
case SH2_MAGNETIC_FIELD_CALIBRATED: case SH2_MAGNETIC_FIELD_CALIBRATED:
data_available_cal_magnetometer = true; data_available_cal_magnetometer = true;
data_magf = imu->rpt_cal_magnetometer.get(); data_magf = imu->rpt.cal_magnetometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: CalMagnetometer: [uTesla] x: %.2f " "Rx Data Trial %d Success: CalMagnetometer: [uTesla] x: %.2f "
"y: %.2f z: %.2f accuracy: %s ", "y: %.2f z: %.2f accuracy: %s ",
(i + 1), data_magf.x, data_magf.y, data_magf.z, (i + 1), data_magf.x, data_magf.y, data_magf.z, BNO08x::accuracy_to_str(data_magf.accuracy));
BNO08x::accuracy_to_str(data_magf.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
break; break;
case SH2_ROTATION_VECTOR: case SH2_ROTATION_VECTOR:
data_available_rv = true; data_available_rv = true;
data_quat = imu->rpt_rv.get_quat(); data_quat = imu->rpt.rv.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV: [n/a] real: %.2f i: %.2f j: " "Rx Data Trial %d Success: RV: [n/a] real: %.2f i: %.2f j: "
"%.2f k: %.2f accuracy: %s ", "%.2f k: %.2f accuracy: %s ",
@ -337,7 +323,7 @@ TEST_CASE("Report ID Input Param Flavor Cb", "[CallbackAllReportIDInputParam]")
case SH2_GAME_ROTATION_VECTOR: case SH2_GAME_ROTATION_VECTOR:
data_available_rv_game = true; data_available_rv_game = true;
data_quat = imu->rpt_rv_game.get_quat(); data_quat = imu->rpt.rv_game.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV Game: [n/a] real: %.2f i: %.2f " "Rx Data Trial %d Success: RV Game: [n/a] real: %.2f i: %.2f "
"j: %.2f k: %.2f accuracy: %s ", "j: %.2f k: %.2f accuracy: %s ",
@ -348,7 +334,7 @@ TEST_CASE("Report ID Input Param Flavor Cb", "[CallbackAllReportIDInputParam]")
case SH2_GEOMAGNETIC_ROTATION_VECTOR: case SH2_GEOMAGNETIC_ROTATION_VECTOR:
data_available_rv_geomagnetic = true; data_available_rv_geomagnetic = true;
data_quat = imu->rpt_rv_geomagnetic.get_quat(); data_quat = imu->rpt.rv_geomagnetic.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV Geomagnetic: [n/a] real: %.2f i: " "Rx Data Trial %d Success: RV Geomagnetic: [n/a] real: %.2f i: "
"%.2f j: %.2f k: %.2f accuracy: %s ", "%.2f j: %.2f k: %.2f accuracy: %s ",
@ -366,26 +352,26 @@ TEST_CASE("Report ID Input Param Flavor Cb", "[CallbackAllReportIDInputParam]")
} }
else if (test_running) else if (test_running)
{ {
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_gravity.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.gravity.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_cal_gyro.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.cal_gyro.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_cal_magnetometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.cal_magnetometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_rv.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_rv_game.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_game.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_rv_geomagnetic.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_geomagnetic.disable());
test_running = false; test_running = false;
} }
}); });
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_gravity.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.gravity.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_cal_gyro.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.cal_gyro.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_cal_magnetometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.cal_magnetometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_rv.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_rv_game.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_game.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_rv_geomagnetic.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_geomagnetic.enable(REPORT_PERIOD));
while (test_running) while (test_running)
{ {
@ -403,11 +389,9 @@ TEST_CASE("Report ID Input Param Flavor Cb", "[CallbackAllReportIDInputParam]")
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
TEST_CASE("BNO08x Driver Cleanup for [CallbackAllReportIDInputParam] Tests", TEST_CASE("BNO08x Driver Cleanup for [CallbackAllReportIDInputParam] Tests", "[CallbackAllReportIDInputParam]")
"[CallbackAllReportIDInputParam]")
{ {
const constexpr char* TEST_TAG = const constexpr char* TEST_TAG = "BNO08x Driver Cleanup for [CallbackAllReportIDInputParam] Tests";
"BNO08x Driver Cleanup for [CallbackAllReportIDInputParam] Tests";
BNO08xTestHelper::print_test_start_banner(TEST_TAG); BNO08xTestHelper::print_test_start_banner(TEST_TAG);
BNO08xTestHelper::print_test_msg(TEST_TAG, "Destroying BNO08x Driver."); BNO08xTestHelper::print_test_msg(TEST_TAG, "Destroying BNO08x Driver.");
@ -416,11 +400,9 @@ TEST_CASE("BNO08x Driver Cleanup for [CallbackAllReportIDInputParam] Tests",
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
TEST_CASE("BNO08x Driver Creation for [CallbackSingleReportVoidInputParam] Tests", TEST_CASE("BNO08x Driver Creation for [CallbackSingleReportVoidInputParam] Tests", "[CallbackSingleReportVoidInputParam]")
"[CallbackSingleReportVoidInputParam]")
{ {
const constexpr char* TEST_TAG = const constexpr char* TEST_TAG = "BNO08x Driver Creation for [CallbackSingleReportVoidInputParam] Tests";
"BNO08x Driver Creation for [CallbackSingleReportVoidInputParam] Tests";
BNO08x* imu = nullptr; BNO08x* imu = nullptr;
@ -452,7 +434,7 @@ TEST_CASE("Single Report Void Input Param Flavor Cb", "[CallbackSingleReportVoid
BNO08xTestHelper::print_test_start_banner(TEST_TAG); BNO08xTestHelper::print_test_start_banner(TEST_TAG);
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
imu->rpt_accelerometer.register_cb( imu->rpt.accelerometer.register_cb(
[&imu, &data_available_accel, &data_accel, &msg_buff, &test_running]() [&imu, &data_available_accel, &data_accel, &msg_buff, &test_running]()
{ {
static int i = 0; static int i = 0;
@ -460,24 +442,23 @@ TEST_CASE("Single Report Void Input Param Flavor Cb", "[CallbackSingleReportVoid
if (i < RX_REPORT_TRIAL_CNT) if (i < RX_REPORT_TRIAL_CNT)
{ {
data_available_accel = true; data_available_accel = true;
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f " "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f "
"accuracy: %s ", "accuracy: %s ",
(i + 1), data_accel.x, data_accel.y, data_accel.z, (i + 1), data_accel.x, data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
i++; i++;
} }
else if (test_running) else if (test_running)
{ {
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
test_running = false; test_running = false;
} }
}); });
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
while (test_running) while (test_running)
{ {
@ -488,11 +469,9 @@ TEST_CASE("Single Report Void Input Param Flavor Cb", "[CallbackSingleReportVoid
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
TEST_CASE("BNO08x Driver Cleanup for [CallbackSingleReportVoidInputParam] Tests", TEST_CASE("BNO08x Driver Cleanup for [CallbackSingleReportVoidInputParam] Tests", "[CallbackSingleReportVoidInputParam]")
"[CallbackSingleReportVoidInputParam]")
{ {
const constexpr char* TEST_TAG = const constexpr char* TEST_TAG = "BNO08x Driver Cleanup for [CallbackSingleReportVoidInputParam] Tests";
"BNO08x Driver Cleanup for [CallbackSingleReportVoidInputParam] Tests";
BNO08xTestHelper::print_test_start_banner(TEST_TAG); BNO08xTestHelper::print_test_start_banner(TEST_TAG);
BNO08xTestHelper::print_test_msg(TEST_TAG, "Destroying BNO08x Driver."); BNO08xTestHelper::print_test_msg(TEST_TAG, "Destroying BNO08x Driver.");

192
test/FeatureTests.cpp
View File

@ -42,17 +42,15 @@ TEST_CASE("Hard Reset", "[FeatureTests]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
@ -62,16 +60,14 @@ TEST_CASE("Hard Reset", "[FeatureTests]")
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -91,17 +87,15 @@ TEST_CASE("Soft Reset", "[FeatureTests]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
@ -111,16 +105,14 @@ TEST_CASE("Soft Reset", "[FeatureTests]")
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -140,17 +132,15 @@ TEST_CASE("Sleep", "[FeatureTests]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
@ -169,16 +159,14 @@ TEST_CASE("Sleep", "[FeatureTests]")
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -199,43 +187,39 @@ TEST_CASE("Get Metadata", "[FeatureTests]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
BNO08xTestHelper::print_test_msg(TEST_TAG, "Getting meta data..."); BNO08xTestHelper::print_test_msg(TEST_TAG, "Getting meta data...");
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.get_meta_data(meta_data)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.get_meta_data(meta_data));
sprintf(msg_buff, sprintf(msg_buff,
"Re-enabling report with fastest possible period of %ldus from accelerometer meta " "Re-enabling report with fastest possible period of %ldus from accelerometer meta "
"data.", "data.",
meta_data.min_period_us); meta_data.min_period_us);
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(meta_data.min_period_us)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(meta_data.min_period_us));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -256,40 +240,36 @@ TEST_CASE("Get Sample Counts", "[FeatureTests]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
BNO08xTestHelper::print_test_msg(TEST_TAG, "Getting sample counts..."); BNO08xTestHelper::print_test_msg(TEST_TAG, "Getting sample counts...");
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.get_sample_counts(sample_counts)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.get_sample_counts(sample_counts));
sprintf(msg_buff, "offered: %ld on: %ld accepted: %ld attempted: %ld", sample_counts.offered, sprintf(msg_buff, "offered: %ld on: %ld accepted: %ld attempted: %ld", sample_counts.offered, sample_counts.on,
sample_counts.on, sample_counts.accepted, sample_counts.attempted); sample_counts.accepted, sample_counts.attempted);
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -310,18 +290,16 @@ TEST_CASE("Enable Dynamic Calibration", "[FeatureTests]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->enable_dynamic_calibration(BNO08xCalSel::all)); TEST_ASSERT_EQUAL(true, imu->dynamic_calibration_enable(BNO08xCalSel::all));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
} }
@ -347,12 +325,10 @@ TEST_CASE("Save Dynamic Calibration", "[FeatureTests]")
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
} }
@ -373,21 +349,19 @@ TEST_CASE("Autosave Dynamic Calibration", "[FeatureTests]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->enable_autosave_dynamic_calibration()); TEST_ASSERT_EQUAL(true, imu->dynamic_calibration_autosave_enable());
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->disable_autosave_dynamic_calibration()); TEST_ASSERT_EQUAL(true, imu->dynamic_calibration_autosave_disable());
} }
TEST_CASE("Disable Dynamic Calibration", "[FeatureTests]") TEST_CASE("Disable Dynamic Calibration", "[FeatureTests]")
@ -406,17 +380,15 @@ TEST_CASE("Disable Dynamic Calibration", "[FeatureTests]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->disable_dynamic_calibration(BNO08xCalSel::all)); TEST_ASSERT_EQUAL(true, imu->dynamic_calibration_disable(BNO08xCalSel::all));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
} }
@ -442,16 +414,14 @@ TEST_CASE("Clear Dynamic Calibration", "[FeatureTests]")
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
TEST_ASSERT_EQUAL(true, imu->data_available()); TEST_ASSERT_EQUAL(true, imu->data_available());
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.has_new_data()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.has_new_data());
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data_accel.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
(i + 1), data_accel.x, data_accel.y, data_accel.z,
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
} }
TEST_CASE("BNO08x Driver Cleanup for [FeatureTests] Tests", "[FeatureTests]") TEST_CASE("BNO08x Driver Cleanup for [FeatureTests] Tests", "[FeatureTests]")

3
test/InitDenitTests.cpp
View File

@ -18,8 +18,7 @@ TEST_CASE("InitComprehensive Config Args", "[InitComprehensive]")
BNO08xTestHelper::print_test_start_banner(TEST_TAG); BNO08xTestHelper::print_test_start_banner(TEST_TAG);
BNO08xTestHelper::print_test_msg( BNO08xTestHelper::print_test_msg(TEST_TAG, "Creating test IMU for [InitComprehensive] and [DeinitComprehensive].");
TEST_TAG, "Creating test IMU for [InitComprehensive] and [DeinitComprehensive].");
BNO08xTestHelper::create_test_imu(); BNO08xTestHelper::create_test_imu();
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();

154
test/MultiReportTests.cpp
View File

@ -11,8 +11,7 @@
#include "unity.h" #include "unity.h"
#include "../include/BNO08xTestHelper.hpp" #include "../include/BNO08xTestHelper.hpp"
TEST_CASE( TEST_CASE("BNO08x Driver Creation for [MultiReportEnableDisable] Tests", "[MultiReportEnableDisable]")
"BNO08x Driver Creation for [MultiReportEnableDisable] Tests", "[MultiReportEnableDisable]")
{ {
const constexpr char* TEST_TAG = "BNO08x Driver Creation for [MultiReportEnableDisable] Tests"; const constexpr char* TEST_TAG = "BNO08x Driver Creation for [MultiReportEnableDisable] Tests";
BNO08x* imu = nullptr; BNO08x* imu = nullptr;
@ -47,18 +46,18 @@ TEST_CASE("Enable/Disable Dual Report", "[MultiReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
if (imu->rpt_accelerometer.has_new_data()) if (imu->rpt.accelerometer.has_new_data())
{ {
data_available_accel = true; data_available_accel = true;
data = imu->rpt_accelerometer.get(); data = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: "
"%s ", "%s ",
@ -66,10 +65,10 @@ TEST_CASE("Enable/Disable Dual Report", "[MultiReportEnableDisable]")
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_linear_accelerometer.has_new_data()) if (imu->rpt.linear_accelerometer.has_new_data())
{ {
data_available_lin_accel = true; data_available_lin_accel = true;
data = imu->rpt_linear_accelerometer.get(); data = imu->rpt.linear_accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: LinAccel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: LinAccel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: "
"%s ", "%s ",
@ -78,8 +77,8 @@ TEST_CASE("Enable/Disable Dual Report", "[MultiReportEnableDisable]")
} }
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.disable());
TEST_ASSERT_EQUAL(true, data_available_accel); TEST_ASSERT_EQUAL(true, data_available_accel);
TEST_ASSERT_EQUAL(true, data_available_lin_accel); TEST_ASSERT_EQUAL(true, data_available_lin_accel);
@ -109,69 +108,65 @@ TEST_CASE("Enable/Disable Quad Report", "[MultiReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_gravity.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.gravity.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_cal_gyro.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.cal_gyro.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
if (imu->rpt_accelerometer.has_new_data()) if (imu->rpt.accelerometer.has_new_data())
{ {
data_available_accel = true; data_available_accel = true;
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: "
"%s ", "%s ",
(i + 1), data_accel.x, data_accel.y, data_accel.z, (i + 1), data_accel.x, data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_linear_accelerometer.has_new_data()) if (imu->rpt.linear_accelerometer.has_new_data())
{ {
data_available_lin_accel = true; data_available_lin_accel = true;
data_accel = imu->rpt_linear_accelerometer.get(); data_accel = imu->rpt.linear_accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: LinAccel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: LinAccel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: "
"%s ", "%s ",
(i + 1), data_accel.x, data_accel.y, data_accel.z, (i + 1), data_accel.x, data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_gravity.has_new_data()) if (imu->rpt.gravity.has_new_data())
{ {
data_available_gravity = true; data_available_gravity = true;
data_accel = imu->rpt_gravity.get(); data_accel = imu->rpt.gravity.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: Gravity: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: Gravity: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: "
"%s ", "%s ",
(i + 1), data_accel.x, data_accel.y, data_accel.z, (i + 1), data_accel.x, data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_cal_gyro.has_new_data()) if (imu->rpt.cal_gyro.has_new_data())
{ {
data_available_cal_gyro = true; data_available_cal_gyro = true;
data_vel = imu->rpt_cal_gyro.get(); data_vel = imu->rpt.cal_gyro.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: CalGyro: [rad/s] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: CalGyro: [rad/s] x: %.2f y: %.2f z: %.2f accuracy: "
"%s ", "%s ",
(i + 1), data_vel.x, data_vel.y, data_vel.z, (i + 1), data_vel.x, data_vel.y, data_vel.z, BNO08x::accuracy_to_str(data_vel.accuracy));
BNO08x::accuracy_to_str(data_vel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_gravity.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.gravity.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_cal_gyro.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.cal_gyro.disable());
TEST_ASSERT_EQUAL(true, data_available_accel); TEST_ASSERT_EQUAL(true, data_available_accel);
TEST_ASSERT_EQUAL(true, data_available_lin_accel); TEST_ASSERT_EQUAL(true, data_available_lin_accel);
@ -209,125 +204,117 @@ TEST_CASE("Enable/Disable Octo Report", "[MultiReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_gravity.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.gravity.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_cal_gyro.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.cal_gyro.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_cal_magnetometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.cal_magnetometer.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_rv.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_rv_game.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_game.enable(REPORT_PERIOD));
TEST_ASSERT_EQUAL(true, imu->rpt_rv_geomagnetic.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_geomagnetic.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
if (imu->rpt_accelerometer.has_new_data()) if (imu->rpt.accelerometer.has_new_data())
{ {
data_available_accel = true; data_available_accel = true;
data_accel = imu->rpt_accelerometer.get(); data_accel = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: "
"%s ", "%s ",
(i + 1), data_accel.x, data_accel.y, data_accel.z, (i + 1), data_accel.x, data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_linear_accelerometer.has_new_data()) if (imu->rpt.linear_accelerometer.has_new_data())
{ {
data_available_lin_accel = true; data_available_lin_accel = true;
data_accel = imu->rpt_linear_accelerometer.get(); data_accel = imu->rpt.linear_accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: LinAccel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: LinAccel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: "
"%s ", "%s ",
(i + 1), data_accel.x, data_accel.y, data_accel.z, (i + 1), data_accel.x, data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_gravity.has_new_data()) if (imu->rpt.gravity.has_new_data())
{ {
data_available_gravity = true; data_available_gravity = true;
data_accel = imu->rpt_gravity.get(); data_accel = imu->rpt.gravity.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: Gravity: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: Gravity: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: "
"%s ", "%s ",
(i + 1), data_accel.x, data_accel.y, data_accel.z, (i + 1), data_accel.x, data_accel.y, data_accel.z, BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08x::accuracy_to_str(data_accel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_cal_gyro.has_new_data()) if (imu->rpt.cal_gyro.has_new_data())
{ {
data_available_cal_gyro = true; data_available_cal_gyro = true;
data_vel = imu->rpt_cal_gyro.get(); data_vel = imu->rpt.cal_gyro.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: CalGyro: [rad/s] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: CalGyro: [rad/s] x: %.2f y: %.2f z: %.2f accuracy: "
"%s ", "%s ",
(i + 1), data_vel.x, data_vel.y, data_vel.z, (i + 1), data_vel.x, data_vel.y, data_vel.z, BNO08x::accuracy_to_str(data_vel.accuracy));
BNO08x::accuracy_to_str(data_vel.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_cal_magnetometer.has_new_data()) if (imu->rpt.cal_magnetometer.has_new_data())
{ {
data_available_cal_magnetometer = true; data_available_cal_magnetometer = true;
data_magf = imu->rpt_cal_magnetometer.get(); data_magf = imu->rpt.cal_magnetometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: CalMagnetometer: [uTesla] x: %.2f y: %.2f z: %.2f " "Rx Data Trial %d Success: CalMagnetometer: [uTesla] x: %.2f y: %.2f z: %.2f "
"accuracy: %s ", "accuracy: %s ",
(i + 1), data_magf.x, data_magf.y, data_magf.z, (i + 1), data_magf.x, data_magf.y, data_magf.z, BNO08x::accuracy_to_str(data_magf.accuracy));
BNO08x::accuracy_to_str(data_magf.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_rv.has_new_data()) if (imu->rpt.rv.has_new_data())
{ {
data_available_rv = true; data_available_rv = true;
data_quat = imu->rpt_rv.get_quat(); data_quat = imu->rpt.rv.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV: [n/a] real: %.2f i: %.2f j: %.2f k: %.2f " "Rx Data Trial %d Success: RV: [n/a] real: %.2f i: %.2f j: %.2f k: %.2f "
"accuracy: %s ", "accuracy: %s ",
(i + 1), data_quat.real, data_quat.i, data_quat.j, data_quat.k, (i + 1), data_quat.real, data_quat.i, data_quat.j, data_quat.k, BNO08x::accuracy_to_str(data_quat.accuracy));
BNO08x::accuracy_to_str(data_quat.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_rv_game.has_new_data()) if (imu->rpt.rv_game.has_new_data())
{ {
data_available_rv_game = true; data_available_rv_game = true;
data_quat = imu->rpt_rv_game.get_quat(); data_quat = imu->rpt.rv_game.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV Game: [n/a] real: %.2f i: %.2f j: %.2f k: %.2f " "Rx Data Trial %d Success: RV Game: [n/a] real: %.2f i: %.2f j: %.2f k: %.2f "
"accuracy: %s ", "accuracy: %s ",
(i + 1), data_quat.real, data_quat.i, data_quat.j, data_quat.k, (i + 1), data_quat.real, data_quat.i, data_quat.j, data_quat.k, BNO08x::accuracy_to_str(data_quat.accuracy));
BNO08x::accuracy_to_str(data_quat.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
if (imu->rpt_rv_geomagnetic.has_new_data()) if (imu->rpt.rv_geomagnetic.has_new_data())
{ {
data_available_rv_geomagnetic = true; data_available_rv_geomagnetic = true;
data_quat = imu->rpt_rv_geomagnetic.get_quat(); data_quat = imu->rpt.rv_geomagnetic.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV Geomagnetic: [n/a] real: %.2f i: %.2f j: %.2f k: " "Rx Data Trial %d Success: RV Geomagnetic: [n/a] real: %.2f i: %.2f j: %.2f k: "
"%.2f accuracy: %s ", "%.2f accuracy: %s ",
(i + 1), data_quat.real, data_quat.i, data_quat.j, data_quat.k, (i + 1), data_quat.real, data_quat.i, data_quat.j, data_quat.k, BNO08x::accuracy_to_str(data_quat.accuracy));
BNO08x::accuracy_to_str(data_quat.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_gravity.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.gravity.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_cal_gyro.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.cal_gyro.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_cal_magnetometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.cal_magnetometer.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_rv.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_rv_game.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_game.disable());
TEST_ASSERT_EQUAL(true, imu->rpt_rv_geomagnetic.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_geomagnetic.disable());
TEST_ASSERT_EQUAL(true, data_available_accel); TEST_ASSERT_EQUAL(true, data_available_accel);
TEST_ASSERT_EQUAL(true, data_available_lin_accel); TEST_ASSERT_EQUAL(true, data_available_lin_accel);
@ -341,8 +328,7 @@ TEST_CASE("Enable/Disable Octo Report", "[MultiReportEnableDisable]")
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
TEST_CASE( TEST_CASE("BNO08x Driver Cleanup for [MultiReportEnableDisable] Tests", "[MultiReportEnableDisable]")
"BNO08x Driver Cleanup for [MultiReportEnableDisable] Tests", "[MultiReportEnableDisable]")
{ {
const constexpr char* TEST_TAG = "BNO08x Driver Cleanup for [MultiReportEnableDisable] Tests"; const constexpr char* TEST_TAG = "BNO08x Driver Cleanup for [MultiReportEnableDisable] Tests";

137
test/SingleReportTests.cpp
View File

@ -11,8 +11,7 @@
#include "unity.h" #include "unity.h"
#include "../include/BNO08xTestHelper.hpp" #include "../include/BNO08xTestHelper.hpp"
TEST_CASE("BNO08x Driver Creation for [SingleReportEnableDisable] Tests", TEST_CASE("BNO08x Driver Creation for [SingleReportEnableDisable] Tests", "[SingleReportEnableDisable]")
"[SingleReportEnableDisable]")
{ {
const constexpr char* TEST_TAG = "BNO08x Driver Creation for [SingleReportEnableDisable] Tests"; const constexpr char* TEST_TAG = "BNO08x Driver Creation for [SingleReportEnableDisable] Tests";
BNO08x* imu = nullptr; BNO08x* imu = nullptr;
@ -44,17 +43,17 @@ TEST_CASE("Enable Incorrect Report", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
wrong_report_data_available = imu->rpt_linear_accelerometer.has_new_data(); wrong_report_data_available = imu->rpt.linear_accelerometer.has_new_data();
TEST_ASSERT_EQUAL(false, wrong_report_data_available); TEST_ASSERT_EQUAL(false, wrong_report_data_available);
data = imu->rpt_linear_accelerometer.get(); data = imu->rpt.linear_accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"No Rx Data Trial %d Success: LinAccelDefaults: [m/s^2] x: %.2f y: %.2f z: %.2f " "No Rx Data Trial %d Success: LinAccelDefaults: [m/s^2] x: %.2f y: %.2f z: %.2f "
@ -64,7 +63,7 @@ TEST_CASE("Enable Incorrect Report", "[SingleReportEnableDisable]")
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -84,26 +83,25 @@ TEST_CASE("Enable/Disable Accelerometer", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_accelerometer.has_new_data(); report_data_available = imu->rpt.accelerometer.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_accelerometer.get(); data = imu->rpt.accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data.x,
"Rx Data Trial %d Success: Accel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data.y, data.z, BNO08x::accuracy_to_str(data.accuracy));
(i + 1), data.x, data.y, data.z, BNO08x::accuracy_to_str(data.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.accelerometer.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -123,17 +121,17 @@ TEST_CASE("Enable/Disable Linear Accelerometer", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_linear_accelerometer.has_new_data(); report_data_available = imu->rpt.linear_accelerometer.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_linear_accelerometer.get(); data = imu->rpt.linear_accelerometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: LinearAccel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: " "Rx Data Trial %d Success: LinearAccel: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: "
@ -143,7 +141,7 @@ TEST_CASE("Enable/Disable Linear Accelerometer", "[SingleReportEnableDisable]")
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_linear_accelerometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.linear_accelerometer.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -163,26 +161,25 @@ TEST_CASE("Enable/Disable Gravity", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_gravity.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.gravity.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_gravity.has_new_data(); report_data_available = imu->rpt.gravity.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_gravity.get(); data = imu->rpt.gravity.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: Gravity: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data.x,
"Rx Data Trial %d Success: Gravity: [m/s^2] x: %.2f y: %.2f z: %.2f accuracy: %s ", data.y, data.z, BNO08x::accuracy_to_str(data.accuracy));
(i + 1), data.x, data.y, data.z, BNO08x::accuracy_to_str(data.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_gravity.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.gravity.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -202,17 +199,17 @@ TEST_CASE("Enable/Disable Cal Magnetometer", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_cal_magnetometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.cal_magnetometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_cal_magnetometer.has_new_data(); report_data_available = imu->rpt.cal_magnetometer.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_cal_magnetometer.get(); data = imu->rpt.cal_magnetometer.get();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: CalMagnetometer: [uTesla] x: %.2f y: %.2f z: %.2f " "Rx Data Trial %d Success: CalMagnetometer: [uTesla] x: %.2f y: %.2f z: %.2f "
@ -222,7 +219,7 @@ TEST_CASE("Enable/Disable Cal Magnetometer", "[SingleReportEnableDisable]")
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_cal_magnetometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.cal_magnetometer.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -243,28 +240,28 @@ TEST_CASE("Enable/Disable Uncal Magnetometer", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_uncal_magnetometer.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.uncal_magnetometer.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_uncal_magnetometer.has_new_data(); report_data_available = imu->rpt.uncal_magnetometer.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
imu->rpt_uncal_magnetometer.get(data_magf, data_bias); imu->rpt.uncal_magnetometer.get(data_magf, data_bias);
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: UncalMagnetometer: [uTesla] x: %.2f y: %.2f z: %.2f " "Rx Data Trial %d Success: UncalMagnetometer: [uTesla] x: %.2f y: %.2f z: %.2f "
"x_bias: %.2f y_bias: %.2f z_bias: %.2f accuracy: %s ", "x_bias: %.2f y_bias: %.2f z_bias: %.2f accuracy: %s ",
(i + 1), data_magf.x, data_magf.y, data_magf.z, data_bias.x, data_bias.y, (i + 1), data_magf.x, data_magf.y, data_magf.z, data_bias.x, data_bias.y, data_bias.z,
data_bias.z, BNO08x::accuracy_to_str(data_magf.accuracy)); BNO08x::accuracy_to_str(data_magf.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_uncal_magnetometer.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.uncal_magnetometer.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -284,26 +281,25 @@ TEST_CASE("Enable/Disable Cal Gyro", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_cal_gyro.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.cal_gyro.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_cal_gyro.has_new_data(); report_data_available = imu->rpt.cal_gyro.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_cal_gyro.get(); data = imu->rpt.cal_gyro.get();
sprintf(msg_buff, sprintf(msg_buff, "Rx Data Trial %d Success: CalGyro: [rad/s] x: %.2f y: %.2f z: %.2f accuracy: %s ", (i + 1), data.x,
"Rx Data Trial %d Success: CalGyro: [rad/s] x: %.2f y: %.2f z: %.2f accuracy: %s ", data.y, data.z, BNO08x::accuracy_to_str(data.accuracy));
(i + 1), data.x, data.y, data.z, BNO08x::accuracy_to_str(data.accuracy));
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_cal_gyro.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.cal_gyro.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -324,17 +320,17 @@ TEST_CASE("Enable/Disable Uncal Gyro", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_uncal_gyro.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.uncal_gyro.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_uncal_gyro.has_new_data(); report_data_available = imu->rpt.uncal_gyro.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
imu->rpt_uncal_gyro.get(data_vel, data_bias); imu->rpt.uncal_gyro.get(data_vel, data_bias);
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: UncalGyro: [rad/s] x: %.2f y: %.2f z: %.2f x_bias: %.2f " "Rx Data Trial %d Success: UncalGyro: [rad/s] x: %.2f y: %.2f z: %.2f x_bias: %.2f "
@ -345,7 +341,7 @@ TEST_CASE("Enable/Disable Uncal Gyro", "[SingleReportEnableDisable]")
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_uncal_gyro.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.uncal_gyro.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -365,17 +361,17 @@ TEST_CASE("Enable/Disable RV", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_rv.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_rv.has_new_data(); report_data_available = imu->rpt.rv.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_rv.get_quat(); data = imu->rpt.rv.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV: [n/a] real: %.2f i: %.2f j: %.2f k: %.2f accuracy: " "Rx Data Trial %d Success: RV: [n/a] real: %.2f i: %.2f j: %.2f k: %.2f accuracy: "
@ -385,7 +381,7 @@ TEST_CASE("Enable/Disable RV", "[SingleReportEnableDisable]")
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_rv.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -405,17 +401,17 @@ TEST_CASE("Enable/Disable Game RV", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_rv_game.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_game.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_rv_game.has_new_data(); report_data_available = imu->rpt.rv_game.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_rv_game.get_quat(); data = imu->rpt.rv_game.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV Game: [n/a] real: %.2f i: %.2f j: %.2f k: %.2f " "Rx Data Trial %d Success: RV Game: [n/a] real: %.2f i: %.2f j: %.2f k: %.2f "
@ -425,7 +421,7 @@ TEST_CASE("Enable/Disable Game RV", "[SingleReportEnableDisable]")
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_rv_game.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_game.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -445,17 +441,17 @@ TEST_CASE("Enable/Disable ARVR Stabilized RV", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_rv_ARVR_stabilized.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_ARVR_stabilized.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_rv_ARVR_stabilized.has_new_data(); report_data_available = imu->rpt.rv_ARVR_stabilized.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_rv_ARVR_stabilized.get_quat(); data = imu->rpt.rv_ARVR_stabilized.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV ARVR Stabilized: [n/a] real: %.2f i: %.2f j: %.2f k: " "Rx Data Trial %d Success: RV ARVR Stabilized: [n/a] real: %.2f i: %.2f j: %.2f k: "
@ -465,7 +461,7 @@ TEST_CASE("Enable/Disable ARVR Stabilized RV", "[SingleReportEnableDisable]")
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_rv_ARVR_stabilized.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_ARVR_stabilized.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -485,17 +481,17 @@ TEST_CASE("Enable/Disable ARVR Stabilized Game RV", "[SingleReportEnableDisable]
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_rv_ARVR_stabilized_game.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_ARVR_stabilized_game.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_rv_ARVR_stabilized_game.has_new_data(); report_data_available = imu->rpt.rv_ARVR_stabilized_game.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_rv_ARVR_stabilized_game.get_quat(); data = imu->rpt.rv_ARVR_stabilized_game.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV ARVR Stabilized Game: [n/a] real: %.2f i: %.2f j: " "Rx Data Trial %d Success: RV ARVR Stabilized Game: [n/a] real: %.2f i: %.2f j: "
@ -505,7 +501,7 @@ TEST_CASE("Enable/Disable ARVR Stabilized Game RV", "[SingleReportEnableDisable]
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_rv_ARVR_stabilized_game.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_ARVR_stabilized_game.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -525,17 +521,17 @@ TEST_CASE("Enable/Disable Gyro Integrated RV", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_rv_gyro_integrated.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_gyro_integrated.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_rv_gyro_integrated.has_new_data(); report_data_available = imu->rpt.rv_gyro_integrated.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_rv_gyro_integrated.get_quat(); data = imu->rpt.rv_gyro_integrated.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV Gyro Integrated: [n/a] real: %.2f i: %.2f j: %.2f k: " "Rx Data Trial %d Success: RV Gyro Integrated: [n/a] real: %.2f i: %.2f j: %.2f k: "
@ -545,7 +541,7 @@ TEST_CASE("Enable/Disable Gyro Integrated RV", "[SingleReportEnableDisable]")
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_rv_gyro_integrated.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_gyro_integrated.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
@ -565,17 +561,17 @@ TEST_CASE("Enable/Disable Geomagnetic RV", "[SingleReportEnableDisable]")
imu = BNO08xTestHelper::get_test_imu(); imu = BNO08xTestHelper::get_test_imu();
TEST_ASSERT_EQUAL(true, imu->rpt_rv_geomagnetic.enable(REPORT_PERIOD)); TEST_ASSERT_EQUAL(true, imu->rpt.rv_geomagnetic.enable(REPORT_PERIOD));
for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++) for (int i = 0; i < RX_REPORT_TRIAL_CNT; i++)
{ {
data_available = imu->data_available(); data_available = imu->data_available();
TEST_ASSERT_EQUAL(true, data_available); TEST_ASSERT_EQUAL(true, data_available);
report_data_available = imu->rpt_rv_geomagnetic.has_new_data(); report_data_available = imu->rpt.rv_geomagnetic.has_new_data();
TEST_ASSERT_EQUAL(true, report_data_available); TEST_ASSERT_EQUAL(true, report_data_available);
data = imu->rpt_rv_geomagnetic.get_quat(); data = imu->rpt.rv_geomagnetic.get_quat();
sprintf(msg_buff, sprintf(msg_buff,
"Rx Data Trial %d Success: RV Geomagnetic: [n/a] real: %.2f i: %.2f j: %.2f k: " "Rx Data Trial %d Success: RV Geomagnetic: [n/a] real: %.2f i: %.2f j: %.2f k: "
@ -585,13 +581,12 @@ TEST_CASE("Enable/Disable Geomagnetic RV", "[SingleReportEnableDisable]")
BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff); BNO08xTestHelper::print_test_msg(TEST_TAG, msg_buff);
} }
TEST_ASSERT_EQUAL(true, imu->rpt_rv_geomagnetic.disable()); TEST_ASSERT_EQUAL(true, imu->rpt.rv_geomagnetic.disable());
BNO08xTestHelper::print_test_end_banner(TEST_TAG); BNO08xTestHelper::print_test_end_banner(TEST_TAG);
} }
TEST_CASE("BNO08x Driver Cleanup for [SingleReportEnableDisable] Tests", TEST_CASE("BNO08x Driver Cleanup for [SingleReportEnableDisable] Tests", "[SingleReportEnableDisable]")
"[SingleReportEnableDisable]")
{ {
const constexpr char* TEST_TAG = "BNO08x Driver Cleanup for [SingleReportEnableDisable] Tests"; const constexpr char* TEST_TAG = "BNO08x Driver Cleanup for [SingleReportEnableDisable] Tests";