bno055.h

Go to the documentation of this file.

/*
 * Author: Jon Trulson <jtrulson@ics.com>
 * Copyright (c) 2016 Intel Corporation.
 *
 * The MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#pragma once

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <upm.h>

#include <mraa/i2c.h>
#include <mraa/gpio.h>

#include "bno055_regs.h"

#ifdef __cplusplus
extern "C" {
#endif

    typedef struct _bno055_context {
        mraa_i2c_context i2c;
        mraa_gpio_context gpio;

        // always stored in C
        float temperature;

        int currentPage;
        BNO055_OPERATION_MODES_T currentMode;

        // uncompensated data

        // mag data
        float magX;
        float magY;
        float magZ;

        // acc data
        float accX;
        float accY;
        float accZ;

        // acc units
        float accUnitScale;

        // gyr data
        float gyrX;
        float gyrY;
        float gyrZ;

        // gyr units
        float gyrUnitScale;

        // eul (euler angle) data
        float eulHeading;
        float eulRoll;
        float eulPitch;

        // eul units
        float eulUnitScale;

        // qua (quaternion) data
        float quaW;
        float quaX;
        float quaY;
        float quaZ;

        // lia (linear acceleration) data
        float liaX;
        float liaY;
        float liaZ;

        // grv (gravity vector) data
        float grvX;
        float grvY;
        float grvZ;
    } *bno055_context;

    bno055_context bno055_init(int bus, uint8_t addr);

    void bno055_close(bno055_context dev);

    upm_result_t bno055_update(const bno055_context dev);

    upm_result_t bno055_get_chip_id(const bno055_context dev,
                                    uint8_t *chip_id);

    upm_result_t bno055_get_acc_id(const bno055_context dev,
                                   uint8_t *chip_id);

    upm_result_t bno055_get_mag_id(const bno055_context dev,
                                   uint8_t *chip_id);

    upm_result_t bno055_get_gyr_id(const bno055_context dev,
                                   uint8_t *chip_id);

    upm_result_t bno055_get_sw_revision(const bno055_context dev,
                                        uint16_t *sw_rev);

    upm_result_t bno055_get_bootloader_id(const bno055_context dev,
                                          uint8_t *bl_id);

    upm_result_t bno055_set_clock_external(const bno055_context dev,
                                           bool extClock);

    upm_result_t bno055_set_temperature_source(const bno055_context dev,
                                               BNO055_TEMP_SOURCES_T src);

    upm_result_t bno055_set_temperature_units_celsius(const bno055_context dev);

    upm_result_t bno055_set_operation_mode(const bno055_context dev,
                                           BNO055_OPERATION_MODES_T mode);

    upm_result_t bno055_reset_system(const bno055_context dev);

    upm_result_t bno055_get_calibration_status(const bno055_context dev,
                                               int *mag, int *acc,
                                               int *gyr, int *sys);

    bool bno055_is_fully_calibrated(const bno055_context dev);

    upm_result_t bno055_read_calibration_data(const bno055_context dev,
                                              uint8_t *data, size_t len);

    upm_result_t bno055_write_calibration_data(const bno055_context dev,
                                               uint8_t *data,
                                               size_t len);

    float bno055_get_temperature(const bno055_context dev);

    void bno055_get_euler_angles(const bno055_context dev, float *heading,
                                 float *roll, float *pitch);

    void bno055_get_quaternions(const bno055_context dev, float *w, float *x,
                                float *y, float *z);

    void bno055_get_linear_acceleration(const bno055_context dev, float *x,
                                        float *y, float *z);

    void bno055_get_gravity_vectors(const bno055_context dev,
                                    float *x, float *y, float *z);

    void bno055_get_accelerometer(const bno055_context dev, float *x, float *y,
                                  float *z);

    void bno055_get_magnetometer(const bno055_context dev, float *x, float *y,
                                 float *z);

    void bno055_get_gyroscope(const bno055_context dev,
                              float *x, float *y, float *z);

    upm_result_t bno055_set_acceleration_config(const bno055_context dev,
                                                BNO055_ACC_RANGE_T range,
                                                BNO055_ACC_BW_T bw,
                                                BNO055_ACC_PWR_MODE_T pwr);

    upm_result_t bno055_set_magnetometer_config(const bno055_context dev,
                                                BNO055_MAG_ODR_T odr,
                                                BNO055_MAG_OPR_T opr,
                                                BNO055_MAG_POWER_T pwr);

    upm_result_t bno055_set_gyroscope_config(const bno055_context dev,
                                             BNO055_GYR_RANGE_T range,
                                             BNO055_GYR_BW_T bw,
                                             BNO055_GYR_POWER_MODE_T pwr);

    upm_result_t bno055_set_accelerometer_units(const bno055_context dev,
                                                bool mg);

    upm_result_t bno055_set_gyroscope_units(const bno055_context dev,
                                            bool radians);

    upm_result_t bno055_set_euler_units(const bno055_context dev,
                                        bool radians);

    upm_result_t bno055_reset_interrupt_status(const bno055_context dev);

    upm_result_t bno055_get_interrupt_status(const bno055_context dev,
                                             uint8_t *istat);

    upm_result_t bno055_get_interrupt_enable(const bno055_context dev,
                                             uint8_t *ienable);

    upm_result_t bno055_set_interrupt_enable(const bno055_context dev,
                                             uint8_t enables);

    upm_result_t bno055_get_interrupt_mask(const bno055_context dev,
                                           uint8_t *imask);

    upm_result_t bno055_set_interrupt_mask(const bno055_context dev,
                                           uint8_t mask);

    upm_result_t bno055_get_system_status(const bno055_context dev,
                                          BNO055_SYS_STATUS_T *sys_stat);

    upm_result_t bno055_get_system_error(const bno055_context dev,
                                         BNO055_SYS_ERR_T *sys_err);

    upm_result_t bno055_install_isr(const bno055_context dev,
                                    int gpio, mraa_gpio_edge_t level,
                                    void (*isr)(void *), void *arg);

    void bno055_uninstall_isr(const bno055_context dev);

    upm_result_t bno055_set_page(const bno055_context dev, uint8_t page,
                                 bool force);

    upm_result_t bno055_read_reg(const bno055_context dev, uint8_t reg,
                                 uint8_t *retval);

    upm_result_t bno055_read_regs(const bno055_context dev, uint8_t reg,
                                  uint8_t *buffer, size_t len);

    upm_result_t bno055_write_reg(const bno055_context dev,
                                  uint8_t reg, uint8_t val);

    upm_result_t bno055_write_regs(const bno055_context dev, uint8_t reg,
                                   uint8_t *buffer, size_t len);

#ifdef __cplusplus
}
#endif