700 lines
19 KiB
C++
700 lines
19 KiB
C++
#include "BNO08x.hpp"
|
|
#include "BNO08x_macros.hpp"
|
|
|
|
/**
|
|
* @brief BNO08x imu constructor.
|
|
*
|
|
* Construct a BNO08x object for managing a BNO08x sensor.
|
|
*
|
|
* @param imu_config Configuration settings (optional), default settings can be seen in bno08x_config_t
|
|
* @return void, nothing to return
|
|
*/
|
|
BNO08x::BNO08x(bno08x_config_t imu_config)
|
|
: evt_grp_spi(xEventGroupCreate())
|
|
, imu_config(imu_config)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @brief BNO08x imu deconstructor.
|
|
*
|
|
* Deconstructs a BNO08x object and releases any utilized resources.
|
|
*
|
|
* @return void, nothing to return.
|
|
*/
|
|
BNO08x::~BNO08x()
|
|
{
|
|
// disable interrupts before beginning so we can ensure SPI transaction doesn't attempt to run
|
|
gpio_intr_disable(imu_config.io_int);
|
|
|
|
// deinitialize sh2 HAL if it has been initialized
|
|
ESP_ERROR_CHECK(deinit_sh2_HAL());
|
|
|
|
// deinitialize spi if has been initialized
|
|
ESP_ERROR_CHECK(deinit_spi());
|
|
|
|
// deinitialize hint ISR if it has been initialized
|
|
ESP_ERROR_CHECK(deinit_hint_isr());
|
|
|
|
// deinitialize GPIO if they have been initialized
|
|
ESP_ERROR_CHECK(deinit_gpio());
|
|
|
|
// delete event groups
|
|
vEventGroupDelete(evt_grp_spi);
|
|
|
|
// clear callback list
|
|
cb_list.clear();
|
|
}
|
|
|
|
/**
|
|
* @brief Initializes BNO08x sensor
|
|
*
|
|
* Resets sensor and goes through initialization process.
|
|
* Configures GPIO, required ISRs, and launches two tasks, one to manage SPI transactions, another to process any received data.
|
|
*
|
|
* @return True if initialization was success, false if otherwise.
|
|
*/
|
|
bool BNO08x::initialize()
|
|
{
|
|
|
|
// initialize configuration arguments
|
|
if (init_config_args() != ESP_OK)
|
|
return false;
|
|
|
|
// initialize GPIO
|
|
if (init_gpio() != ESP_OK)
|
|
return false;
|
|
|
|
// initialize HINT ISR
|
|
if (init_hint_isr() != ESP_OK)
|
|
return false;
|
|
|
|
// initialize SPI
|
|
if (init_spi() != ESP_OK)
|
|
return false;
|
|
|
|
// initialize SH2 HAL
|
|
if (init_sh2_HAL() != ESP_OK)
|
|
return false;
|
|
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGI(TAG, "Successfully initialized....");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief Initializes required esp-idf SPI data structures with values from user passed bno08x_config_t struct.
|
|
*
|
|
* @return ESP_OK if initialization was success.
|
|
*/
|
|
esp_err_t BNO08x::init_config_args()
|
|
{
|
|
if ((imu_config.io_cs == GPIO_NUM_NC))
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, CS GPIO cannot be unassigned.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if ((imu_config.io_miso == GPIO_NUM_NC))
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, MISO GPIO cannot be unassigned.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if ((imu_config.io_mosi == GPIO_NUM_NC))
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, MOSI GPIO cannot be unassigned.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if ((imu_config.io_sclk == GPIO_NUM_NC))
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, SCLK GPIO cannot be unassigned.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
if ((imu_config.io_rst == GPIO_NUM_NC))
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "RST GPIO cannot be unassigned.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
// SPI bus config
|
|
bus_config.mosi_io_num = imu_config.io_mosi; // assign mosi gpio pin
|
|
bus_config.miso_io_num = imu_config.io_miso; // assign miso gpio pin
|
|
bus_config.sclk_io_num = imu_config.io_sclk; // assign sclk gpio pin
|
|
bus_config.quadhd_io_num = -1; // hold signal gpio (not used)
|
|
bus_config.quadwp_io_num = -1; // write protect signal gpio (not used)
|
|
|
|
// SPI slave device specific config
|
|
imu_spi_config.mode = 0x3; // set mode to 3 as per BNO08x datasheet (CPHA second edge, CPOL bus high when idle)
|
|
|
|
if (imu_config.sclk_speed > SCLK_MAX_SPEED) // max sclk speed of 3MHz for BNO08x
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Max SPI clock speed exceeded, %ld overwritten with 3MHz", imu_config.sclk_speed);
|
|
#endif
|
|
// clang-format on
|
|
|
|
imu_config.sclk_speed = SCLK_MAX_SPEED;
|
|
}
|
|
|
|
imu_spi_config.clock_source = SPI_CLK_SRC_DEFAULT;
|
|
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.command_bits = 0; // 0 command bits, not using this system
|
|
imu_spi_config.spics_io_num = -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
|
|
imu_spi_config.queue_size = static_cast<int>(CONFIG_ESP32_BNO08X_SPI_QUEUE_SZ); // set max allowable queued SPI transactions
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief Initializes required gpio inputs.
|
|
*
|
|
* @return ESP_OK if initialization was success.
|
|
*/
|
|
esp_err_t BNO08x::init_gpio_inputs()
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
// configure input(s) (HINT)
|
|
gpio_config_t inputs_config;
|
|
inputs_config.pin_bit_mask = (1ULL << imu_config.io_int);
|
|
inputs_config.mode = GPIO_MODE_INPUT;
|
|
inputs_config.pull_up_en = GPIO_PULLUP_DISABLE;
|
|
inputs_config.pull_down_en = GPIO_PULLDOWN_DISABLE;
|
|
inputs_config.intr_type = GPIO_INTR_NEGEDGE;
|
|
|
|
ret = gpio_config(&inputs_config);
|
|
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, failed to configure HINT gpio.");
|
|
#endif
|
|
// clang-format on
|
|
}
|
|
else
|
|
{
|
|
init_status.gpio_inputs = true; // set gpio_inputs to initialized such that deconstructor knows to clean them up
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Initializes required gpio outputs.
|
|
*
|
|
* @return ESP_OK if initialization was success.
|
|
*/
|
|
esp_err_t BNO08x::init_gpio_outputs()
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
// configure output(s) (CS, RST, and WAKE)
|
|
gpio_config_t outputs_config;
|
|
|
|
outputs_config.pin_bit_mask = (imu_config.io_wake != GPIO_NUM_NC)
|
|
? ((1ULL << imu_config.io_cs) | (1ULL << imu_config.io_rst) | (1ULL << imu_config.io_wake))
|
|
: ((1ULL << imu_config.io_cs) | (1ULL << imu_config.io_rst));
|
|
|
|
outputs_config.mode = GPIO_MODE_OUTPUT;
|
|
outputs_config.pull_down_en = GPIO_PULLDOWN_DISABLE;
|
|
outputs_config.pull_up_en = GPIO_PULLUP_DISABLE;
|
|
outputs_config.intr_type = GPIO_INTR_DISABLE;
|
|
|
|
ret = gpio_config(&outputs_config);
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, failed to configure CS, RST, and WAKE (if used) gpio.");
|
|
#endif
|
|
// clang-format on
|
|
}
|
|
else
|
|
{
|
|
init_status.gpio_outputs = true; // set gpio_inputs to initialized such that deconstructor knows to clean them up
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Initializes required gpio.
|
|
*
|
|
* @return ESP_OK if initialization was success.
|
|
*/
|
|
esp_err_t BNO08x::init_gpio()
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
/*GPIO config for pins not controlled by SPI peripheral*/
|
|
|
|
ret = init_gpio_outputs();
|
|
if (ret != ESP_OK)
|
|
return ret;
|
|
|
|
ret = init_gpio_inputs();
|
|
if (ret != ESP_OK)
|
|
return ret;
|
|
|
|
gpio_set_level(imu_config.io_cs, 1);
|
|
gpio_set_level(imu_config.io_rst, 1);
|
|
|
|
if (imu_config.io_wake != GPIO_NUM_NC)
|
|
gpio_set_level(imu_config.io_wake, 1);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Initializes host interrupt ISR.
|
|
*
|
|
* @return ESP_OK if initialization was success.
|
|
*/
|
|
esp_err_t BNO08x::init_hint_isr()
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
// check if installation of ISR service has been requested by user (default is true)
|
|
if (imu_config.install_isr_service)
|
|
ret = gpio_install_isr_service(0); // install isr service
|
|
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, failed to install global ISR service.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
init_status.isr_service = 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)
|
|
}
|
|
|
|
ret = gpio_isr_handler_add(imu_config.io_int, hint_handler, (void*) this);
|
|
if (ret != ESP_OK)
|
|
{
|
|
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, failed to add hint_handler ISR.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
init_status.isr_handler = true; // set isr handler to initialized such that deconstructor knows to clean it up
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Initializes SPI.
|
|
*
|
|
* @return ESP_OK if initialization was success.
|
|
*/
|
|
esp_err_t BNO08x::init_spi()
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
// initialize the spi peripheral
|
|
ret = spi_bus_initialize(imu_config.spi_peripheral, &bus_config, SPI_DMA_CH_AUTO);
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, SPI bus failed to initialize.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
init_status.spi_bus = true;
|
|
}
|
|
|
|
// add the imu device to the bus
|
|
ret = spi_bus_add_device(imu_config.spi_peripheral, &imu_spi_config, &spi_hdl);
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, failed to add device to SPI bus.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
init_status.spi_device = true;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Initializes sh2 HAL.
|
|
*
|
|
* @return ESP_OK if initialization was success.
|
|
*/
|
|
esp_err_t BNO08x::init_sh2_HAL()
|
|
{
|
|
// use this IMU in sh2 HAL callbacks
|
|
BNO08xSH2HAL::set_hal_imu(this);
|
|
|
|
// register sh2 HAL callbacks
|
|
sh2_HAL.open = BNO08xSH2HAL::spi_open;
|
|
sh2_HAL.close = BNO08xSH2HAL::spi_close;
|
|
sh2_HAL.read = BNO08xSH2HAL::spi_read;
|
|
sh2_HAL.write = BNO08xSH2HAL::spi_write;
|
|
sh2_HAL.getTimeUs = BNO08xSH2HAL::get_time_us;
|
|
|
|
// reset BNO08x
|
|
hard_reset();
|
|
|
|
if (sh2_open(&sh2_HAL, BNO08xSH2HAL::hal_cb, NULL) != SH2_OK)
|
|
return ESP_FAIL;
|
|
|
|
init_status.sh2_HAL = true;
|
|
|
|
memset(&product_ID, 0, sizeof(product_ID));
|
|
|
|
if (sh2_getProdIds(&product_ID) != SH2_OK)
|
|
return ESP_FAIL;
|
|
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
print_product_ids();
|
|
#endif
|
|
// clang-format on
|
|
|
|
sh2_setSensorCallback(BNO08xSH2HAL::sensor_report_cb, NULL);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief Deinitializes GPIO, called from deconstructor.
|
|
*
|
|
* @return ESP_OK if deinitialization was success.
|
|
*/
|
|
esp_err_t BNO08x::deinit_gpio()
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
if (init_status.gpio_inputs)
|
|
{
|
|
ret = deinit_gpio_inputs();
|
|
if (ret != ESP_OK)
|
|
return ret;
|
|
}
|
|
|
|
if (init_status.gpio_outputs)
|
|
{
|
|
ret = deinit_gpio_outputs();
|
|
if (ret != ESP_OK)
|
|
return ret;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Deinitializes GPIO inputs, called from deconstructor.
|
|
*
|
|
* @return ESP_OK if deinitialization was success.
|
|
*/
|
|
esp_err_t BNO08x::deinit_gpio_inputs()
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
ret = gpio_reset_pin(imu_config.io_int);
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Initialization failed, failed to add device to SPI bus.");
|
|
#endif
|
|
// clang-format on
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Deinitializes GPIO outputs, called from deconstructor.
|
|
*
|
|
* @return ESP_OK if deinitialization was success.
|
|
*/
|
|
esp_err_t BNO08x::deinit_gpio_outputs()
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
if (imu_config.io_wake != GPIO_NUM_NC)
|
|
{
|
|
ret = gpio_reset_pin(imu_config.io_wake);
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Deconstruction failed, could reset gpio WAKE pin to default state.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
ret = gpio_reset_pin(imu_config.io_cs);
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Deconstruction failed, could reset gpio CS pin to default state.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ret;
|
|
}
|
|
|
|
ret = gpio_reset_pin(imu_config.io_rst);
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Deconstruction failed, could reset gpio RST pin to default state.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ret;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Deinitializes host interrupt ISR, called from deconstructor.
|
|
*
|
|
* @return ESP_OK if deinitialization was success.
|
|
*/
|
|
esp_err_t BNO08x::deinit_hint_isr()
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
if (init_status.isr_handler)
|
|
{
|
|
ret = gpio_isr_handler_remove(imu_config.io_int);
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Deconstruction failed, could not remove hint ISR handler.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
if (init_status.isr_service)
|
|
{
|
|
// only remove the ISR service if it was requested to be installed by user
|
|
if (imu_config.install_isr_service)
|
|
{
|
|
gpio_uninstall_isr_service();
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Deinitializes SPI.
|
|
*
|
|
* @return ESP_OK if deinitialization was success.
|
|
*/
|
|
esp_err_t BNO08x::deinit_spi()
|
|
{
|
|
esp_err_t ret = ESP_OK;
|
|
|
|
if (init_status.spi_device)
|
|
{
|
|
ret = spi_bus_remove_device(spi_hdl);
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Deconstruction failed, could not remove spi device.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
if (init_status.spi_bus)
|
|
{
|
|
ret = spi_bus_free(imu_config.spi_peripheral);
|
|
if (ret != ESP_OK)
|
|
{
|
|
// clang-format off
|
|
#ifdef CONFIG_ESP32_BNO08x_LOG_STATEMENTS
|
|
ESP_LOGE(TAG, "Deconstruction failed, could free SPI peripheral.");
|
|
#endif
|
|
// clang-format on
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Deinitializes sh2 HAL.
|
|
*
|
|
* @return ESP_OK if deinitialization was success.
|
|
*/
|
|
esp_err_t BNO08x::deinit_sh2_HAL()
|
|
{
|
|
if (init_status.sh2_HAL)
|
|
sh2_close();
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief Hard resets BNO08x sensor.
|
|
*
|
|
* @return void, nothing to return
|
|
*/
|
|
void BNO08x::hard_reset()
|
|
{
|
|
|
|
gpio_intr_disable(imu_config.io_int); // disable interrupts before reset
|
|
|
|
gpio_set_level(imu_config.io_cs, 1);
|
|
|
|
if (imu_config.io_wake != GPIO_NUM_NC)
|
|
gpio_set_level(imu_config.io_wake, 1);
|
|
|
|
gpio_set_level(imu_config.io_rst, 0); // set reset pin low
|
|
gpio_intr_enable(imu_config.io_int); // enable interrupts before bringing out of reset
|
|
vTaskDelay(HARD_RESET_DELAY_MS); // 10ns min, set to larger delay to let things stabilize(Anton)
|
|
gpio_set_level(imu_config.io_rst, 1); // bring out of reset
|
|
}
|
|
|
|
/**
|
|
* @brief Waits for HINT pin assertion or HOST_INT_TIMEOUT_DEFAULT_MS to elapse.
|
|
*
|
|
*
|
|
* @return ESP_OK if HINT was asserted.
|
|
*/
|
|
esp_err_t BNO08x::wait_for_hint()
|
|
{
|
|
EventBits_t spi_evt_bits;
|
|
|
|
spi_evt_bits = xEventGroupWaitBits(evt_grp_spi, EVT_GRP_SPI_HINT_ASSERTED_BIT, pdTRUE, pdFALSE, HOST_INT_TIMEOUT_DEFAULT_MS);
|
|
|
|
if (spi_evt_bits & EVT_GRP_SPI_HINT_ASSERTED_BIT)
|
|
return ESP_OK;
|
|
else
|
|
return ESP_ERR_TIMEOUT;
|
|
}
|
|
|
|
/**
|
|
* @brief Registers a callback to execute when new data from a report is received.
|
|
*
|
|
* @param cb_fxn Pointer to the call-back function should be of void return type and void input parameters.
|
|
*
|
|
* @return void, nothing to return
|
|
*/
|
|
void BNO08x::register_cb(std::function<void()> cb_fxn)
|
|
{
|
|
cb_list.push_back(cb_fxn);
|
|
}
|
|
|
|
/**
|
|
* @brief Prints product IDs received at initialization.
|
|
*
|
|
* @return void, nothing to return
|
|
*/
|
|
void BNO08x::print_product_ids()
|
|
{
|
|
for (int i = 0; i < product_ID.numEntries; i++)
|
|
{
|
|
ESP_LOGI(TAG,
|
|
"Product ID %d Info: \n\r"
|
|
" ---------------------------\n\r"
|
|
" Product ID: 0x%" PRIx32 "\n\r"
|
|
" SW Version Major: 0x%" PRIx8 "\n\r"
|
|
" SW Version Minor: 0x%" PRIx8 "\n\r"
|
|
" SW Build Number: 0x%" PRIx32 "\n\r"
|
|
" SW Version Patch: 0x%" PRIx16 "\n\r"
|
|
" ---------------------------\n\r",
|
|
i, product_ID.entry->swPartNumber, product_ID.entry->swVersionMajor, product_ID.entry->swVersionMinor,
|
|
product_ID.entry->swBuildNumber, product_ID.entry->swVersionPatch);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief HINT interrupt service routine, handles falling edge of BNO08x HINT pin.
|
|
*
|
|
* ISR that launches SPI task to perform transaction upon assertion of BNO08x interrupt pin.
|
|
*
|
|
* @return void, nothing to return
|
|
*/
|
|
void IRAM_ATTR BNO08x::hint_handler(void* arg)
|
|
{
|
|
BaseType_t xHighPriorityTaskWoken = pdFALSE;
|
|
BNO08x* imu = (BNO08x*) arg; // cast argument received by gpio_isr_handler_add ("this" pointer to imu object
|
|
// created by constructor call)
|
|
|
|
// notify any tasks/function calls waiting for HINT assertion
|
|
xEventGroupSetBitsFromISR(imu->evt_grp_spi, EVT_GRP_SPI_HINT_ASSERTED_BIT, &xHighPriorityTaskWoken);
|
|
portYIELD_FROM_ISR(xHighPriorityTaskWoken); // perform context switch if necessary
|
|
}
|