mirror of https://github.com/lumapu/ahoy.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
794 lines
26 KiB
794 lines
26 KiB
#!/usr/bin/python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
Hoymiles Micro-Inverters decoder library
|
|
"""
|
|
|
|
import struct
|
|
from datetime import datetime, timedelta
|
|
import crcmod
|
|
import logging
|
|
|
|
f_crc_m = crcmod.predefined.mkPredefinedCrcFun('modbus')
|
|
f_crc8 = crcmod.mkCrcFun(0x101, initCrc=0, xorOut=0)
|
|
|
|
def g_unpack(s_fmt, s_buf):
|
|
"""Chunk unpack helper
|
|
|
|
:param s_fmt: struct format string
|
|
:type s_fmt: str
|
|
:param s_buf: buffer to unpack
|
|
:type s_buf: bytes
|
|
:return: decoded data iterator
|
|
:rtype: generator object
|
|
"""
|
|
|
|
cs = struct.calcsize(s_fmt)
|
|
s_exc = len(s_buf) % cs
|
|
|
|
return struct.iter_unpack(s_fmt, s_buf[:len(s_buf) - s_exc])
|
|
|
|
def print_table_unpack(s_fmt, payload, cw=6):
|
|
"""
|
|
Print table of decoded numbers with different offsets
|
|
Helps recognizing values in unknown payloads
|
|
|
|
:param s_fmt: struct format string
|
|
:type s_fmt: str
|
|
:param payload: bytes data
|
|
:type payload: bytes
|
|
:param cw: cell width
|
|
:type cw: int
|
|
:return: None
|
|
"""
|
|
|
|
l_hexlified = [f'{byte:02x}' for byte in payload]
|
|
|
|
dbg = f'{"Pos": <{cw}}'
|
|
dbg += ''.join([f'{num: >{cw}}' for num in range(0, len(payload))])
|
|
logging.debug(dbg)
|
|
dbg = f'{"Hex": <{cw}}'
|
|
dbg += ''.join([f'{byte: >{cw}}' for byte in l_hexlified])
|
|
logging.debug(dbg)
|
|
|
|
l_fmt = struct.calcsize(s_fmt)
|
|
if len(payload) >= l_fmt:
|
|
for offset in range(0, l_fmt):
|
|
dbg = f'{s_fmt: <{cw}}'
|
|
dbg += ' ' * cw * offset
|
|
dbg += ''.join([f'{num[0]: >{cw*l_fmt}}' for num in g_unpack(s_fmt, payload[offset:])])
|
|
logging.debug(dbg)
|
|
|
|
class Response:
|
|
""" All Response Shared methods """
|
|
inverter_ser = None
|
|
inverter_name = None
|
|
dtu_ser = None
|
|
response = None
|
|
|
|
def __init__(self, *args, **params):
|
|
"""
|
|
:param bytes response: response payload bytes
|
|
"""
|
|
self.inverter_ser = params.get('inverter_ser', None)
|
|
self.inverter_name = params.get('inverter_name', None)
|
|
self.dtu_ser = params.get('dtu_ser', None)
|
|
self.response = args[0]
|
|
|
|
strings = params.get('strings', None)
|
|
self.inv_strings = strings
|
|
|
|
if isinstance(params.get('time_rx', None), datetime):
|
|
self.time_rx = params['time_rx']
|
|
else:
|
|
self.time_rx = datetime.now()
|
|
|
|
def __dict__(self):
|
|
""" Base values, availabe in each __dict__ call """
|
|
return {
|
|
'inverter_ser': self.inverter_ser,
|
|
'inverter_name': self.inverter_name,
|
|
'dtu_ser': self.dtu_ser}
|
|
|
|
class StatusResponse(Response):
|
|
"""Inverter StatusResponse object"""
|
|
phase_keys = ['voltage','current','power','reactive_power','frequency']
|
|
string_keys = ['voltage','current','power','energy_total','energy_daily', 'irradiation']
|
|
temperature = None
|
|
frequency = None
|
|
powerfactor = None
|
|
event_count = None
|
|
unpack_error = False
|
|
|
|
def unpack(self, fmt, base):
|
|
"""
|
|
Data unpack helper
|
|
|
|
:param str fmt: struct format string
|
|
:param int base: unpack base position from self.response bytes
|
|
:return: unpacked values
|
|
:rtype: tuple
|
|
"""
|
|
size = struct.calcsize(fmt)
|
|
if (len(self.response) < base+size):
|
|
self.unpack_error = True
|
|
logging.error(f'base: {base} size: {size} len: {len(self.response)} fmt: {fmt} rep: {self.response}')
|
|
return [0]
|
|
return struct.unpack(fmt, self.response[base:base+size])
|
|
|
|
@property
|
|
def phases(self):
|
|
"""
|
|
AC power data
|
|
|
|
:retrun: list of dict's
|
|
:rtype: list
|
|
"""
|
|
phases = []
|
|
p_exists = True
|
|
while p_exists:
|
|
p_exists = False
|
|
phase_id = len(phases)
|
|
phase = {}
|
|
for key in self.phase_keys:
|
|
prop = f'ac_{key}_{phase_id}'
|
|
if hasattr(self, prop):
|
|
p_exists = True
|
|
phase[key] = getattr(self, prop)
|
|
if p_exists:
|
|
phases.append(phase)
|
|
|
|
return phases
|
|
|
|
@property
|
|
def strings(self):
|
|
"""
|
|
DC PV-string data
|
|
|
|
:retrun: list of dict's
|
|
:rtype: list
|
|
"""
|
|
strings = []
|
|
s_exists = True
|
|
while s_exists:
|
|
s_exists = False
|
|
string_id = len(strings)
|
|
string = {}
|
|
for key in self.string_keys:
|
|
prop = f'dc_{key}_{string_id}'
|
|
if hasattr(self, prop):
|
|
s_exists = True
|
|
string[key] = getattr(self, prop)
|
|
if s_exists:
|
|
strings.append(string)
|
|
|
|
return strings
|
|
|
|
def __dict__(self):
|
|
"""
|
|
Get all known data
|
|
|
|
:return: dict of properties
|
|
:rtype: dict
|
|
"""
|
|
data = super().__dict__()
|
|
data['phases'] = self.phases
|
|
data['strings'] = self.strings
|
|
data['temperature'] = self.temperature
|
|
data['powerfactor'] = self.powerfactor
|
|
|
|
data['yield_total'] = 0.0
|
|
data['yield_today'] = 0.0
|
|
for string in data['strings']:
|
|
data['yield_total'] += string['energy_total']
|
|
data['yield_today'] += string['energy_daily']
|
|
|
|
ac_sum_power = 0.0
|
|
for phase in data['phases']:
|
|
ac_sum_power += phase['power']
|
|
dc_sum_power = 0.0
|
|
for string in data['strings']:
|
|
dc_sum_power += string['power']
|
|
if dc_sum_power != 0:
|
|
data['efficiency'] = round(ac_sum_power * 100 / dc_sum_power, 2)
|
|
else:
|
|
data['efficiency'] = 0.0
|
|
|
|
data['event_count'] = self.event_count
|
|
data['time'] = self.time_rx
|
|
|
|
if not self.unpack_error:
|
|
return data
|
|
|
|
class UnknownResponse(Response):
|
|
"""
|
|
Debugging helper for unknown payload format
|
|
"""
|
|
|
|
@property
|
|
def hex_ascii(self):
|
|
"""
|
|
Generate white-space separated byte representation
|
|
|
|
:return: hexlifierd byte string
|
|
:rtype: str
|
|
"""
|
|
return ' '.join([f'{byte:02x}' for byte in self.response])
|
|
|
|
def validate_crc8(self):
|
|
"""
|
|
Checks if self.response has valid CRC8
|
|
|
|
:return: if crc is available and correct
|
|
:rtype: bool
|
|
"""
|
|
# check crc
|
|
pcrc = struct.unpack('>B', self.response[-1:])[0]
|
|
return f_crc8(self.response[:-1]) == pcrc
|
|
|
|
def validate_crc_m(self):
|
|
"""
|
|
Checks if self.response has valid Modbus CRC
|
|
|
|
:return: if crc is available and correct
|
|
:rtype: bool
|
|
"""
|
|
# check crc
|
|
pcrc = struct.unpack('>H', self.response[-2:])[0]
|
|
return f_crc_m(self.response[:-2]) == pcrc
|
|
|
|
def unpack_table(self, *args):
|
|
"""Access shared debug function"""
|
|
print_table_unpack(*args)
|
|
|
|
|
|
class EventsResponse(UnknownResponse):
|
|
""" Hoymiles micro-inverter event log decode helper """
|
|
|
|
alarm_codes = {
|
|
# HM Error Codes
|
|
1: 'Inverter start', # 0x01
|
|
2: 'DTU command failed', # 0x02
|
|
121: 'Over temperature protection', # 0x79
|
|
125: 'Grid configuration parameter error', # 0x7D
|
|
126: 'Software error code 126', # 0x7E
|
|
127: 'Firmware error', # 0x7F
|
|
128: 'Software error code 128', # 0x80
|
|
129: 'Software error code 129', # 0x81
|
|
130: 'Offline', # 0x82
|
|
141: 'Grid overvoltage', # 0x8D
|
|
142: 'Average grid overvoltage', # 0x8E
|
|
143: 'Grid undervoltage', # 0x8F
|
|
144: 'Grid overfrequency', # 0x90
|
|
145: 'Grid underfrequency', # 0x91
|
|
146: 'Rapid grid frequency change', # 0x92
|
|
147: 'Power grid outage', # 0x93
|
|
148: 'Grid disconnection', # 0x94
|
|
149: 'Island detected', # 0x95
|
|
205: 'Input port 1 & 2 overvoltage', # 0xCD
|
|
206: 'Input port 3 & 4 overvoltage', # 0xCE
|
|
207: 'Input port 1 & 2 undervoltage', # 0xCF
|
|
208: 'Input port 3 & 4 undervoltage', # 0xD0
|
|
209: 'Port 1 no input', # 0xD1
|
|
210: 'Port 2 no input', # 0xD2
|
|
211: 'Port 3 no input', # 0xD3
|
|
212: 'Port 4 no input', # 0xD4
|
|
213: 'PV-1 & PV-2 abnormal wiring', # 0xD5
|
|
214: 'PV-3 & PV-4 abnormal wiring', # 0xD6
|
|
215: 'PV-1 Input overvoltage', # 0xD7
|
|
216: 'PV-1 Input undervoltage', # 0xD8
|
|
217: 'PV-2 Input overvoltage', # 0xD9
|
|
218: 'PV-2 Input undervoltage', # 0xDA
|
|
219: 'PV-3 Input overvoltage', # 0xDB
|
|
220: 'PV-3 Input undervoltage', # 0xDC
|
|
221: 'PV-4 Input overvoltage', # 0xDD
|
|
222: 'PV-4 Input undervoltage', # 0xDE
|
|
301: 'Hardware error code 301', # 0x012D
|
|
302: 'Hardware error code 302', # 0x012E
|
|
303: 'Hardware error code 303', # 0x012F
|
|
304: 'Hardware error code 304', # 0x0130
|
|
305: 'Hardware error code 305', # 0x0131
|
|
306: 'Hardware error code 306', # 0x0132
|
|
307: 'Hardware error code 307', # 0x0133
|
|
308: 'Hardware error code 308', # 0x0134
|
|
309: 'Hardware error code 309', # 0x0135
|
|
310: 'Hardware error code 310', # 0x0136
|
|
311: 'Hardware error code 311', # 0x0137
|
|
312: 'Hardware error code 312', # 0x0138
|
|
313: 'Hardware error code 313', # 0x0139
|
|
314: 'Hardware error code 314', # 0x013A
|
|
# MI Error Codes
|
|
5041: 'Error code-04 Port 1', # 0x13B1
|
|
5042: 'Error code-04 Port 2', # 0x13B2
|
|
5043: 'Error code-04 Port 3', # 0x13B3
|
|
5044: 'Error code-04 Port 4', # 0x13B4
|
|
5051: 'PV Input 1 Overvoltage/Undervoltage', # 0x13BB
|
|
5052: 'PV Input 2 Overvoltage/Undervoltage', # 0x13BC
|
|
5053: 'PV Input 3 Overvoltage/Undervoltage', # 0x13BD
|
|
5054: 'PV Input 4 Overvoltage/Undervoltage', # 0x13BE
|
|
5060: 'Abnormal bias', # 0x13C4
|
|
5070: 'Over temperature protection', # 0x13CE
|
|
5080: 'Grid Overvoltage/Undervoltage', # 0x13D8
|
|
5090: 'Grid Overfrequency/Underfrequency', # 0x13E2
|
|
5100: 'Island detected', # 0x13EC
|
|
5120: 'EEPROM reading and writing error', # 0x1400
|
|
5150: '10 min value grid overvoltage', # 0x141E
|
|
5200: 'Firmware error', # 0x1450
|
|
8310: 'Shut down', # 0x2076
|
|
9000: 'Microinverter is suspected of being stolen' # 0x2328
|
|
}
|
|
|
|
def __init__(self, *args, **params):
|
|
super().__init__(*args, **params)
|
|
|
|
crc_valid = self.validate_crc_m()
|
|
if crc_valid:
|
|
#logging.debug(' payload has valid modbus crc')
|
|
self.response = self.response[:-2]
|
|
|
|
self.status = struct.unpack('>H', self.response[:2])[0]
|
|
self.a_text = self.alarm_codes.get(self.status, 'N/A')
|
|
logging.info (f' Inverter status: {self.a_text} ({self.status})')
|
|
|
|
chunk_size = 12
|
|
for i_chunk in range(2, len(self.response), chunk_size):
|
|
chunk = self.response[i_chunk:i_chunk+chunk_size]
|
|
|
|
logging.debug(' '.join([f'{byte:02x}' for byte in chunk]) + ': ')
|
|
|
|
if (len(chunk[0:6]) < 6):
|
|
logging.error(f'length of chunk must be greater or equal 6 bytes: {chunk}')
|
|
return
|
|
|
|
opcode, a_code, a_count, uptime_sec = struct.unpack('>BBHH', chunk[0:6])
|
|
a_text = self.alarm_codes.get(a_code, 'N/A')
|
|
logging.debug(f' uptime={timedelta(seconds=uptime_sec)} a_count={a_count} opcode={opcode} a_code={a_code} a_text={a_text}')
|
|
|
|
dbg = ''
|
|
for fmt in ['BBHHHHH']:
|
|
dbg += f' {fmt:7}: ' + str(struct.unpack('>' + fmt, chunk))
|
|
logging.debug(dbg)
|
|
|
|
def __dict__(self):
|
|
""" Base values, availabe in each __dict__ call """
|
|
|
|
data = super().__dict__()
|
|
data['inv_stat_num'] = self.status
|
|
data['inv_stat_txt'] = self.a_text
|
|
return data
|
|
|
|
class HardwareInfoResponse(UnknownResponse):
|
|
def __init__(self, *args, **params):
|
|
super().__init__(*args, **params)
|
|
"""
|
|
const byteAssign_t InfoAssignment[] = {
|
|
{ FLD_FW_VERSION, UNIT_NONE, CH0, 0, 2, 1 },
|
|
{ FLD_FW_BUILD_YEAR, UNIT_NONE, CH0, 2, 2, 1 },
|
|
{ FLD_FW_BUILD_MONTH_DAY, UNIT_NONE, CH0, 4, 2, 1 },
|
|
{ FLD_FW_Build_Hour_Minute, UNIT_NONE, CH0, 6, 2, 1 },
|
|
{ FLD_HW_ID, UNIT_NONE, CH0, 8, 2, 1 },
|
|
{ FLD_unknown, UNIT_NONE, CH0, 10, 2, 1 },
|
|
{ FLD_unknown, UNIT_NONE, CH0, 12, 2, 1 },
|
|
{ FLD_CRC-M, UNIT_NONE, CH0, 14, 2, 1 }
|
|
};
|
|
self.response = bytes('\x27\x1a\x07\xe5\x04\x4d\x03\x4a\x00\x68\x00\x00\x00\x00\xe6\xfb', 'latin1')
|
|
"""
|
|
|
|
def __dict__(self):
|
|
""" Base values, availabe in each __dict__ call """
|
|
|
|
data = super().__dict__()
|
|
|
|
if (len(self.response) != 16):
|
|
logging.error(f'HardwareInfoResponse: data length should be 16 bytes - measured {len(self.response)} bytes')
|
|
logging.error(f'HardwareInfoResponse: data: {self.response}')
|
|
return data
|
|
|
|
logging.info(f'HardwareInfoResponse: {struct.unpack(">HHHHHHHH", self.response[0:16])}')
|
|
fw_version, fw_build_yyyy, fw_build_mmdd, fw_build_hhmm, hw_id = struct.unpack('>HHHHH', self.response[0:10])
|
|
|
|
fw_version_maj = int((fw_version / 10000))
|
|
fw_version_min = int((fw_version % 10000) / 100)
|
|
fw_version_pat = int((fw_version % 100))
|
|
fw_build_mm = int(fw_build_mmdd / 100)
|
|
fw_build_dd = int(fw_build_mmdd % 100)
|
|
fw_build_HH = int(fw_build_hhmm / 100)
|
|
fw_build_MM = int(fw_build_hhmm % 100)
|
|
logging.info(f'Firmware: {fw_version_maj}.{fw_version_min}.{fw_version_pat} '\
|
|
f'build at {fw_build_dd:>02}/{fw_build_mm:>02}/{fw_build_yyyy}T{fw_build_HH:>02}:{fw_build_MM:>02}, '\
|
|
f'HW revision {hw_id}')
|
|
|
|
data['FW_ver_maj'] = fw_version_maj
|
|
data['FW_ver_min'] = fw_version_min
|
|
data['FW_ver_pat'] = fw_version_pat
|
|
data['FW_build_yy'] = fw_build_yyyy
|
|
data['FW_build_mm'] = fw_build_mm
|
|
data['FW_build_dd'] = fw_build_dd
|
|
data['FW_build_HH'] = fw_build_HH
|
|
data['FW_build_MM'] = fw_build_MM
|
|
data['FW_HW_ID'] = hw_id
|
|
return data
|
|
|
|
class DebugDecodeAny(UnknownResponse):
|
|
"""Default decoder"""
|
|
|
|
def __init__(self, *args, **params):
|
|
super().__init__(*args, **params)
|
|
|
|
crc8_valid = self.validate_crc8()
|
|
if crc8_valid:
|
|
logging.debug(' payload has valid crc8')
|
|
self.response = self.response[:-1]
|
|
|
|
crc_valid = self.validate_crc_m()
|
|
if crc_valid:
|
|
logging.debug(' payload has valid modbus crc')
|
|
self.response = self.response[:-2]
|
|
|
|
l_payload = len(self.response)
|
|
logging.debug(f' payload has {l_payload} bytes')
|
|
|
|
logging.debug()
|
|
logging.debug('Field view: int')
|
|
print_table_unpack('>B', self.response)
|
|
|
|
logging.debug()
|
|
logging.debug('Field view: shorts')
|
|
print_table_unpack('>H', self.response)
|
|
|
|
logging.debug()
|
|
logging.debug('Field view: longs')
|
|
print_table_unpack('>L', self.response)
|
|
|
|
try:
|
|
if len(self.response) > 2:
|
|
logging.debug(' type utf-8 : ' + self.response.decode('utf-8'))
|
|
except UnicodeDecodeError:
|
|
logging.debug(' type utf-8 : utf-8 decode error')
|
|
|
|
try:
|
|
if len(self.response) > 2:
|
|
logging.debug(' type ascii : ' + self.response.decode('ascii'))
|
|
except UnicodeDecodeError:
|
|
logging.debug(' type ascii : ascii decode error')
|
|
|
|
|
|
# 1121-Series Intervers, 1 MPPT, 1 Phase
|
|
class Hm300Decode01(HardwareInfoResponse):
|
|
""" 1121-series Firmware version / date """
|
|
|
|
class Hm300Decode02(EventsResponse):
|
|
""" 1121-series Inverter generic events log """
|
|
|
|
class Hm300Decode0B(StatusResponse):
|
|
""" 1121-series mirco-inverters status data """
|
|
|
|
@property
|
|
def dc_voltage_0(self):
|
|
""" String 1 VDC """
|
|
return self.unpack('>H', 2)[0]/10
|
|
@property
|
|
def dc_current_0(self):
|
|
""" String 1 ampere """
|
|
return self.unpack('>H', 4)[0]/100
|
|
@property
|
|
def dc_power_0(self):
|
|
""" String 1 watts """
|
|
return self.unpack('>H', 6)[0]/10
|
|
@property
|
|
def dc_energy_total_0(self):
|
|
""" String 1 total energy in Wh """
|
|
return self.unpack('>L', 8)[0]
|
|
@property
|
|
def dc_energy_daily_0(self):
|
|
""" String 1 daily energy in Wh """
|
|
return self.unpack('>H', 12)[0]
|
|
@property
|
|
def dc_irradiation_0(self):
|
|
""" String 1 irratiation in percent """
|
|
if self.inv_strings is None:
|
|
return None
|
|
return round(self.unpack('>H', 6)[0]/10/self.inv_strings[0]['s_maxpower']*100, 3)
|
|
|
|
@property
|
|
def ac_voltage_0(self):
|
|
""" Phase 1 VAC """
|
|
return self.unpack('>H', 14)[0]/10
|
|
@property
|
|
def ac_current_0(self):
|
|
""" Phase 1 ampere """
|
|
return self.unpack('>H', 22)[0]/100
|
|
@property
|
|
def ac_power_0(self):
|
|
""" Phase 1 watts """
|
|
return self.unpack('>H', 18)[0]/10
|
|
@property
|
|
def ac_frequency_0(self):
|
|
""" Grid frequency in Hertz """
|
|
return self.unpack('>H', 16)[0]/100
|
|
@property
|
|
def ac_reactive_power_0(self):
|
|
""" reactive power """
|
|
return self.unpack('>H', 20)[0]/10
|
|
@property
|
|
def temperature(self):
|
|
""" Inverter temperature in °C """
|
|
return self.unpack('>h', 26)[0]/10
|
|
|
|
class Hm300Decode0C(Hm300Decode0B):
|
|
""" 1121-series mirco-inverters status data """
|
|
|
|
class Hm300Decode11(EventsResponse):
|
|
""" 1121-series Inverter generic events log """
|
|
|
|
class Hm300Decode12(EventsResponse):
|
|
""" 1121-series Inverter major events log """
|
|
|
|
|
|
# 1141-Series Inverters, 2 MPPT, 1 Phase
|
|
class Hm600Decode01(HardwareInfoResponse):
|
|
""" 1141-Series Firmware version / date """
|
|
|
|
class Hm600Decode02(EventsResponse):
|
|
""" 1141-Series Inverter generic events log """
|
|
|
|
class Hm600Decode0B(StatusResponse):
|
|
""" 1141-series mirco-inverters status data """
|
|
|
|
@property
|
|
def dc_voltage_0(self):
|
|
""" String 1 VDC """
|
|
return self.unpack('>H', 2)[0]/10
|
|
@property
|
|
def dc_current_0(self):
|
|
""" String 1 ampere """
|
|
return self.unpack('>H', 4)[0]/100
|
|
@property
|
|
def dc_power_0(self):
|
|
""" String 1 watts """
|
|
return self.unpack('>H', 6)[0]/10
|
|
@property
|
|
def dc_energy_total_0(self):
|
|
""" String 1 total energy in Wh """
|
|
return self.unpack('>L', 14)[0]
|
|
@property
|
|
def dc_energy_daily_0(self):
|
|
""" String 1 daily energy in Wh """
|
|
return self.unpack('>H', 22)[0]
|
|
@property
|
|
def dc_irradiation_0(self):
|
|
""" String 1 irratiation in percent """
|
|
if self.inv_strings is None:
|
|
return None
|
|
return round(self.unpack('>H', 6)[0]/10/self.inv_strings[0]['s_maxpower']*100, 3)
|
|
|
|
@property
|
|
def dc_voltage_1(self):
|
|
""" String 2 VDC """
|
|
return self.unpack('>H', 8)[0]/10
|
|
@property
|
|
def dc_current_1(self):
|
|
""" String 2 ampere """
|
|
return self.unpack('>H', 10)[0]/100
|
|
@property
|
|
def dc_power_1(self):
|
|
""" String 2 watts """
|
|
return self.unpack('>H', 12)[0]/10
|
|
@property
|
|
def dc_energy_total_1(self):
|
|
""" String 2 total energy in Wh """
|
|
return self.unpack('>L', 18)[0]
|
|
@property
|
|
def dc_energy_daily_1(self):
|
|
""" String 2 daily energy in Wh """
|
|
return self.unpack('>H', 24)[0]
|
|
@property
|
|
def dc_irradiation_1(self):
|
|
""" String 2 irratiation in percent """
|
|
if self.inv_strings is None:
|
|
return None
|
|
return round(self.unpack('>H', 12)[0]/10/self.inv_strings[1]['s_maxpower']*100, 3)
|
|
|
|
@property
|
|
def ac_voltage_0(self):
|
|
""" Phase 1 VAC """
|
|
return self.unpack('>H', 26)[0]/10
|
|
@property
|
|
def ac_current_0(self):
|
|
""" Phase 1 ampere """
|
|
return self.unpack('>H', 34)[0]/100
|
|
@property
|
|
def ac_power_0(self):
|
|
""" Phase 1 watts """
|
|
return self.unpack('>H', 30)[0]/10
|
|
@property
|
|
def ac_frequency_0(self):
|
|
""" Grid frequency in Hertz """
|
|
return self.unpack('>H', 28)[0]/100
|
|
@property
|
|
def ac_reactive_power_0(self):
|
|
""" reactive power """
|
|
return self.unpack('>H', 32)[0]/10
|
|
@property
|
|
def powerfactor(self):
|
|
""" Powerfactor """
|
|
return self.unpack('>H', 36)[0]/1000
|
|
@property
|
|
def temperature(self):
|
|
""" Inverter temperature in °C """
|
|
return self.unpack('>h', 38)[0]/10
|
|
@property
|
|
def event_count(self):
|
|
""" Event counter """
|
|
return self.unpack('>H', 40)[0]
|
|
|
|
class Hm600Decode0C(Hm600Decode0B):
|
|
""" 1141-series mirco-inverters status data """
|
|
|
|
class Hm600Decode11(EventsResponse):
|
|
""" 1141-Series Inverter generic events log """
|
|
|
|
class Hm600Decode12(EventsResponse):
|
|
""" 1141-Series Inverter major events log """
|
|
|
|
|
|
# 1161-Series Inverters, 2 MPPT, 1 Phase
|
|
class Hm1200Decode01(HardwareInfoResponse):
|
|
""" 1161-Series Firmware version / date """
|
|
|
|
class Hm1200Decode02(EventsResponse):
|
|
""" 1161-Series Inverter generic events log """
|
|
|
|
class Hm1200Decode0B(StatusResponse):
|
|
""" 1161-series mirco-inverters status data """
|
|
|
|
@property
|
|
def dc_voltage_0(self):
|
|
""" String 1 VDC """
|
|
return self.unpack('>H', 2)[0]/10
|
|
@property
|
|
def dc_current_0(self):
|
|
""" String 1 ampere """
|
|
return self.unpack('>H', 4)[0]/100
|
|
@property
|
|
def dc_power_0(self):
|
|
""" String 1 watts """
|
|
return self.unpack('>H', 8)[0]/10
|
|
@property
|
|
def dc_energy_total_0(self):
|
|
""" String 1 total energy in Wh """
|
|
return self.unpack('>L', 12)[0]
|
|
@property
|
|
def dc_energy_daily_0(self):
|
|
""" String 1 daily energy in Wh """
|
|
return self.unpack('>H', 20)[0]
|
|
@property
|
|
def dc_irradiation_0(self):
|
|
""" String 1 irratiation in percent """
|
|
if self.inv_strings is None:
|
|
return None
|
|
return round(self.unpack('>H', 8)[0]/10/self.inv_strings[0]['s_maxpower']*100, 3)
|
|
|
|
@property
|
|
def dc_voltage_1(self):
|
|
""" String 2 VDC """
|
|
return self.unpack('>H', 2)[0]/10
|
|
@property
|
|
def dc_current_1(self):
|
|
""" String 2 ampere """
|
|
return self.unpack('>H', 6)[0]/100
|
|
@property
|
|
def dc_power_1(self):
|
|
""" String 2 watts """
|
|
return self.unpack('>H', 10)[0]/10
|
|
@property
|
|
def dc_energy_total_1(self):
|
|
""" String 2 total energy in Wh """
|
|
return self.unpack('>L', 16)[0]
|
|
@property
|
|
def dc_energy_daily_1(self):
|
|
""" String 2 daily energy in Wh """
|
|
return self.unpack('>H', 22)[0]
|
|
@property
|
|
def dc_irradiation_0(self):
|
|
""" String 2 irratiation in percent """
|
|
if self.inv_strings is None:
|
|
return None
|
|
return round(self.unpack('>H', 10)[0]/10/self.inv_strings[1]['s_maxpower']*100, 3)
|
|
|
|
@property
|
|
def dc_voltage_2(self):
|
|
""" String 3 VDC """
|
|
return self.unpack('>H', 24)[0]/10
|
|
@property
|
|
def dc_current_2(self):
|
|
""" String 3 ampere """
|
|
return self.unpack('>H', 26)[0]/100
|
|
@property
|
|
def dc_power_2(self):
|
|
""" String 3 watts """
|
|
return self.unpack('>H', 30)[0]/10
|
|
@property
|
|
def dc_energy_total_2(self):
|
|
""" String 3 total energy in Wh """
|
|
return self.unpack('>L', 34)[0]
|
|
@property
|
|
def dc_energy_daily_2(self):
|
|
""" String 3 daily energy in Wh """
|
|
return self.unpack('>H', 42)[0]
|
|
@property
|
|
def dc_irradiation_0(self):
|
|
""" String 3 irratiation in percent """
|
|
if self.inv_strings is None:
|
|
return None
|
|
return round(self.unpack('>H', 30)[0]/10/self.inv_strings[2]['s_maxpower']*100, 3)
|
|
|
|
@property
|
|
def dc_voltage_3(self):
|
|
""" String 4 VDC """
|
|
return self.unpack('>H', 24)[0]/10
|
|
@property
|
|
def dc_current_3(self):
|
|
""" String 4 ampere """
|
|
return self.unpack('>H', 28)[0]/100
|
|
@property
|
|
def dc_power_3(self):
|
|
""" String 4 watts """
|
|
return self.unpack('>H', 32)[0]/10
|
|
@property
|
|
def dc_energy_total_3(self):
|
|
""" String 4 total energy in Wh """
|
|
return self.unpack('>L', 38)[0]
|
|
@property
|
|
def dc_energy_daily_3(self):
|
|
""" String 4 daily energy in Wh """
|
|
return self.unpack('>H', 44)[0]
|
|
@property
|
|
def dc_irradiation_0(self):
|
|
""" String 4 irratiation in percent """
|
|
if self.inv_strings is None:
|
|
return None
|
|
return round(self.unpack('>H', 32)[0]/10/self.inv_strings[3]['s_maxpower']*100, 3)
|
|
|
|
@property
|
|
def ac_voltage_0(self):
|
|
""" Phase 1 VAC """
|
|
return self.unpack('>H', 46)[0]/10
|
|
@property
|
|
def ac_current_0(self):
|
|
""" Phase 1 ampere """
|
|
return self.unpack('>H', 54)[0]/100
|
|
@property
|
|
def ac_power_0(self):
|
|
""" Phase 1 watts """
|
|
return self.unpack('>H', 50)[0]/10
|
|
@property
|
|
def ac_frequency_0(self):
|
|
""" Grid frequency in Hertz """
|
|
return self.unpack('>H', 48)[0]/100
|
|
@property
|
|
def ac_reactive_power_0(self):
|
|
""" reactive power """
|
|
return self.unpack('>H', 52)[0]/10
|
|
@property
|
|
def powerfactor(self):
|
|
""" Powerfactor """
|
|
return self.unpack('>H', 56)[0]/1000
|
|
@property
|
|
def temperature(self):
|
|
""" Inverter temperature in °C """
|
|
return self.unpack('>h', 58)[0]/10
|
|
@property
|
|
def event_count(self):
|
|
""" Event counter """
|
|
return self.unpack('>H', 60)[0]
|
|
|
|
class Hm1200Decode0C(Hm1200Decode0B):
|
|
""" 1161-series mirco-inverters status data """
|
|
|
|
class Hm1200Decode11(EventsResponse):
|
|
""" 1161-Series Inverter generic events log """
|
|
|
|
class Hm1200Decode12(EventsResponse):
|
|
""" 1161-Series Inverter major events log """
|
|
|