| /* |
| * 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. |
| */ |
| |
| #include <unistd.h> |
| #include <assert.h> |
| #include <errno.h> |
| #include <iostream> |
| #include <stdexcept> |
| #include <string> |
| |
| #include "h803x.hpp" |
| |
| using namespace upm; |
| using namespace std; |
| |
| // We can't use the modbus float conversion functions since they |
| // assume the first word is the LSW. On this device, the first word |
| // is MSW. In addition, the data is already IEEE 754 formatted, which |
| // won't work with just the bit shuffling modbus_get_float*() does. |
| static float regs2float(uint16_t h, uint16_t l) |
| { |
| // this function will fail horribly if the following isn't true |
| assert(sizeof(float) == sizeof(uint32_t)); |
| |
| // we can't use a cast here, since the data is already IEEE 754 |
| // formatted, so use a union instead. |
| union { |
| uint32_t i; |
| float f; |
| } converter; |
| |
| converter.i = ((uint32_t)h << 16) | l; |
| return converter.f; |
| } |
| |
| |
| H803X::H803X(std::string device, int address, int baud, int bits, char parity, |
| int stopBits) : |
| m_mbContext(0) |
| { |
| // check some of the parameters |
| if (!(bits == 7 || bits == 8)) |
| { |
| throw std::out_of_range(std::string(__FUNCTION__) |
| + ": bits must be 7 or 8"); |
| } |
| |
| if (!(parity == 'N' || parity == 'E' || parity == 'O')) |
| { |
| throw std::out_of_range(std::string(__FUNCTION__) |
| + ": parity must be 'N', 'O', or 'E'"); |
| } |
| |
| if (!(stopBits == 1 || stopBits == 2)) |
| { |
| throw std::out_of_range(std::string(__FUNCTION__) |
| + ": stopBits must be 1 or 2"); |
| } |
| |
| // now, open/init the device and modbus context |
| |
| if (!(m_mbContext = modbus_new_rtu(device.c_str(), baud, parity, bits, |
| stopBits))) |
| { |
| throw std::runtime_error(std::string(__FUNCTION__) |
| + ": modbus_new_rtu() failed"); |
| } |
| |
| // set the slave address of the device we want to talk to |
| |
| // addresses are only 8bits wide |
| address &= 0xff; |
| if (modbus_set_slave(m_mbContext, address)) |
| { |
| throw std::runtime_error(std::string(__FUNCTION__) |
| + ": modbus_set_slave() failed"); |
| } |
| |
| // set the serial mode |
| modbus_rtu_set_serial_mode(m_mbContext, MODBUS_RTU_RS232); |
| |
| // now connect.. |
| if (modbus_connect(m_mbContext)) |
| { |
| throw std::runtime_error(std::string(__FUNCTION__) |
| + ": modbus_connect() failed"); |
| } |
| |
| // will set m_isH8036 appropriately |
| testH8036(); |
| |
| clearData(); |
| |
| // turn off debugging |
| setDebug(false); |
| } |
| |
| H803X::~H803X() |
| { |
| if (m_mbContext) |
| { |
| modbus_close(m_mbContext); |
| modbus_free(m_mbContext); |
| } |
| } |
| |
| int H803X::readHoldingRegs(HOLDING_REGS_T reg, int len, uint16_t *buf) |
| { |
| int rv; |
| int retries = 5; |
| |
| // Sometimes it seems the device goes to sleep, and therefore a read |
| // will timeout, so we will retry up to 5 times. |
| |
| while (retries >= 0) |
| { |
| if ((rv = modbus_read_registers(m_mbContext, reg, len, buf)) < 0) |
| { |
| if (errno == ETIMEDOUT) |
| { |
| // timeout |
| retries--; |
| sleep(1); |
| } |
| else if (errno == EMBXILADD) |
| { |
| // invalid registers will return a EMBXILADD (modbus) |
| // error. We want to detect these as a way to determine |
| // whether we are dealing with an H8035 or H8036. |
| return -1; |
| } |
| else |
| { |
| // anything else is a failure. |
| throw std::runtime_error(std::string(__FUNCTION__) |
| + ": modbus_read_registers() failed: " |
| + modbus_strerror(errno)); |
| } |
| } |
| else |
| return rv; // success |
| } |
| |
| // if we're here, then all the retries were exhausted |
| throw std::runtime_error(std::string(__FUNCTION__) |
| + ": modbus_read_registers() timed out after " |
| + "5 retries"); |
| } |
| |
| void H803X::writeHoldingReg(HOLDING_REGS_T reg, int value) |
| { |
| if (modbus_write_register(m_mbContext, reg, value) != 1) |
| { |
| throw std::runtime_error(std::string(__FUNCTION__) |
| + ": modbus_write_register() failed: " |
| + modbus_strerror(errno)); |
| } |
| } |
| |
| void H803X::update() |
| { |
| static const int h8035NumRegs = 4; // 2 regs * 2 |
| static const int h8036NumRegs = 52; // 26 regs * 2 |
| |
| int numRegs = (isH8036() ? h8036NumRegs : h8035NumRegs); |
| |
| uint16_t buf[numRegs]; |
| |
| // This should only fail (return -1) if we got isH8036() wrong |
| if (readHoldingRegs(HOLDING_CONSUMPTION_KWH, numRegs, buf) < 0) |
| { |
| throw std::out_of_range(std::string(__FUNCTION__) + |
| ": readHoldingRegs() failed: " |
| + modbus_strerror(errno)); |
| } |
| |
| // And so it begins... |
| |
| // H8035 / H8036 |
| m_consumptionkWh = regs2float(buf[0], buf[1]); |
| m_realPowerkW = regs2float(buf[2], buf[3]); |
| |
| // H8036 only |
| if (isH8036()) |
| { |
| m_reactivePowerkVAR = regs2float(buf[4], buf[5]); |
| m_apparentPowerkVA = regs2float(buf[6], buf[7]); |
| m_powerFactor = regs2float(buf[8], buf[9]); |
| |
| m_voltsLineToLine = regs2float(buf[10], buf[11]); |
| m_voltsLineToNeutral = regs2float(buf[12], buf[13]); |
| |
| m_current = regs2float(buf[14], buf[15]); |
| |
| m_realPowerPhaseAkW = regs2float(buf[16], buf[17]); |
| m_realPowerPhaseBkW = regs2float(buf[18], buf[19]); |
| m_realPowerPhaseCkW = regs2float(buf[20], buf[21]); |
| |
| m_powerFactorPhaseA = regs2float(buf[22], buf[23]); |
| m_powerFactorPhaseB = regs2float(buf[24], buf[25]); |
| m_powerFactorPhaseC = regs2float(buf[26], buf[27]); |
| |
| m_voltsPhaseAB = regs2float(buf[28], buf[29]); |
| m_voltsPhaseBC = regs2float(buf[30], buf[31]); |
| m_voltsPhaseAC = regs2float(buf[32], buf[33]); |
| m_voltsPhaseAN = regs2float(buf[34], buf[35]); |
| m_voltsPhaseBN = regs2float(buf[36], buf[37]); |
| m_voltsPhaseCN = regs2float(buf[38], buf[39]); |
| |
| m_currentPhaseA = regs2float(buf[40], buf[41]); |
| m_currentPhaseB = regs2float(buf[42], buf[43]); |
| m_currentPhaseC = regs2float(buf[44], buf[45]); |
| |
| m_avgRealPowerkW = regs2float(buf[46], buf[47]); |
| m_minRealPowerkW = regs2float(buf[48], buf[49]); |
| m_maxRealPowerkW = regs2float(buf[50], buf[51]); |
| } |
| } |
| |
| string H803X::getSlaveID() |
| { |
| uint8_t id[MODBUS_MAX_PDU_LENGTH]; |
| int rv; |
| |
| if ((rv = modbus_report_slave_id(m_mbContext, MODBUS_MAX_PDU_LENGTH, id)) < 0) |
| { |
| throw std::runtime_error(std::string(__FUNCTION__) |
| + ": modbus_report_slave_id() failed: " |
| + modbus_strerror(errno)); |
| |
| } |
| |
| // the first byte is the number of bytes in the response, the second |
| // byte is the active indicator (00 = off, ff = on), and the rest |
| // are ascii identification (company, model, and serial number) data. |
| |
| if (rv > 2) |
| { |
| string retID((char *)&id[2], rv - 2); |
| return retID; |
| } |
| else |
| return ""; |
| } |
| |
| void H803X::setSlaveAddress(int addr) |
| { |
| // addresses are only 8bits wide |
| addr &= 0xff; |
| |
| if (modbus_set_slave(m_mbContext, addr)) |
| { |
| throw std::runtime_error(std::string(__FUNCTION__) |
| + ": modbus_set_slave() failed: " |
| + modbus_strerror(errno)); |
| } |
| |
| // retest H8036 |
| testH8036(); |
| |
| // clear out any previously stored data |
| clearData(); |
| } |
| |
| void H803X::setDebug(bool enable) |
| { |
| m_debugging = enable; |
| |
| if (enable) |
| modbus_set_debug(m_mbContext, 1); |
| else |
| modbus_set_debug(m_mbContext, 0); |
| } |
| |
| void H803X::clearData() |
| { |
| // H8035 |
| m_consumptionkWh = 0.0; |
| m_realPowerkW = 0.0; |
| |
| // H8036 |
| m_reactivePowerkVAR = 0.0; |
| m_apparentPowerkVA = 0.0; |
| m_powerFactor = 0.0; |
| m_voltsLineToLine = 0.0; |
| m_voltsLineToNeutral = 0.0; |
| m_current = 0.0; |
| m_realPowerPhaseAkW = 0.0; |
| m_realPowerPhaseBkW = 0.0; |
| m_realPowerPhaseCkW = 0.0; |
| m_powerFactorPhaseA = 0.0; |
| m_powerFactorPhaseB = 0.0; |
| m_powerFactorPhaseC = 0.0; |
| m_voltsPhaseAB = 0.0; |
| m_voltsPhaseBC = 0.0; |
| m_voltsPhaseAC = 0.0; |
| m_voltsPhaseAN = 0.0; |
| m_voltsPhaseBN = 0.0; |
| m_voltsPhaseCN = 0.0; |
| m_currentPhaseA = 0.0; |
| m_currentPhaseB = 0.0; |
| m_currentPhaseC = 0.0; |
| m_avgRealPowerkW = 0.0; |
| m_minRealPowerkW = 0.0; |
| m_maxRealPowerkW = 0.0; |
| } |
| |
| void H803X::testH8036() |
| { |
| // here we test a register read to see if we are on an H8036 device, |
| // which can provide much more information. |
| |
| uint16_t regs[2]; |
| |
| // here, we'll read 2 registers that only exist on the H8036. Any |
| // failure other than a illegal data access will generate an |
| // exception. A valid request will return >0, and an illegal |
| // register read will return -1. |
| if (readHoldingRegs(HOLDING_REACTIVE_POWER_KVAR, 2, regs) == -1) |
| m_isH8036 = false; |
| else |
| m_isH8036 = true; |
| } |
| |
| void H803X::presetConsumption(float value, MULTIPLIERS_T multiplier) |
| { |
| uint32_t i = uint32_t(value * float(multiplier)); |
| |
| uint16_t h = uint16_t(i >> 16); |
| uint16_t l = uint16_t(i & 0xffff); |
| |
| // always write the LSW first |
| writeHoldingReg(HOLDING_CONSUMPTION_KWH_INT_L, l); |
| writeHoldingReg(HOLDING_CONSUMPTION_KWH_INT_H, h); |
| } |
