Created
April 20, 2014 10:38
-
-
Save subinabr/11110876 to your computer and use it in GitHub Desktop.
sMAP driver for PMAC
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| """ | |
| Copyright (c) 2011, 2012, Regents of the University of California | |
| All rights reserved. | |
| Redistribution and use in source and binary forms, with or without | |
| modification, are permitted provided that the following conditions | |
| are met: | |
| - Redistributions of source code must retain the above copyright | |
| notice, this list of conditions and the following disclaimer. | |
| - Redistributions in binary form must reproduce the above copyright | |
| notice, this list of conditions and the following disclaimer in the | |
| documentation and/or other materials provided with the | |
| distribution. | |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS | |
| FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL | |
| THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, | |
| INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
| SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
| HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
| STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | |
| OF THE POSSIBILITY OF SUCH DAMAGE. | |
| """ | |
| """ | |
| @author Stephen Dawson-Haggerty <stevedh@eecs.berkeley.edu> | |
| """ | |
| """Driver for HeatX Steam Meter | |
| """ | |
| import time | |
| import struct | |
| from twisted.python import log | |
| import smap.driver as driver | |
| import smap.util as util | |
| #from smap.iface.modbustcp.ModbusTCP import ModbusTCP | |
| #From currentvoltorig: | |
| from pymodbus.constants import Endian | |
| from struct import pack, unpack | |
| from pymodbus.utilities import pack_bitstring | |
| from pymodbus.utilities import unpack_bitstring | |
| from pymodbus.exceptions import ParameterException | |
| from pymodbus.client.sync import ModbusSerialClient as ModbusClient | |
| from pymodbus.transaction import ModbusSocketFramer as ModbusFramer | |
| import csv | |
| import datetime | |
| import subprocess | |
| import sys | |
| import os | |
| import logging | |
| import logging.handlers | |
| import gc | |
| from os.path import join | |
| ID_VENDOR='0403' | |
| ID_PRODUCT='6001' | |
| class BinaryPayloadDecoder(object): | |
| ''' A utility that helps decode payload messages from a modbus | |
| reponse message. It really is just a simple wrapper around | |
| the struct module, however it saves time looking up the format | |
| strings. What follows is a simple example:: | |
| decoder = BinaryPayloadDecoder(payload) | |
| first = decoder.decode_8bit_uint() | |
| second = decoder.decode_16bit_uint() | |
| ''' | |
| def __init__(self, payload, endian=Endian.Little): | |
| ''' Initialize a new payload decoder | |
| :param payload: The payload to decode with | |
| :param endian: The endianess of the payload | |
| ''' | |
| self._payload = payload | |
| self._pointer = 0x00 | |
| self._endian = endian | |
| @classmethod | |
| def fromRegisters(klass, registers, endian=Endian.Little): | |
| ''' Initialize a payload decoder with the result of | |
| reading a collection of registers from a modbus device. | |
| The registers are treated as a list of 2 byte values. | |
| We have to do this because of how the data has already | |
| been decoded by the rest of the library. | |
| :param registers: The register results to initialize with | |
| :param endian: The endianess of the payload | |
| :returns: An initialized PayloadDecoder | |
| ''' | |
| if isinstance(registers, list): # repack into flat binary | |
| payload = ' '.join(pack('>H', x) for x in registers) | |
| return klass(payload, endian) | |
| raise ParameterException('Invalid collection of registers supplied') | |
| @classmethod | |
| def fromCoils(klass, coils, endian=Endian.Little): | |
| ''' Initialize a payload decoder with the result of | |
| reading a collection of coils from a modbus device. | |
| The coils are treated as a list of bit(boolean) values. | |
| :param coils: The coil results to initialize with | |
| :param endian: The endianess of the payload | |
| :returns: An initialized PayloadDecoder | |
| ''' | |
| if isinstance(coils, list): | |
| payload = pack_bitstring(coils) | |
| return klass(payload, endian) | |
| raise ParameterException('Invalid collection of coils supplied') | |
| def reset(self): | |
| ''' Reset the decoder pointer back to the start | |
| ''' | |
| self._pointer = 0x00 | |
| def decode_8bit_uint(self): | |
| ''' Decodes a 8 bit unsigned int from the buffer | |
| ''' | |
| self._pointer += 1 | |
| fstring = self._endian + 'B' | |
| handle = self._payload[self._pointer - 1:self._pointer] | |
| return unpack(fstring, handle)[0] | |
| def decode_bits(self): | |
| ''' Decodes a byte worth of bits from the buffer | |
| ''' | |
| self._pointer += 1 | |
| fstring = self._endian + 'B' | |
| handle = self._payload[self._pointer - 1:self._pointer] | |
| return unpack_bitstring(handle) | |
| def decode_16bit_uint(self): | |
| ''' Decodes a 16 bit unsigned int from the buffer | |
| ''' | |
| self._pointer += 2 | |
| fstring = self._endian + 'H' | |
| handle = self._payload[self._pointer - 2:self._pointer] | |
| return unpack(fstring, handle)[0] | |
| def decode_32bit_uint(self): | |
| ''' Decodes a 32 bit unsigned int from the buffer | |
| ''' | |
| self._pointer += 4 | |
| fstring = self._endian + 'I' | |
| handle = self._payload[self._pointer - 4:self._pointer] | |
| return unpack(fstring, handle)[0] | |
| def decode_64bit_uint(self): | |
| ''' Decodes a 64 bit unsigned int from the buffer | |
| ''' | |
| self._pointer += 8 | |
| fstring = self._endian + 'Q' | |
| handle = self._payload[self._pointer - 8:self._pointer] | |
| return unpack(fstring, handle)[0] | |
| def decode_8bit_int(self): | |
| ''' Decodes a 8 bit signed int from the buffer | |
| ''' | |
| self._pointer += 1 | |
| fstring = self._endian + 'b' | |
| handle = self._payload[self._pointer - 1:self._pointer] | |
| return unpack(fstring, handle)[0] | |
| def decode_16bit_int(self): | |
| ''' Decodes a 16 bit signed int from the buffer | |
| ''' | |
| self._pointer += 2 | |
| fstring = self._endian + 'h' | |
| handle = self._payload[self._pointer - 2:self._pointer] | |
| return unpack(fstring, handle)[0] | |
| def decode_32bit_int(self): | |
| ''' Decodes a 32 bit signed int from the buffer | |
| ''' | |
| self._pointer += 4 | |
| fstring = self._endian + 'i' | |
| handle = self._payload[self._pointer - 4:self._pointer] | |
| return unpack(fstring, handle)[0] | |
| def decode_64bit_int(self): | |
| ''' Decodes a 64 bit signed int from the buffer | |
| ''' | |
| self._pointer += 8 | |
| fstring = self._endian + 'q' | |
| handle = self._payload[self._pointer - 8:self._pointer] | |
| return unpack(fstring, handle)[0] | |
| def decode_32bit_float(self): | |
| ''' Decodes a 32 bit float from the buffer | |
| ''' | |
| self._pointer += 4 | |
| fstring = self._endian + 'f' | |
| handle = self._payload[self._pointer - 4:self._pointer] | |
| return unpack(fstring, handle)[0] | |
| def decode_64bit_float(self): | |
| ''' Decodes a 64 bit float(double) from the buffer | |
| ''' | |
| self._pointer += 8 | |
| fstring = self._endian + 'd' | |
| handle = self._payload[self._pointer - 8:self._pointer] | |
| return unpack(fstring, handle)[0] | |
| def decode_string(self, size=1): | |
| ''' Decodes a string from the buffer | |
| :param size: The size of the string to decode | |
| ''' | |
| self._pointer += size | |
| return self._payload[self._pointer - size:self._pointer] | |
| def CONNECT_TO_METER(): | |
| try: | |
| client = None | |
| METER_PORT = find_tty_usb(ID_VENDOR, ID_PRODUCT) | |
| #print METER_PORT#reading to which port rs485(client) is connected | |
| client = ModbusClient(method='rtu', port=METER_PORT, baudrate=9600, stopbits=1, parity='E',timeout=0.3, bytesize=8) | |
| client.connect() | |
| return client | |
| except Exception as e: | |
| #lgr.error('Error while connecting client: ', exc_info = True) | |
| print "Error while connecting client: \n"+e.__str__() | |
| def find_tty_usb(idVendor, idProduct): | |
| """find_tty_usb('067b', '2302') -> '/dev/ttyUSB0'""" | |
| # Note: if searching for a lot of pairs, it would be much faster to search | |
| # for the enitre lot at once instead of going over all the usb devices | |
| # each time. | |
| for dnbase in os.listdir('/sys/bus/usb/devices'): | |
| dn = join('/sys/bus/usb/devices', dnbase) | |
| if not os.path.exists(join(dn, 'idVendor')): | |
| continue | |
| idv = open(join(dn, 'idVendor')).read().strip() | |
| if idv != idVendor: | |
| continue | |
| idp = open(join(dn, 'idProduct')).read().strip() | |
| if idp != idProduct: | |
| continue | |
| for subdir in os.listdir(dn): | |
| if subdir.startswith(dnbase+':'): | |
| for subsubdir in os.listdir(join(dn, subdir)): | |
| if subsubdir.startswith('ttyUSB'): | |
| return join('/dev', subsubdir) | |
| class HeatX3(driver.SmapDriver): | |
| def setup(self, opts): | |
| # host = opts.get("Host", "10.0.50.118") | |
| self.rate = int(opts.get("Rate", 20)) | |
| # self.modbus = ModbusTCP(host) | |
| self.add_timeseries('/AVolt', 'VOLT', data_type="double") | |
| self.add_timeseries('/BVolt', 'VOLT', data_type="double") | |
| self.add_timeseries('/CVolt', 'VOLT', data_type="double") | |
| self.add_timeseries('/IA1', 'Ampere', data_type="double") | |
| self.add_timeseries('/IA2', 'Ampere', data_type="double") | |
| self.add_timeseries('/IA3', 'Ampere', data_type="double") | |
| self.add_timeseries('/IA4', 'Ampere', data_type="double") | |
| self.add_timeseries('/IB1', 'Ampere', data_type="double") | |
| self.add_timeseries('/IB2', 'Ampere', data_type="double") | |
| self.add_timeseries('/IB3', 'Ampere', data_type="double") | |
| self.add_timeseries('/IB4', 'Ampere', data_type="double") | |
| self.add_timeseries('/IC1', 'Ampere', data_type="double") | |
| self.add_timeseries('/IC2', 'Ampere', data_type="double") | |
| self.add_timeseries('/IC3', 'Ampere', data_type="double") | |
| self.add_timeseries('/IC4', 'Ampere', data_type="double") | |
| self.add_timeseries('/Ckt1_PhaseA_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt2_PhaseA_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt3_PhaseA_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt4_PhaseA_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt1_PhaseB_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt2_PhaseB_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt3_PhaseB_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt4_PhaseB_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt1_PhaseC_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt2_PhaseC_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt3_PhaseC_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt4_PhaseC_actve_pow', 'Watts', data_type="long") | |
| self.add_timeseries('/Ckt1_PhaseA_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt2_PhaseA_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt3_PhaseA_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt4_PhaseA_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt1_PhaseB_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt2_PhaseB_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt3_PhaseB_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt4_PhaseB_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt1_PhaseC_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt2_PhaseC_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt3_PhaseC_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt4_PhaseC_REactve_pow', 'VAR', data_type="long") | |
| self.add_timeseries('/Ckt1_PhaseA_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt2_PhaseA_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt3_PhaseA_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt4_PhaseA_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt1_PhaseB_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt2_PhaseB_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt3_PhaseB_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt4_PhaseB_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt1_PhaseC_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt2_PhaseC_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt3_PhaseC_apprnt_pow', 'VA', data_type="long") | |
| self.add_timeseries('/Ckt4_PhaseC_apprnt_pow', 'VA', data_type="long") | |
| self.set_metadata('/', { | |
| 'Instrument/Manufacturer' : 'Pilot', | |
| 'Instrument/Model' : 'PMAC201-HW Meter' | |
| }) | |
| def start(self): | |
| util.periodicSequentialCall(self.update).start(self.rate) | |
| def update(self): | |
| client = CONNECT_TO_METER() | |
| #VOLTAGE START | |
| regObject =client.read_holding_registers(address=0,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| volt = 0.01*decoder.decode_16bit_uint() | |
| AV = volt | |
| regObject =client.read_holding_registers(address=1,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| volt = 0.01*decoder.decode_16bit_uint() | |
| BV = volt | |
| regObject =client.read_holding_registers(address=2,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| volt = 0.01*decoder.decode_16bit_uint() | |
| CV = volt | |
| #VOLTAGE CLOSE | |
| # CURRENT START | |
| regObject =client.read_holding_registers(address=10,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IA1 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=13,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IA2 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=11,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IB1 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=14,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IB2 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=12,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IC1 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=15,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IC2 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=16,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IA3 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=19,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IA4 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=17,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IB3 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=20,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IB4 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=19,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IC3 = before_decimal+(after_decimal%1000)/1000.0 | |
| regObject =client.read_holding_registers(address=21,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| after_decimal = decoder.decode_16bit_uint() | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| before_decimal=decoder.decode_8bit_int() | |
| if (after_decimal%1000)>500: | |
| before_decimal-=1 | |
| IC4 = before_decimal+(after_decimal%1000)/1000.0 | |
| # CURENT CLOSE | |
| #ACTIVE POWER START | |
| regObject =client.read_holding_registers(address=26,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A1actpow = value | |
| regObject =client.read_holding_registers(address=29,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A2actpow = value | |
| regObject =client.read_holding_registers(address=32,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A3actpow = value | |
| regObject =client.read_holding_registers(address=35,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A4actpow = value | |
| regObject =client.read_holding_registers(address=27,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B1actpow = value | |
| regObject =client.read_holding_registers(address=30,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B2actpow = value | |
| regObject =client.read_holding_registers(address=33,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B3actpow = value | |
| regObject =client.read_holding_registers(address=36,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B4actpow = value | |
| regObject =client.read_holding_registers(address=28,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C1actpow = value | |
| regObject =client.read_holding_registers(address=31,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C2actpow = value | |
| regObject =client.read_holding_registers(address=34,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C3actpow = value | |
| regObject =client.read_holding_registers(address=37,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C4actpow = value | |
| #ACTIVE POWER CLOSE | |
| #REACTIVE POWER START | |
| regObject =client.read_holding_registers(address=46,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A1REactpow = value | |
| regObject =client.read_holding_registers(address=49,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A2REactpow = value | |
| regObject =client.read_holding_registers(address=52,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A3REactpow = value | |
| regObject =client.read_holding_registers(address=55,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A4REactpow = value | |
| regObject =client.read_holding_registers(address=47,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B1REactpow = value | |
| regObject =client.read_holding_registers(address=50,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B2REactpow = value | |
| regObject =client.read_holding_registers(address=53,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B3REactpow = value | |
| regObject =client.read_holding_registers(address=56,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B4REactpow = value | |
| regObject =client.read_holding_registers(address=48,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C1REactpow = value | |
| regObject =client.read_holding_registers(address=51,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C2REactpow = value | |
| regObject =client.read_holding_registers(address=54,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C3REactpow = value | |
| regObject =client.read_holding_registers(address=57,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C4REactpow = value | |
| #REACTIVE POWER CLOSE | |
| #APPARENT POWER START | |
| regObject =client.read_holding_registers(address=82,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A1appPOW = value | |
| regObject =client.read_holding_registers(address=85,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A2appPOW = value | |
| regObject =client.read_holding_registers(address=88,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A3appPOW = value | |
| regObject =client.read_holding_registers(address=91,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| A4appPOW = value | |
| regObject =client.read_holding_registers(address=83,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B1appPOW = value | |
| regObject =client.read_holding_registers(address=86,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B2appPOW = value | |
| regObject =client.read_holding_registers(address=89,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B3appPOW = value | |
| regObject =client.read_holding_registers(address=92,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| B4appPOW = value | |
| regObject =client.read_holding_registers(address=84,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C1appPOW = value | |
| regObject =client.read_holding_registers(address=87,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C2appPOW = value | |
| regObject =client.read_holding_registers(address=90,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C3appPOW = value | |
| regObject =client.read_holding_registers(address=93,count=1,unit=146) | |
| decoder =BinaryPayloadDecoder.fromRegisters(regObject.registers, endian=Endian.Big) | |
| value = decoder.decode_16bit_int() | |
| C4appPOW = value | |
| # try: | |
| # data = self.modbus.read(25, 36) | |
| # except IOError, e: | |
| # log.err("Exception while reading device: " + str(e)) | |
| # return | |
| # if data == None: | |
| # log.err("Failed to read device\n"); | |
| # return | |
| # s = "" | |
| # try: | |
| # for i in range(0, len(data), 4): | |
| # s += data[i+1] | |
| # s += data[i+0] | |
| # s += data[i+3] | |
| # s += data[i+2] | |
| # vals = struct.unpack("<18f", s) | |
| # except: | |
| # return | |
| # | |
| t = util.now() | |
| # | |
| self.add("/AVolt", t, AV) | |
| self.add("/BVolt", t, BV) | |
| self.add("/CVolt", t, CV) | |
| self.add("/IA1", t, IA1) | |
| self.add("/IA2", t, IA2) | |
| self.add("/IA3", t, IA3) | |
| self.add("/IA4", t, IA4) | |
| self.add("/IB1", t, IB1) | |
| self.add("/IB2", t, IB2) | |
| self.add("/IB3", t, IB3) | |
| self.add("/IB4", t, IB4) | |
| self.add("/IC1", t, IC1) | |
| self.add("/IC2", t, IC2) | |
| self.add("/IC3", t, IC3) | |
| self.add("/IC4", t, IC4) | |
| self.add("/Ckt1_PhaseA_actve_pow", t, A1actpow) | |
| self.add("/Ckt2_PhaseA_actve_pow", t, A2actpow) | |
| self.add("/Ckt3_PhaseA_actve_pow", t, A3actpow) | |
| self.add("/Ckt4_PhaseA_actve_pow", t, A4actpow) | |
| self.add("/Ckt1_PhaseB_actve_pow", t, B1actpow) | |
| self.add("/Ckt2_PhaseB_actve_pow", t, B2actpow) | |
| self.add("/Ckt3_PhaseB_actve_pow", t, B3actpow) | |
| self.add("/Ckt4_PhaseB_actve_pow", t, B4actpow) | |
| self.add("/Ckt1_PhaseC_actve_pow", t, C1actpow) | |
| self.add("/Ckt2_PhaseC_actve_pow", t, C2actpow) | |
| self.add("/Ckt3_PhaseC_actve_pow", t, C3actpow) | |
| self.add("/Ckt4_PhaseC_actve_pow", t, C4actpow) | |
| self.add("/Ckt1_PhaseA_REactve_pow", t, A1REactpow) | |
| self.add("/Ckt2_PhaseA_REactve_pow", t, A2REactpow) | |
| self.add("/Ckt3_PhaseA_REactve_pow", t, A3REactpow) | |
| self.add("/Ckt4_PhaseA_REactve_pow", t, A4REactpow) | |
| self.add("/Ckt1_PhaseB_REactve_pow", t, B1REactpow) | |
| self.add("/Ckt2_PhaseB_REactve_pow", t, B2REactpow) | |
| self.add("/Ckt3_PhaseB_REactve_pow", t, B3REactpow) | |
| self.add("/Ckt4_PhaseB_REactve_pow", t, B4REactpow) | |
| self.add("/Ckt1_PhaseC_REactve_pow", t, C1REactpow) | |
| self.add("/Ckt2_PhaseC_REactve_pow", t, C2REactpow) | |
| self.add("/Ckt3_PhaseC_REactve_pow", t, C3REactpow) | |
| self.add("/Ckt4_PhaseC_REactve_pow", t, C4REactpow) | |
| self.add("/Ckt1_PhaseA_apprnt_pow", t, A1appPOW) | |
| self.add("/Ckt2_PhaseA_apprnt_pow", t, A2appPOW) | |
| self.add("/Ckt3_PhaseA_apprnt_pow", t, A3appPOW) | |
| self.add("/Ckt4_PhaseA_apprnt_pow", t, A4appPOW) | |
| self.add("/Ckt1_PhaseB_apprnt_pow", t, B1appPOW) | |
| self.add("/Ckt2_PhaseB_apprnt_pow", t, B2appPOW) | |
| self.add("/Ckt3_PhaseB_apprnt_pow", t, B3appPOW) | |
| self.add("/Ckt4_PhaseB_apprnt_pow", t, B4appPOW) | |
| self.add("/Ckt1_PhaseC_apprnt_pow", t, C1appPOW) | |
| self.add("/Ckt2_PhaseC_apprnt_pow", t, C2appPOW) | |
| self.add("/Ckt3_PhaseC_apprnt_pow", t, C3appPOW) | |
| self.add("/Ckt4_PhaseC_apprnt_pow", t, C4appPOW) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment