ACS37800.h

Go to the documentation of this file.

// Copyright (C) Pololu Corporation.  See LICENSE.txt for details.
 
 
#pragma once
 
#include <Arduino.h>
#include <Wire.h>
 
class ACS37800
{
public:
  ACS37800(uint8_t address = 0x60, TwoWire * bus = &Wire)
    : bus(bus), address(address) {}
 
  void setBus(TwoWire * bus)
  {
    this->bus = bus;
  }
 
  TwoWire * getBus()
  {
    return this->bus;
  }
 
  void setAddress(uint8_t address)
  {
    this->address = address;
  }
 
  uint8_t getAddress()
  {
    return address;
  }
 
  uint8_t getLastError()
  {
    return lastError;
  }
 
  void setBoardPololu(uint8_t rsense_kohm)
  {
    icodesMult = 17873;
    icodesShift = 14;
    switch (rsense_kohm)
    {
    case 1:
      vcodesMult = 18623;
      vcodesShift = 9;
      pinstantMult = 1299;
      pinstantShift = 0;
      break;
    case 2:
      vcodesMult = 18627;
      vcodesShift = 10;
      pinstantMult = 10395;
      pinstantShift = 4;
      break;
    default:
    case 4:
      vcodesMult = 18637;
      vcodesShift = 11;
      pinstantMult = 325;
      pinstantShift = 0;
      break;
    }
  }
 
  void setBoardParameters(uint8_t isense_range, uint32_t riso, uint32_t rsense)
  {
    calculateApproximation(riso + rsense, 110 * rsense,
      vcodesMult, vcodesShift);
    calculateApproximation(2 * isense_range, 55,
      icodesMult, icodesShift);
    calculateApproximation(
      (uint64_t)isense_range * (riso + rsense) * 5, rsense * 462,
      pinstantMult, pinstantShift);
  }
 
  void enableWriteAccess()
  {
    writeReg(0x2F, 0x4F70656E);  // write ACCESS_CODE
  }
 
  void setSampleCount(uint16_t count)
  {
    enableWriteAccess();
    if (getLastError()) { return; }
 
    uint32_t reg = readReg(0x1F);
    if (getLastError()) { return; }
 
    if (count > 1023) { count = 1023; }
 
    // Clear N and BYPASS_N_EN, then set them if necessary.
    reg &= 0xFE003FFF;
    if (count) { reg |= ((uint32_t)1 << 24) | ((uint32_t)count << 14); }
 
    writeReg(0x1F, reg);
  }
 
  void readRMSVoltageAndCurrent()
  {
    uint32_t reg = readReg(0x20);
    uint16_t vrms = (uint16_t)reg;
    uint16_t irms = (uint16_t)(reg >> 16);
    rmsVoltageMillivolts = (int32_t)vrms * vcodesMult >> vcodesShift >> 1;
    rmsCurrentMilliamps = (int32_t)irms * icodesMult >> icodesShift >> 1;
  }
 
  void readActiveAndReactivePower()
  {
    uint32_t reg = readReg(0x21);
    int16_t pactive = (int16_t)reg;
    uint16_t pimag = (uint16_t)(reg >> 16);
    activePowerMilliwatts = (int32_t)pactive * pinstantMult >> pinstantShift;
    reactivePowerMilliwatts = (int32_t)pimag * pinstantMult >> pinstantShift >> 1;
  }
 
  int32_t readApparentPowerMilliwatts()
  {
    // Note: maybe this function should also store the power factor and
    // other things in register 0x22.
    uint32_t reg = readReg(0x22);
    uint16_t papparent = (uint16_t)reg;
    apparentPowerMilliwatts = (int32_t)papparent * pinstantMult >> pinstantShift >> 1;
    return apparentPowerMilliwatts;
  }
 
  void readInstVoltageAndCurrent()
  {
    uint32_t reg = readReg(0x2A);
    int16_t vcodes = (int16_t)reg;
    int16_t icodes = (int16_t)(reg >> 16);
    instVoltageMillivolts = (int32_t)vcodes * vcodesMult >> vcodesShift;
    instCurrentMilliamps = (int32_t)icodes * icodesMult >> icodesShift;
  }
 
  int32_t readInstPowerMilliwatts()
  {
    int16_t pinstant = (int16_t)readReg(0x2C);
    instPowerMilliwatts = (int32_t)pinstant * pinstantMult >> pinstantShift;
    return instPowerMilliwatts;
  }
 
  int32_t readRMSVoltageMillivolts()
  {
    readRMSVoltageAndCurrent();
    return rmsVoltageMillivolts;
  }
 
  int32_t readRMSCurrentMilliamps()
  {
    readRMSVoltageAndCurrent();
    return rmsCurrentMilliamps;
  }
 
  int32_t readActivePowerMilliwatts()
  {
    readActiveAndReactivePower();
    return activePowerMilliwatts;
  }
 
  int32_t readReactivePowerMilliwatts()
  {
    readActiveAndReactivePower();
    return reactivePowerMilliwatts;
  }
 
  int32_t readInstVoltageMillivolts()
  {
    readInstVoltageAndCurrent();
    return instVoltageMillivolts;
  }
 
  int32_t readInstCurrentMilliamps()
  {
    readInstVoltageAndCurrent();
    return instCurrentMilliamps;
  }
 
  void writeEepromI2CAddress(uint8_t address)
  {
    enableWriteAccess();
    if (getLastError()) { return; }
    uint32_t reg = readReg(0x0F);
    if (getLastError()) { return; }
    reg = (reg & ~(uint32_t)0x3FC) | (1 << 9) | ((address & 0x7F) << 2);
    writeReg(0x0F, reg);
  }
 
  uint32_t readReg(uint8_t reg)
  {
    bus->beginTransmission(address);
    bus->write(reg);
    lastError = bus->endTransmission();
    if (getLastError()) { return 0; }
 
    uint8_t byteCount = bus->requestFrom(address, (uint8_t)4);
    if (byteCount != 4)
    {
      lastError = 50;
      return 0;
    }
 
    uint32_t value = bus->read();
    value |= (uint32_t)bus->read() << 8;
    value |= (uint32_t)bus->read() << 16;
    value |= (uint32_t)bus->read() << 24;
    return value;
  }
 
  void writeReg(uint8_t reg, uint32_t value)
  {
    bus->beginTransmission(address);
    bus->write(reg);
    bus->write(value & 0xFF);
    bus->write(value >> 8 & 0xFF);
    bus->write(value >> 16 & 0xFF);
    bus->write(value >> 24 & 0xFF);
    lastError = bus->endTransmission();
  }
 
  uint16_t vcodesMult = 1, icodesMult = 1, pinstantMult = 1;
  uint8_t vcodesShift = 0, icodesShift = 0, pinstantShift = 0;
 
  int32_t instVoltageMillivolts;
  int32_t instCurrentMilliamps;
  int32_t instPowerMilliwatts;
 
  int32_t rmsVoltageMillivolts;
  int32_t rmsCurrentMilliamps;
  int32_t activePowerMilliwatts;
  int32_t reactivePowerMilliwatts;
  int32_t apparentPowerMilliwatts;
 
private:
 
  // Calculates an approximation for (x * numerator / denominator), where
  // x is an int16_t or uint16_t, of the form ((int32_t)x * mult >> shift).
  static void calculateApproximation(
    uint64_t numerator, uint64_t denominator,
    uint16_t & outputMult, uint8_t & outputShift)
  {
    float k = (float)numerator / denominator;
    uint16_t mult = 0;
    uint8_t shift = 0;
    for (uint8_t shift_candidate = 0; shift_candidate < 32; shift_candidate++)
    {
      uint32_t mult_candidate = round(k * ((uint32_t)1 << shift_candidate));
      if (mult_candidate > 0x7FFF) { break; }
      mult = mult_candidate;
      shift = shift_candidate;
    }
    while ((mult & 1) == 0)
    {
      mult >>= 1;
      shift--;
    }
    outputMult = mult;
    outputShift = shift;
  }
 
  TwoWire * bus;
  uint8_t address;
 
  uint8_t lastError = 0;
};