bmm150.hpp

/*
 * Author: Jon Trulson <jtrulson@ics.com>
 * Copyright (c) 2016 Intel Corporation.
 *
 * 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 <string>
#include <mraa/i2c.hpp>
#include <mraa/spi.hpp>
#include <mraa/gpio.hpp>

#define BMM150_I2C_BUS 0
#define BMM150_SPI_BUS 0
#define BMM150_DEFAULT_ADDR 0x10


namespace upm {

  class BMM150 {
  public:

    // NOTE: Reserved registers must not be written into.  Reading
    // from them may return indeterminate values.  Registers
    // containing reserved bitfields must be written as 0.  Reading
    // reserved bitfields may return indeterminate values.

    typedef enum : uint8_t {
      REG_CHIP_ID                      = 0x40,

      // 0x41 reserved

      REG_MAG_X_LSB                    = 0x42,
      REG_MAG_X_MSB                    = 0x43,
      REG_MAG_Y_LSB                    = 0x44,
      REG_MAG_Y_MSB                    = 0x45,
      REG_MAG_Z_LSB                    = 0x46,
      REG_MAG_Z_MSB                    = 0x47,

      REG_RHALL_LSB                    = 0x48,
      REG_RHALL_MSB                    = 0x49,

      REG_INT_STATUS                   = 0x4a,

      REG_POWER_CTRL                   = 0x4b,

      REG_OPMODE                       = 0x4c,

      REG_INT_EN                       = 0x4d,
      REG_INT_CONFIG                   = 0x4e,

      REG_LOW_THRES                    = 0x4f,
      REG_HIGH_THRES                   = 0x50,

      REG_REP_XY                       = 0x51,
      REG_REP_Z                        = 0x52,

      // 0x53-0x71 reserved (mostly)

      // TRIM registers from Bosch BMM050 driver
      REG_TRIM_DIG_X1                  = 0x5d,
      REG_TRIM_DIG_Y1                  = 0x5e,

      REG_TRIM_DIG_Z4_LSB              = 0x62,
      REG_TRIM_DIG_Z4_MSB              = 0x63,
      REG_TRIM_DIG_X2                  = 0x64,
      REG_TRIM_DIG_Y2                  = 0x65,

      REG_TRIM_DIG_Z2_LSB              = 0x68,
      REG_TRIM_DIG_Z2_MSB              = 0x69,
      REG_TRIM_DIG_Z1_LSB              = 0x6a,
      REG_TRIM_DIG_Z1_MSB              = 0x6b,
      REG_TRIM_DIG_XYZ1_LSB            = 0x6c,
      REG_TRIM_DIG_XYZ1_MSB            = 0x6d,
      REG_TRIM_DIG_Z3_LSB              = 0x6e,
      REG_TRIM_DIG_Z3_MSB              = 0x6f,
      REG_TRIM_DIG_XY2                 = 0x70,
      REG_TRIM_DIG_XY1                 = 0x71

    } BMM150_REGS_T;

    typedef enum {
      _MAG_XY_LSB_RESERVED_BITS        = 0x02 | 0x04,

      MAG_XY_LSB_SELFTEST_XY           = 0x01,

      MAG_XY_LSB_LSB0                  = 0x08,
      MAG_XY_LSB_LSB1                  = 0x10,
      MAG_XY_LSB_LSB2                  = 0x20,
      MAG_XY_LSB_LSB3                  = 0x40,
      MAG_XY_LSB_LSB4                  = 0x80,
      _MAG_XY_LSB_LSB_MASK             = 31,
      _MAG_XY_LSB_LSB_SHIFT            = 3
    } MAG_XY_LSB_BITS_T;

    typedef enum {
      MAG_Z_LSB_SELFTEST_Z             = 0x01,

      MAG_Z_LSB_LSB0                   = 0x02,
      MAG_Z_LSB_LSB1                   = 0x04,
      MAG_Z_LSB_LSB2                   = 0x08,
      MAG_Z_LSB_LSB3                   = 0x10,
      MAG_Z_LSB_LSB4                   = 0x20,
      MAG_Z_LSB_LSB5                   = 0x40,
      MAG_Z_LSB_LSB6                   = 0x80,
      _MAG_Z_LSB_LSB_MASK              = 127,
      _MAG_Z_LSB_LSB_SHIFT             = 1
    } MAG_Z_LSB_BITS_T;

    typedef enum {
      _MAG_RHALL_LSB_RESERVED_BITS     = 0x02,

      MAG_RHALL_LSB_DATA_READY_STATUS  = 0x01,

      MAG_RHALL_LSB_LSB0               = 0x04,
      MAG_RHALL_LSB_LSB1               = 0x08,
      MAG_RHALL_LSB_LSB2               = 0x10,
      MAG_RHALL_LSB_LSB3               = 0x20,
      MAG_RHALL_LSB_LSB4               = 0x40,
      MAG_RHALL_LSB_LSB5               = 0x80,
      _MAG_RHALL_LSB_LSB_MASK          = 63,
      _MAG_RHALL_LSB_LSB_SHIFT         = 2
    } MAG_RHALL_LSB_BITS_T;

    typedef enum {
      INT_STATUS_LOW_INT_X             = 0x01,
      INT_STATUS_LOW_INT_Y             = 0x02,
      INT_STATUS_LOW_INT_Z             = 0x04,
      INT_STATUS_HIGH_INT_X            = 0x08,
      INT_STATUS_HIGH_INT_Y            = 0x10,
      INT_STATUS_HIGH_INT_Z            = 0x20,
      INT_STATUS_OVERFLOW              = 0x40,
      INT_STATUS_DATA_OVERRUN          = 0x80
    } INT_STATUS_BITS_T;

    typedef enum {
      _POWER_CTRL_RESERVED_BITS        = 0x40 | 0x20 | 0x10 | 0x08,

      POWER_CTRL_POWER_CTRL_BIT        = 0x01,
      POWER_CTRL_SOFT_RESET0           = 0x02,
      POWER_CTRL_SPI3EN                = 0x04, // not supported

      POWER_CTRL_SOFT_RESET1           = 0x80
    } POWER_CTRL_BITS_T;

    typedef enum {
      OPMODE_SELFTTEST                 = 0x01,

      OPMODE_OPERATION_MODE0           = 0x02,
      OPMODE_OPERATION_MODE1           = 0x04,
      _OPMODE_OPERATION_MODE_MASK      = 3,
      _OPMODE_OPERATION_MODE_SHIFT     = 1,

      OPMODE_DATA_RATE0                = 0x08,
      OPMODE_DATA_RATE1                = 0x10,
      OPMODE_DATA_RATE2                = 0x20,
      _OPMODE_DATA_RATE_MASK           = 7,
      _OPMODE_DATA_RATE_SHIFT          = 3,

      OPMODE_ADV_SELFTEST0             = 0x40,
      OPMODE_ADV_SELFTEST1             = 0x80,
      _OPMODE_ADV_SELFTEST_MASK        = 3,
      _OPMODE_ADV_SELFTEST_SHIFT       = 6
    } OPMODE_BITS_T;

    typedef enum {
      OPERATION_MODE_NORMAL            = 0,
      OPERATION_MODE_FORCED            = 1,
      OPERATION_MODE_SLEEP             = 3
    } OPERATION_MODE_T;

    typedef enum {
      DATA_RATE_10HZ                   = 0,
      DATA_RATE_2HZ                    = 1,
      DATA_RATE_6HZ                    = 2,
      DATA_RATE_8HZ                    = 3,
      DATA_RATE_15HZ                   = 4,
      DATA_RATE_20HZ                   = 5,
      DATA_RATE_25HZ                   = 6,
      DATA_RATE_30HZ                   = 7
    } DATA_RATE_T;

    typedef enum {
      INT_EN_LOW_INT_X_EN              = 0x01,
      INT_EN_LOW_INT_Y_EN              = 0x02,
      INT_EN_LOW_INT_Z_EN              = 0x04,
      INT_EN_HIGH_INT_X_EN             = 0x08,
      INT_EN_HIGH_INT_Y_EN             = 0x10,
      INT_EN_HIGH_INT_Z_EN             = 0x20,
      INT_EN_OVERFLOW_INT_EN           = 0x40,
      INT_EN_DATA_OVERRUN_INT_EN       = 0x80
    } INT_EN_T;

    typedef enum {
      INT_CONFIG_INT_POLARITY          = 0x01,
      INT_CONFIG_INT_LATCH             = 0x02,
      INT_CONFIG_DR_POLARITY           = 0x04,
      INT_CONFIG_CHANNEL_X             = 0x08,
      INT_CONFIG_CHANNEL_Y             = 0x10,
      INT_CONFIG_CHANNEL_Z             = 0x20,
      INT_CONFIG_INT_PIN_EN            = 0x40,
      INT_CONFIG_DR_PIN_EN             = 0x80
    } INT_CONFIG_T;

    typedef enum {
      INTERRUPT_INT,
      INTERRUPT_DR
    } INTERRUPT_PINS_T;

    typedef enum {
      USAGE_LOW_POWER,
      USAGE_REGULAR,
      USAGE_ENHANCED_REGULAR,
      USAGE_HIGH_ACCURACY
    } USAGE_PRESETS_T;

    BMM150(int bus=BMM150_I2C_BUS, int addr=BMM150_DEFAULT_ADDR,
           int cs=-1);

    ~BMM150();

    void update();

    uint8_t getChipID();

    void getMagnetometer(float *x, float *y, float *z);

    float *getMagnetometer();

    void init(USAGE_PRESETS_T usage=USAGE_HIGH_ACCURACY);

    void setPresetMode(USAGE_PRESETS_T usage);

    void reset();

    void setOutputDataRate(DATA_RATE_T odr);

    void setPowerBit(bool power);

    void setOpmode(OPERATION_MODE_T opmode);

    OPERATION_MODE_T getOpmode();

    uint8_t getInterruptEnable();

    void setInterruptEnable(uint8_t bits);

    uint8_t getInterruptConfig();

    void setInterruptConfig(uint8_t bits);

    uint8_t getInterruptStatus();

    void setRepetitionsXY(uint8_t reps);

    void setRepetitionsZ(uint8_t reps);

#if defined(SWIGJAVA) || defined(JAVACALLBACK)
    void installISR(INTERRUPT_PINS_T intr, int gpio, mraa::Edge level,
                    jobject runnable);
#else

    void installISR(INTERRUPT_PINS_T intr, int gpio, mraa::Edge level,
                    void (*isr)(void *), void *arg);
#endif

    void uninstallISR(INTERRUPT_PINS_T intr);

    uint8_t readReg(uint8_t reg);

    int readRegs(uint8_t reg, uint8_t *buffer, int len);

    void writeReg(uint8_t reg, uint8_t val);

  protected:
    mraa::I2c *m_i2c;
    mraa::Spi *m_spi;

    mraa::Gpio *m_gpioIntr;
    mraa::Gpio *m_gpioDR;

    // spi chip select
    mraa::Gpio *m_gpioCS;

    uint8_t m_addr;

    OPERATION_MODE_T m_opmode;

    // SPI chip select
    void csOn();
    void csOff();

    // acc data
    float m_magX;
    float m_magY;
    float m_magZ;

    // hall resistance
    uint16_t m_hall;

    // trimming data
    int8_t m_dig_x1;
    int8_t m_dig_y1;

    int16_t m_dig_z4;
    int8_t m_dig_x2;
    int8_t m_dig_y2;

    int16_t m_dig_z2;
    uint16_t m_dig_z1;
    uint16_t m_dig_xyz1;
    int16_t m_dig_z3;
    int8_t m_dig_xy2;
    uint8_t m_dig_xy1;

    // read trim data for compensation
    void readTrimData();

  private:
    bool m_isSPI;

    // return a reference to a gpio pin pointer depending on intr
    mraa::Gpio*& getPin(INTERRUPT_PINS_T intr);

    // Adding a private function definition for java bindings
#if defined(SWIGJAVA) || defined(JAVACALLBACK)
    void installISR(INTERRUPT_PINS_T intr, int gpio, mraa::Edge level,
                    void (*isr)(void *), void *arg);
#endif

    // bosch compensation algorithms
    float bmm050_compensate_X_float(int16_t mag_data_x, uint16_t data_r);
    float bmm050_compensate_Y_float(int16_t mag_data_y, uint16_t data_r);
    float bmm050_compensate_Z_float(int16_t mag_data_z, uint16_t data_r);
  };
}