AMiRo-OS

/*

 * INA219 - Power Monitor

 */

#ifndef AMIRO_INA219_H_

#define AMIRO_INA219_H_

#include <ch.hpp>

#include <amiro/bus/i2c/I2CParams.hpp>

#include <amiro/bus/i2c/I2CDriver.hpp>

#include <amiro/BaseSensor.hpp>

namespace amiro {

  namespace INA219 {

    namespace Configuration

    {

      union Register {

        uint16_t value = 0;

        struct {

          uint16_t mode : 3;

          uint16_t sadc : 4;

          uint16_t badc : 4;

          uint16_t pg : 2;

          uint16_t brng : 1;

          uint16_t rsvd : 1;

          uint16_t rst : 1;

        } content;

      };

      enum BusRange {

        BRNG_16V = 0,

        BRNG_32V = 1, BRNG_DEFAULT = 1

      };

      enum Pga {

        PGA_40mV = 0,

        PGA_80mV = 1,

        PGA_160mV = 2,

        PGA_320mV = 3, PGA_DEFAULT = 3

      };

      enum Adc {

        ADC_84us = 0x0u,

        ADC_148us = 0x1u,

        ADC_276us = 0x2u,

        ADC_532us = 0x3u, ADC_632us_alt = 0x8u, ADC_DEFAULT = 0x3u,

        ADC_1060us = 0x9u,

        ADC_2130us = 0xAu,

        ADC_4260us = 0xBu,

        ADC_8510us = 0xCu,

        ADC_17020us = 0xDu,

        ADC_34050us = 0xEu,

        ADC_68100us = 0xFu

      };

      enum Mode {

        MODE_PowerDown = 0x0u,

        MODE_ShuntV_Triggered = 0x1u,

        MODE_BusV_Triggered = 0x2u,

        MODE_ShuntBus_Triggered = 0x3u,

        MODE_AdcOff = 0x4u,

        MODE_ShuntV_Continuous = 0x5u,

        MODE_BusV_Continuous = 0x6u,

        MODE_ShuntBus_Continuous = 0x7u, MODE_DEFAULT = 0x7u

      };

    } // end of namespace Configuration

    struct InitData {

      Configuration::Register configuration;

      uint16_t calibration;

      uint16_t current_lsb_uA;

    };

    struct CalibData {

      struct CalibInput {

        float shunt_resistance_O;

        float max_expected_current_A;

        uint16_t current_lsb_uA;

        Configuration::Register configuration;

      } input;

      struct CalibOutput {

        float max_current_before_overflow_A;

        float max_shuntvoltage_before_overflow_V;

        uint16_t current_lsb_uA;

        uint16_t calibration_value;

      } output;

      uint16_t power_lsb_uW() const

      {

        return 20 * output.current_lsb_uA;

      }

      float maximum_power_W() const

      {

        return output.max_current_before_overflow_A * ((input.configuration.content.brng == Configuration::BusRange::BRNG_32V)? 32 : 16);}

    };

    struct BusVoltage {

      uint32_t voltage_uV : 25;

      uint32_t rsvd : 5;

      uint32_t conversion_ready : 1;

      uint32_t overflow : 1;

    };

    class Driver : public BaseSensor<InitData,CalibData>, public chibios_rt::BaseStaticThread<256>

    {

    public:

      enum SelftestResult {

        ST_OK = BaseSensor<>::OK,

        ST_FAIL_ANY = BaseSensor<>::FAIL,

        ST_FAIL_BACKUP = BaseSensor<>::FAIL + 1,

        ST_FAIL_RESET = BaseSensor<>::FAIL + 2,

        ST_FAIL_IS_DEFAULT = BaseSensor<>::FAIL + 3,

        ST_FAIL_WRITE_CONFIG = BaseSensor<>::FAIL + 4,

        ST_FAIL_WRITE_CALIB = BaseSensor<>::FAIL + 5,

        ST_FAIL_CHECK_CONFIG = BaseSensor<>::FAIL + 6,

        ST_FAIL_CHECK_CALIB = BaseSensor<>::FAIL + 7

      };

    private:

      union BusVoltage {

        uint16_t value = 0;

        struct {

          uint16_t overflow : 1;

          uint16_t conversion_ready : 1;

          uint16_t rsvd : 1;

          uint16_t voltage : 13;

        } content;

      };

      struct Status {

        Driver::BusVoltage bus_voltage;

        uint16_t power;

        Status() {bus_voltage.value = 0; power = 0;}

      };

      enum RegisterAddress {

        REG_CONFIGURATION = 0x00u,

        REG_SHUNT_VOLTAGE = 0x01u,

        REG_BUS_VOLTAGE = 0x02u,

        REG_POWER = 0x03u,

        REG_CURRENT = 0x04u,

        REG_CALIBRATION = 0x05u

      };

      enum RegisterMask {

        MASK_CONFIGURATION = 0x3FFFu,

        MASK_CALIBRATION = 0xFFFEu,

        MASK_RESET = 0x8000u

      };

      I2CDriver *const i2c_driver;

      I2CTxParams tx_params;

      Configuration::Register config;

      uint16_t current_lsb_uA;

      Status status;

    public:

      /* constructor & destructor */

      explicit Driver(I2CDriver &i2c_driver, const uint8_t i2c_address);

      virtual ~Driver();

      /* inherited functions from BaseSensor */

      msg_t init(InitData* initialization_data = NULL);

      msg_t update();

      msg_t wakeup();

      msg_t hibernate();

#ifndef AMIRO_NCALIBRATION

      msg_t calibration(CalibData* calibration_data = NULL);

#endif

#ifndef AMIRO_NSELFTEST

      msg_t selftest();

#endif

      INA219::BusVoltage getVoltage() const

      {

        return this->busVoltageReg2uV(this->status.bus_voltage);

      }

      uint32_t getPower_uW() const

      {

        return this->powerReg2uW(this->status.power);

      }

      uint32_t getCurrent_uA() const

      {

        return this->powerReg2uW(this->status.power) / this->busVoltageReg2uV(this->status.bus_voltage).voltage_uV;

      }

      inline Configuration::Register readConfiguration();

      inline int32_t readShuntVoltage_uV();

      inline INA219::BusVoltage readBusVoltage();

      inline uint32_t readPower_uW();

      inline int32_t readCurrent_uA();

      inline uint16_t readCalibration();

      uint8_t reset();

  protected:

      virtual msg_t main(void);

    private:

      msg_t readRegister(const RegisterAddress reg, uint16_t& dst);

      msg_t writeRegister(const RegisterAddress reg, const uint16_t& val);

      static inline INA219::BusVoltage busVoltageReg2uV(const INA219::Driver::BusVoltage reg_val)

      {

        INA219::BusVoltage bus_voltage;

        bus_voltage.conversion_ready = reg_val.content.conversion_ready;

        bus_voltage.overflow = reg_val.content.conversion_ready;

        /*

         * The least significant bit represents 4mV.

         * -> Multiply with 4000 in order to convert to uV.

         */

        bus_voltage.voltage_uV = reg_val.content.voltage * 4000;

        return bus_voltage;

      }

      inline uint32_t powerReg2uW(const uint16_t reg_val) const

      {

        /*

         * Multiply with the value of the least significant bit for the current and the constant 20.

         * -> see data sheet, chapter 'Programming the INA219 power measurement engine' for details

         */

        return reg_val * 20 * this->current_lsb_uA;

      }

    };

  } // end of namespace INA219

}

#endif /* AMIRO_INA219_H_ */