bmg160.h

Go to the documentation of this file.

/*
 * Author: Jon Trulson <jtrulson@ics.com>
 * Copyright (c) 2017 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 <unistd.h>
#include <string.h>

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

#include "upm.h"

#include "bmg160_defs.h"

#ifdef __cplusplus
extern "C" {
#endif

    typedef struct _bmg160_context {
        mraa_i2c_context i2c;
        mraa_spi_context spi;
        mraa_gpio_context gpioCS; // SPI CS pin
        mraa_gpio_context gpio1;  // intr 1
        mraa_gpio_context gpio2;  // intr 2

        // using SPI?
        bool isSPI;
        // use the FIFO?
        bool useFIFO;

        // always stored in C
        float temperature;

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

        // gyr scaling
        float gyrScale;
    } *bmg160_context;

    bmg160_context bmg160_init(int bus, int addr, int cs);

    void bmg160_close(bmg160_context dev);

    upm_result_t bmg160_update(const bmg160_context dev);

    uint8_t bmg160_get_chip_id(const bmg160_context dev);

    void bmg160_get_gyroscope(const bmg160_context dev,
                              float *x, float *y, float *z);

    float bmg160_get_temperature(const bmg160_context dev);

    upm_result_t bmg160_devinit(const bmg160_context dev,
                                BMG160_POWER_MODE_T pwr,
                                BMG160_RANGE_T range,
                                BMG160_BW_T bw);

    upm_result_t bmg160_reset(const bmg160_context dev);

    upm_result_t bmg160_set_range(const bmg160_context dev,
                                  BMG160_RANGE_T range);

    upm_result_t bmg160_set_bandwidth(const bmg160_context dev,
                                      BMG160_BW_T bw);

    upm_result_t bmg160_set_power_mode(const bmg160_context dev,
                                       BMG160_POWER_MODE_T power);

    void bmg160_enable_fifo(const bmg160_context dev, bool useFIFO);

    upm_result_t bmg160_fifo_set_watermark(const bmg160_context dev, int wm);

    upm_result_t bmg160_fifo_config(const bmg160_context dev,
                                    BMG160_FIFO_MODE_T mode,
                                    BMG160_FIFO_DATA_SEL_T axes);

    uint8_t bmg160_get_interrupt_enable0(const bmg160_context dev);

    upm_result_t bmg160_set_interrupt_enable0(const bmg160_context dev,
                                              uint8_t bits);

    uint8_t bmg160_get_interrupt_map0(const bmg160_context dev);

    upm_result_t bmg160_set_interrupt_map0(const bmg160_context dev,
                                           uint8_t bits);

    uint8_t bmg160_get_interrupt_map1(const bmg160_context dev);

    upm_result_t bmg160_set_interrupt_map1(const bmg160_context dev,
                                           uint8_t bits);

    uint8_t bmg160_get_interrupt_src(const bmg160_context dev);

    upm_result_t bmg160_set_interrupt_src(const bmg160_context dev,
                                          uint8_t bits);

    uint8_t bmg160_get_interrupt_output_control(const bmg160_context dev);

    upm_result_t bmg160_set_interrupt_output_control(const bmg160_context dev,
                                                     uint8_t bits);

    upm_result_t bmg160_clear_interrupt_latches(const bmg160_context dev);

    BMG160_RST_LATCH_T bmg160_get_interrupt_latch_behavior(
        const bmg160_context dev);

    upm_result_t bmg160_set_interrupt_latch_behavior(const bmg160_context dev,
                                                     BMG160_RST_LATCH_T latch);

    uint8_t bmg160_get_interrupt_status0(const bmg160_context dev);

    uint8_t bmg160_get_interrupt_status1(const bmg160_context dev);

    uint8_t bmg160_get_interrupt_status2(const bmg160_context dev);

    uint8_t bmg160_get_interrupt_status3(const bmg160_context dev);

    upm_result_t bmg160_enable_register_shadowing(const bmg160_context dev,
                                                  bool shadow);

    upm_result_t bmg160_enable_output_filtering(const bmg160_context dev,
                                                bool filter);

    upm_result_t bmg160_install_isr(const bmg160_context dev,
                                    BMG160_INTERRUPT_PINS_T intr, int gpio,
                                    mraa_gpio_edge_t level,
                                    void (*isr)(void *), void *arg);

    void bmg160_uninstall_isr(const bmg160_context dev,
                              BMG160_INTERRUPT_PINS_T intr);

    uint8_t bmg160_read_reg(const bmg160_context dev, uint8_t reg);

    int bmg160_read_regs(const bmg160_context dev, uint8_t reg,
                         uint8_t *buffer, int len);

    upm_result_t bmg160_write_reg(const bmg160_context dev,
                                  uint8_t reg, uint8_t val);


#ifdef __cplusplus
}
#endif