h803x.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 <modbus/modbus.h>

namespace upm {

  class H803X {
  public:

    // MODBUS holding registers.  These offsets are for the MSW only.
    // The LSW always follows, though they are not enumerated here.
    // These are all 2 register (32-bit total (16b HSW + 16b LSW))
    // quantities, in IEEE 754 floating point format.
    typedef enum {
      // these two registers are used only for presetConsumption()
      HOLDING_CONSUMPTION_KWH_INT_L             = 0, // preset use only
      HOLDING_CONSUMPTION_KWH_INT_H             = 1, // preset use only

      // H8035/H8036
      HOLDING_CONSUMPTION_KWH                   = 258, // floating point data

      HOLDING_REAL_POWER_KW                     = 260,

      // H8036 only
      HOLDING_REACTIVE_POWER_KVAR               = 262,
      HOLDING_APPARENT_POWER_KVA                = 264,
      HOLDING_POWER_FACTOR                      = 266,
      HOLDING_VOLTS_LINE_TO_LINE                = 268,
      HOLDING_VOLTS_LINE_TO_NEUTRAL             = 270,
      HOLDING_CURRENT                           = 272,
      HOLDING_REAL_POWER_PHASE_A_KWH            = 274,
      HOLDING_REAL_POWER_PHASE_B_KWH            = 276,
      HOLDING_REAL_POWER_PHASE_C_KWH            = 278,
      HOLDING_POWER_FACTOR_PHASE_A              = 280,
      HOLDING_POWER_FACTOR_PHASE_B              = 282,
      HOLDING_POWER_FACTOR_PHASE_C              = 284,
      HOLDING_VOLTS_PHASE_AB                    = 286,
      HOLDING_VOLTS_PHASE_BC                    = 288,
      HOLDING_VOLTS_PHASE_AC                    = 290,
      HOLDING_VOLTS_PHASE_AN                    = 292,
      HOLDING_VOLTS_PHASE_BN                    = 294,
      HOLDING_VOLTS_PHASE_CN                    = 296,
      HOLDING_CURRENT_PHASE_A                   = 298,
      HOLDING_CURRENT_PHASE_B                   = 300,
      HOLDING_CURRENT_PHASE_C                   = 302,
      HOLDING_AVG_REAL_POWER_KW                 = 304,
      HOLDING_MIN_REAL_POWER_KW                 = 306,
      HOLDING_MAX_REAL_POWER_KW                 = 308
    } HOLDING_REGS_T;

    // these enums are used by presetConsumption() to scale the value
    // properly depending on the devices' current capacity.
    typedef enum {
      MULT_100A                                 = 128, // 100A devices
      MULT_300A_400A                            = 32,
      MULT_800A                                 = 16,
      MULT_1600A                                = 8,
      MULT_2400A                                = 4
    } MULTIPLIERS_T;

    H803X(std::string device, int address, int baud=9600, int bits=8,
          char parity='N', int stopBits=2);

    ~H803X();

    void update();

    std::string getSlaveID();

    void setSlaveAddress(int addr);

    void presetConsumption(float value, MULTIPLIERS_T multiplier);

    float getConsumption()
    {
      return m_consumptionkWh;
    };

    float getRealPower()
    {
      return m_realPowerkW;
    };

    float getReactivePower()
    {
      return m_reactivePowerkVAR;
    };

    float getApparentPower()
    {
      return m_apparentPowerkVA;
    };

    float getPowerFactor()
    {
      return m_powerFactor;
    };

    float getVoltsLineToLine()
    {
      return m_voltsLineToLine;
    };

    float getVoltsLineToNeutral()
    {
      return m_voltsLineToNeutral;
    };

    float getCurrent()
    {
      return m_current;
    };

    float getRealPowerPhaseA()
    {
      return m_realPowerPhaseAkW;
    };

    float getRealPowerPhaseB()
    {
      return m_realPowerPhaseBkW;
    };

    float getRealPowerPhaseC()
    {
      return m_realPowerPhaseCkW;
    };

    float getPowerFactorPhaseA()
    {
      return m_powerFactorPhaseA;
    };

    float getPowerFactorPhaseB()
    {
      return m_powerFactorPhaseB;
    };

    float getPowerFactorPhaseC()
    {
      return m_powerFactorPhaseC;
    };

    float getVoltsPhaseAToB()
    {
      return m_voltsPhaseAB;
    };

    float getVoltsPhaseBToC()
    {
      return m_voltsPhaseBC;
    };

    float getVoltsPhaseAToC()
    {
      return m_voltsPhaseAC;
    };

    float getVoltsPhaseAToNeutral()
    {
      return m_voltsPhaseAN;
    };

    float getVoltsPhaseBToNeutral()
    {
      return m_voltsPhaseBN;
    };

    float getVoltsPhaseCToNeutral()
    {
      return m_voltsPhaseCN;
    };

    float getCurrentPhaseA()
    {
      return m_currentPhaseA;
    };

    float getCurrentPhaseB()
    {
      return m_currentPhaseB;
    };

    float getCurrentPhaseC()
    {
      return m_currentPhaseC;
    };

    float getAvgRealPower()
    {
      return m_avgRealPowerkW;
    };

    float getMinRealPower()
    {
      return m_minRealPowerkW;
    };

    float getMaxRealPower()
    {
      return m_maxRealPowerkW;
    };

    void setDebug(bool enable);

    bool isH8036()
    {
      return m_isH8036;
    };

  protected:
    // holding registers
    int readHoldingRegs(HOLDING_REGS_T reg, int len, uint16_t *buf);
    void writeHoldingReg(HOLDING_REGS_T reg, int value);

    // clear out all stored data
    void clearData();
    
    // MODBUS context
    modbus_t *m_mbContext;

    // test to see if the connected device is an H8036, and set
    // m_isH8036 appropriately
    void testH8036();

    // Is this an H8036 (has extended registers)
    bool m_isH8036;

  private:
    bool m_debugging;

    // data

    // H8035 / H8036
    float m_consumptionkWh;
    float m_realPowerkW;

    // H8036 only
    float m_reactivePowerkVAR;
    float m_apparentPowerkVA;
    float m_powerFactor;
    float m_voltsLineToLine;
    float m_voltsLineToNeutral;
    float m_current; // in amps
    float m_realPowerPhaseAkW;
    float m_realPowerPhaseBkW;
    float m_realPowerPhaseCkW;
    float m_powerFactorPhaseA;
    float m_powerFactorPhaseB;
    float m_powerFactorPhaseC;
    float m_voltsPhaseAB;
    float m_voltsPhaseBC;
    float m_voltsPhaseAC;
    float m_voltsPhaseAN;
    float m_voltsPhaseBN;
    float m_voltsPhaseCN;
    float m_currentPhaseA;
    float m_currentPhaseB;
    float m_currentPhaseC;
    float m_avgRealPowerkW;
    float m_minRealPowerkW;
    float m_maxRealPowerkW;
  };
}