migrate paho.mqtt CallbackAPIVersion to VERSION2 (#225)

ha_addons/ha_addon/rootfs/home/proxy/messages.py

@@ -0,0 +1,203 @@
+import logging
+import weakref
+from typing import Callable
+from enum import Enum
+
+from async_ifc import AsyncIfc
+from protocol_ifc import ProtocolIfc
+from infos import Infos, Register
+from modbus import Modbus
+from my_timer import Timer
+
+logger = logging.getLogger('msg')
+
+
+def __hex_val(n, data, data_len):
+    line = ''
+    for j in range(n-16, n):
+        if j >= data_len:
+            break
+        line += '%02x ' % abs(data[j])
+    return line
+
+
+def __asc_val(n, data, data_len):
+    line = ''
+    for j in range(n-16, n):
+        if j >= data_len:
+            break
+        c = data[j] if not (data[j] < 0x20 or data[j] > 0x7e) else '.'
+        line += '%c' % c
+    return line
+
+
+def hex_dump(data, data_len) -> list:
+    n = 0
+    lines = []
+
+    for i in range(0, data_len, 16):
+        line = '  '
+        line += '%04x | ' % (i)
+        n += 16
+        line += __hex_val(n, data, data_len)
+        line += ' ' * (3 * 16 + 9 - len(line)) + ' | '
+        line += __asc_val(n, data, data_len)
+        lines.append(line)
+
+    return lines
+
+
+def hex_dump_str(data, data_len):
+    lines = hex_dump(data, data_len)
+    return '\n'.join(lines)
+
+
+def hex_dump_memory(level, info, data, data_len):
+    lines = []
+    lines.append(info)
+    tracer = logging.getLogger('tracer')
+    if not tracer.isEnabledFor(level):
+        return
+
+    lines += hex_dump(data, data_len)
+
+    tracer.log(level, '\n'.join(lines))
+
+
+class State(Enum):
+    '''state of the logical connection'''
+    init = 0
+    '''just created'''
+    received = 1
+    '''at least one packet received'''
+    up = 2
+    '''at least one cmd-rsp transaction'''
+    pend = 3
+    '''inverter transaction pending, don't send MODBUS cmds'''
+    closed = 4
+    '''connection closed'''
+
+
+class Message(ProtocolIfc):
+    MAX_START_TIME = 400
+    '''maximum time without a received msg in sec'''
+    MAX_INV_IDLE_TIME = 120
+    '''maximum time without a received msg from the inverter in sec'''
+    MAX_DEF_IDLE_TIME = 360
+    '''maximum default time without a received msg in sec'''
+    MB_START_TIMEOUT = 40
+    '''start delay for Modbus polling in server mode'''
+    MB_REGULAR_TIMEOUT = 60
+    '''regular Modbus polling time in server mode'''
+
+    def __init__(self, node_id, ifc: "AsyncIfc", server_side: bool,
+                 send_modbus_cb: Callable[[bytes, int, str], None],
+                 mb_timeout: int):
+        self._registry.append(weakref.ref(self))
+
+        self.server_side = server_side
+        self.ifc = ifc
+        self.node_id = node_id
+        if server_side:
+            self.mb = Modbus(send_modbus_cb, mb_timeout)
+            self.mb_timer = Timer(self.mb_timout_cb, self.node_id)
+        else:
+            self.mb = None
+            self.mb_timer = None
+        self.header_valid = False
+        self.header_len = 0
+        self.data_len = 0
+        self.unique_id = 0
+        self.sug_area = ''
+        self.new_data = {}
+        self.state = State.init
+        self.shutdown_started = False
+        self.modbus_elms = 0    # for unit tests
+        self.mb_timeout = self.MB_REGULAR_TIMEOUT
+        self.mb_first_timeout = self.MB_START_TIMEOUT
+        '''timer value for next Modbus polling request'''
+        self.modbus_polling = False
+
+    @property
+    def node_id(self):
+        return self._node_id
+
+    @node_id.setter
+    def node_id(self, value):
+        self._node_id = value
+        self.ifc.set_node_id(value)
+
+    '''
+    Empty methods, that have to be implemented in any child class which
+    don't use asyncio
+    '''
+    def _read(self) -> None:     # read data bytes from socket and copy them
+        # to our _recv_buffer
+        return  # pragma: no cover
+
+    def _set_mqtt_timestamp(self, key, ts: float | None):
+        if key not in self.new_data or \
+           not self.new_data[key]:
+            if key == 'grid':
+                info_id = Register.TS_GRID
+            elif key == 'input':
+                info_id = Register.TS_INPUT
+            elif key == 'total':
+                info_id = Register.TS_TOTAL
+            else:
+                return
+            # tstr = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(ts))
+            # logger.info(f'update: key: {key} ts:{tstr}'
+            self.db.set_db_def_value(info_id, round(ts))
+
+    def _timeout(self) -> int:
+        if self.state == State.init or self.state == State.received:
+            to = self.MAX_START_TIME
+        elif self.state == State.up and \
+                self.server_side and self.modbus_polling:
+            to = self.MAX_INV_IDLE_TIME
+        else:
+            to = self.MAX_DEF_IDLE_TIME
+        return to
+
+    def _send_modbus_cmd(self, func, addr, val, log_lvl) -> None:
+        if self.state != State.up:
+            logger.log(log_lvl, f'[{self.node_id}] ignore MODBUS cmd,'
+                       ' as the state is not UP')
+            return
+        self.mb.build_msg(Modbus.INV_ADDR, func, addr, val, log_lvl)
+
+    async def send_modbus_cmd(self, func, addr, val, log_lvl) -> None:
+        self._send_modbus_cmd(func, addr, val, log_lvl)
+
+    '''
+    Our puplic methods
+    '''
+    def close(self) -> None:
+        if self.server_side:
+            # set inverter state to offline, if output power is very low
+            logging.debug('close power: '
+                          f'{self.db.get_db_value(Register.OUTPUT_POWER, -1)}')
+            if self.db.get_db_value(Register.OUTPUT_POWER, 999) < 2:
+                self.db.set_db_def_value(Register.INVERTER_STATUS, 0)
+                self.new_data['env'] = True
+            self.mb_timer.close()
+        self.state = State.closed
+        self.ifc.rx_set_cb(None)
+        self.ifc.prot_set_timeout_cb(None)
+        self.ifc.prot_set_init_new_client_conn_cb(None)
+        self.ifc.prot_set_update_header_cb(None)
+        self.ifc = None
+
+        if self.mb:
+            self.mb.close()
+            self.mb = None
+        # pragma: no cover
+
+    def inc_counter(self, counter: str) -> None:
+        self.db.inc_counter(counter)
+        Infos.new_stat_data['proxy'] = True
+
+    def dec_counter(self, counter: str) -> None:
+        self.db.dec_counter(counter)
+        Infos.new_stat_data['proxy'] = True