version 0.5.5

* - fix issue 33

  The TSUN Cloud now responds to contact_info and get_time messages with
  an empty display message and not with a response message as before.
  We tried to parse data from the empty message, which led to an
  exception

* Add test with empty conn_ind from inverter

.coveragerc

@@ -0,0 +1,2 @@
+[run]
+branch = True

.gitignore

@@ -1,8 +1,10 @@
 __pycache__
 .pytest_cache
+bin/**
 mosquitto/**
 homeassistant/**
 tsun_proxy/**
-system_tests/**
 Doku/**
 .DS_Store
+.coverage
+coverage.xml

.vscode/settings.json

@@ -1,8 +1,15 @@
 {
     "python.testing.pytestArgs": [
-        "-vv",
-        "app","system_tests"
+        "-vv", 
+        "app",
+        "--cov=app/src",
+        "--cov-report=xml",
+        "--cov-report=html",
+        "system_tests"
     ],
     "python.testing.unittestEnabled": false,
-    "python.testing.pytestEnabled": true
+    "python.testing.pytestEnabled": true,
+    "flake8.args": [
+        "--extend-exclude=app/tests/*.py system_tests/*.py"   
+    ]
 }

CHANGELOG.md

@@ -7,11 +7,99 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.5] - 2023-12-31
+
+- Fixed [#33](https://github.com/s-allius/tsun-gen3-proxy/issues/33)
+- Fixed detection of the connected inputs/MPPTs
+- Preparation for overwriting received data
+- home assistant improvements:
+  - Add unit 'W' to the `Rated Power` value for home assistant
+  - `Collect_Interval`, `Connect_Count` and `Data_Up_Interval` as diagnostic value and not as graph
+  - Add data acquisition interval
+  - Add number of connections
+  - Add communication type
+  - Add 'Internal SW Exception' counter
+
+## [0.5.4] - 2023-11-22
+
+- hardening remove dangerous commands from busybox
+- add OTA start message counter
+- add message handler for over the air updates
+- add unit tests for ota messages
+- add unit test for int64 data type
+- cleanup msg_get_time_handler
+- remove python packages setuptools, wheel, pip from final image to reduce the attack surface
+
+## [0.5.3] - 2023-11-12
+
+- remove apk packet manager from the final image
+- send contact info every time a client connection is established
+- use TSUN timestamp instead of local time, as TSUN also expects Central European Summer Time in winter
+
+## [0.5.2] - 2023-11-09
+
+- add int64 data type to info parser
+- allow multiple calls to Message.close()
+- check for race cond. on closing and establishing client connections
+
+## [0.5.1] - 2023-11-05
+
+- fixes f-string by limes007
+- add description for dns settings by limes007
+
+## [0.5.0] - 2023-11-04
+
+- fix issue [#21](https://github.com/s-allius/tsun-gen3-proxy/issues/21)
+- register proxy dev as soon as the MQTT connection is established
+- increase test coverage of the Messages class
+- add error counter for unknown control bytes
+- lint code with flake8
+  
+## [0.4.3] - 2023-10-26
+
+- fix typos by Lenz Grimmer
+- catch mqtt errors, so we can forward messages to tsun even if the mqtt broker is not reachable
+- avoid resetting the daily generation counters even if the inverter sends zero values after reconnection
+
+## [0.4.2] - 2023-10-21
+
+- count unknown data types in received messages
+- count definition errors in our internal tables
+- increase test coverage of the Infos class to 100%
+- avoid resetting the daily generation counters even if the inverter sends zero values at sunset
+
+## [0.4.1] - 2023-10-20
+
+- fix issue [#18](https://github.com/s-allius/tsun-gen3-proxy/issues/18)
+- initialize the proxy statistics
+- avoid resetting total generation counters
+  
+## [0.4.0] - 2023-10-16
+
+- fix issue [#8](https://github.com/s-allius/tsun-gen3-proxy/issues/8)
+- implement [#10](https://github.com/s-allius/tsun-gen3-proxy/issues/10)
+- fix: don't dispatch ignored messages so that they are not forwarded
+- add systemtests
+- fix unit tests, which were broken since version 0.3.0
+- add proxy device to home assistant
+- add statistic counter to proxy device
+- support multiple inverter registration at home assistant
+  
+## [0.3.0] - 2023-10-10
+
+❗Due to the definition of values for diagnostics, the MQTT devices of controller and inverter should be deleted in the Home Assistant before updating to version '0.3.0'. After the update, these are automatically created again. The measurement data is retained.
+
+### Changes
+
+- optimize and reduce logging
+- switch to pathon 3.12
+- classify some values for diagnostics
+  
 ## [0.2.0] - 2023-10-07
 
 This version halves the size of the Docker image and reduces the attack surface for security vulnerabilities, by omitting unneeded code. The feature set is exactly the same as the previous release version 0.1.0.
 
-### Changes
+### Changes in 0.2.0
 
 - move from slim-bookworm to an alpine base image
 - install python requirements with pip wheel
@@ -44,31 +132,31 @@ This version halves the size of the Docker image and reduces the attack surface
   
 ❗Due to the change from one device to multiple devices in the Home Assistant, the previous MQTT device should be deleted in the Home Assistant after the update to pre-release '0.0.4'. Afterwards, the proxy must be restarted again to ensure that the sub-devices are created completely.
 
-### Added
+### Added in 0.0.4
 
 - Register multiple devices at home-assistant instead of one for all measurements.
   Now we register: a Controller, the inverter and up to 4 input devices to home-assistant.
   
 ## [0.0.3] - 2023-09-28
 
-### Added
+### Added in 0.0.3
 
 - Fixes Running Proxy with host UID and GUID #2
 
 ## [0.0.2] - 2023-09-27
 
-### Added
+### Added in 0.0.2
 
 - Dockerfile opencontainer labels
 - Send voltage and current of inputs to mqtt
 
 ## [0.0.1] - 2023-09-25
 
-### Added
+### Added in 0.0.1
 
 - Logger for inverter packets
 - SIGTERM handler for fast docker restarts
-- Proxy as non-root docker application 
+- Proxy as non-root docker application
 - Unit- and system tests
 - Home asssistant auto configuration
 - Self-sufficient island operation without internet
@@ -77,4 +165,4 @@ This version halves the size of the Docker image and reduces the attack surface
 
 ### Added
 
-- First checkin, the project was born
+- First checkin, the project was born

README.md

@@ -6,9 +6,9 @@
 <p align="center">integration</p>
 <p align="center">
     <a href="https://opensource.org/licenses/BSD-3-Clause"><img alt="License: BSD-3-Clause" src="https://img.shields.io/badge/License-BSD_3--Clause-green.svg"></a>
-    <a href="https://www.python.org/downloads/release/python-3110/"><img alt="Supported Python versions" src="https://img.shields.io/badge/python-3.11-blue.svg"></a>
-    <a href="https://sbtinstruments.github.io/aiomqtt/introduction.html"><img alt="Supported Python versions" src="https://img.shields.io/badge/aiomqtt-1.2.0-lightblue.svg"></a>
-    <a href="https://toml.io/en/v1.0.0"><img alt="Supported Python versions" src="https://img.shields.io/badge/toml-1.0.0-lightblue.svg"></a>
+    <a href="https://www.python.org/downloads/release/python-3120/"><img alt="Supported Python versions" src="https://img.shields.io/badge/python-3.12-blue.svg"></a>
+    <a href="https://sbtinstruments.github.io/aiomqtt/introduction.html"><img alt="Supported aiomqtt versions" src="https://img.shields.io/badge/aiomqtt-1.2.1-lightblue.svg"></a>
+    <a href="https://toml.io/en/v1.0.0"><img alt="Supported toml versions" src="https://img.shields.io/badge/toml-1.0.0-lightblue.svg"></a>
 
 </p>
 
@@ -16,13 +16,16 @@
 ###
 # Overview
 
-The "TSUN Gen3 Micro-Inverter" proxy enables a reliable connection between TSUN third generation inverters and an MQTT broker. With the proxy, you can easily retrieve real-time values such as power, current and daily energy and integrate the inverter into typical home automations. This works even without an internet connection. The optional connection to the TSUN Cloud can be disabled!
+This proxy enables a reliable connection between TSUN third generation inverters and an MQTT broker. With the proxy, you can easily retrieve real-time values such as power, current and daily energy and integrate the inverter into typical home automations. This works even without an internet connection. The optional connection to the TSUN Cloud can be disabled!
 
 In detail, the inverter establishes a TCP connection to the TSUN cloud to transmit current measured values every 300 seconds. To be able to forward the measurement data to an MQTT broker, the proxy must be looped into this TCP connection.
 
 Through this, the inverter then establishes a connection to the proxy and the proxy establishes another connection to the TSUN Cloud. The transmitted data is interpreted by the proxy and then passed on to both the TSUN Cloud and the MQTT broker. The connection to the TSUN Cloud is optional and can be switched off in the configuration (default is on). Then no more data is sent to the Internet, but no more remote updates of firmware and operating parameters (e.g. rated power, grid parameters) are possible.
 
-By means of `docker` a simple installation and operation is possible. By using `docker-composer`, a complete stack of proxy, `MQTT-brocker` and `home-assistant` can be started easily. 
+By means of `docker` a simple installation and operation is possible. By using `docker-composer`, a complete stack of proxy, `MQTT-brocker` and `home-assistant` can be started easily.
+###
+ℹ️ This project is not related to the company TSUN. It is a private initiative that aims to connect TSUN inverters with an MQTT broker. There is no support and no warranty from TSUN.
+###
 
 ```
 ❗An essential requirement is that the proxy can be looped into the connection
@@ -37,11 +40,18 @@ If you use a Pi-hole, you can also store the host entry in the Pi-hole.
 
 ## Features
 
+- supports TSUN G3 inverters: TSOL MS-300, MS-350, MS-400, MS-600, MS-700 and MS-800
+- support for TSUN G3 Plus inverters is in preperation (e.g. MS-2000)
 - `MQTT` support
 - `Home-Assistant` auto-discovery support
 - Self-sufficient island operation without internet
 - non-root Docker Container
 
+## Home Assistant Screenshots
+
+Here are some screenshots of how the inverter is displayed in the Home Assistant:
+
+https://github.com/s-allius/tsun-gen3-proxy/wiki/home-assistant#home-assistant-screenshots
 ## Requirements
 
 - A running Docker engine to host the container
@@ -101,6 +111,8 @@ mqtt.passwd  = ''
 ha.auto_conf_prefix = 'homeassistant'       # MQTT prefix for subscribing for homeassistant status updates
 ha.discovery_prefix = 'homeassistant'       # MQTT prefix for discovery topic 
 ha.entity_prefix    = 'tsun'                # MQTT topic prefix for publishing inverter values
+ha.proxy_node_id    = 'proxy'               # MQTT node id, for the proxy_node_id
+ha.proxy_unique_id  = 'P170000000000001'    # MQTT unique id, to identify a proxy instance
 
 
 # microinverters
@@ -109,6 +121,7 @@ inverters.allow_all = false   # True: allow inverters, even if we have no invert
 # inverter mapping, maps a `serial_no* to a `node_id` and defines an optional `suggested_area` for `home-assistant`
 #
 # for each inverter add a block starting with [inverters."<16-digit serial numbeer>"]
+
 [inverters."R17xxxxxxxxxxxx1"]
 node_id = 'inv1'              # Optional, MQTT replacement for inverters serial number  
 suggested_area = 'roof'       # Optional, suggested installation area for home-assistant
@@ -120,6 +133,50 @@ suggested_area = 'balcony'    # Optional, suggested installation area for home-a
 
 ```
 
+## DNS Settings
+
+### Loop the proxy into the connection
+To include the proxy in the connection between the inverter and the TSUN Cloud, you must adapt the DNS record of *logger.talent-monitoring.com* within the network that your inverter uses. You need a mapping from logger.talent-monitoring.com to the IP address of the host running the Docker engine.
+
+This can be done, for example, by adding a local DNS record to the Pi-hole if you are using it.
+
+### DNS Rebind Protection
+If you are using a router as local DNS server, the router may have DNS rebind protection that needs to be adjusted. For security reasons, DNS rebind protection blocks DNS queries that refer to an IP address on the local network.
+
+If you are using a FRITZ!Box, you can do this in the Network Settings tab under Home Network / Network. Add logger.talent-monitoring.com as a hostname exception in DNS rebind protection.
+
+### DNS server of proxy
+The proxy itself must use a different DNS server to connect to the TSUN Cloud. If you use the DNS server with the adapted record, you will end up in an endless loop as soon as the proxy tries to send data to the TSUN Cloud.
+
+As described above, set a DNS sever in the Docker command or Docker compose file.
+
+### Over The Air (OTA) firmware update
+Even if the proxy is connected between the inverter and the TSUN Cloud, an OTA update is supported. To do this, the inverter must be able to reach the website http://www.talent-monitoring.com:9002/ in order to download images from there.
+
+It must be ensured that this address is not mapped to the proxy!
+
+## Compatibility
+In the following table you will find an overview of which inverter model has been tested for compatibility with which firmware version.
+A combination with a red question mark should work, but I have not checked it in detail.
+
+Micro Inverter Model | Fw. 1.00.06 | Fw. 1.00.17 | Fw. 1.00.20| Fw. 1.1.00.0B
+:---|:---:|:---:|:---:|:---:|
+G3 micro inverters (single MPPT):<br>MS-300, MS-350, MS-400| ❓ | ❓ | ❓ |➖
+G3 micro inverters (dual MPPT):<br>MS-600, MS-700, MS-800| ✔️ | ✔️ | ✔️ |➖
+G3 PLUS micro inverters:<br>MS-1600, MS-1800, MS-2000| ➖  |➖ | ➖ | 🚧 
+balcony micro inverters:<br>MS-400-D, MS-800-D, MS-2000-D| ❓ | ❓ | ❓| ❓ 
+
+```
+Legend
+➖: Firmware not available for this devices
+✔️: proxy support testet
+❓: proxy support possible but not testet
+🚧: Proxy support in preparation
+```
+❗The new inverters of the G3Plus generation (e.g. MS-2000) use a completely different protocol for data transmission to the TSUN server. I already have such an inverter in operation and am working on the integration for the proxy version 0.6. The serial numbers of these inverters start with `Y17E` instead of `R17E`
+
+If you have one of these combinations with a red question mark, it would be very nice if you could send me a proxy trace so that I can carry out the detailed checks and adjust the device and system tests. [Ask here how to send a trace](https://github.com/s-allius/tsun-gen3-proxy/discussions/categories/traces-for-compatibility-check)
+
 ## License
 
 This project is licensed under the [BSD 3-clause License](https://opensource.org/licenses/BSD-3-Clause).
@@ -129,7 +186,6 @@ Note the aiomqtt library used is based on the paho-mqtt library, which has a dua
 - One use of "COPYRIGHT OWNER" (EDL) instead of "COPYRIGHT HOLDER" (BSD)
 - One use of "Eclipse Foundation, Inc." (EDL) instead of "copyright holder" (BSD)
 
-
 ## Versioning
 
 This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Breaking changes will only occur in major `X.0.0` releases.

app/.dockerignore

@@ -1,4 +1,5 @@
 tests/
 **/__pycache__
 *.pyc
-.DS_Store
+.DS_Store
+build.sh

app/Dockerfile

@@ -4,23 +4,24 @@ ARG GID=1000
 
 #
 # first stage for our base image
-FROM python:3.11-alpine AS base
+FROM python:3.12-alpine AS base
 USER root
 
-RUN apk update && \
-    apk upgrade
-RUN apk add --no-cache su-exec	
+COPY --chmod=0700 ./hardening_base.sh .
+RUN apk upgrade --no-cache && \
+    apk add --no-cache su-exec	&& \
+    ./hardening_base.sh && \
+    rm ./hardening_base.sh
 
 #
 # second stage for building wheels packages
 FROM base as builder
 
-RUN apk add --no-cache build-base && \
-    python -m pip install --no-cache-dir -U pip wheel
-
 # copy the dependencies file to the root dir and install requirements
 COPY ./requirements.txt /root/
-RUN python -OO -m pip wheel --no-cache-dir --wheel-dir=/root/wheels -r /root/requirements.txt
+RUN apk add --no-cache build-base && \
+    python -m pip install --no-cache-dir -U pip wheel && \
+    python -OO -m pip wheel --no-cache-dir --wheel-dir=/root/wheels -r /root/requirements.txt
 
 
 #
@@ -31,26 +32,32 @@ ARG VERSION
 ARG UID
 ARG GID
 ARG LOG_LVL
+ARG environment
 
 ENV VERSION=$VERSION
 ENV SERVICE_NAME=$SERVICE_NAME
 ENV UID=$UID
 ENV GID=$GID 
 ENV LOG_LVL=$LOG_LVL
+ENV HOME=/home/$SERVICE_NAME
 
     
 # set the working directory in the container
 WORKDIR /home/$SERVICE_NAME
 
-# update PATH environment variable
-ENV HOME=/home/$SERVICE_NAME
-
 VOLUME ["/home/$SERVICE_NAME/log", "/home/$SERVICE_NAME/config"]
 
-# install the requirements from the wheels packages from the builder stage
+# install the requirements from the wheels packages from the builder stage 
+# and unistall python packages and alpine package manger to reduce attack surface
 COPY --from=builder /root/wheels /root/wheels
+COPY --chmod=0700 ./hardening_final.sh .
 RUN python -m pip install --no-cache --no-index /root/wheels/* && \
-    rm -rf /root/wheels
+    rm -rf /root/wheels && \
+    python -m pip uninstall --yes setuptools wheel pip && \
+    apk --purge del apk-tools && \
+    ./hardening_final.sh && \
+    rm ./hardening_final.sh
+
 
 # copy the content of the local src and config directory to the working directory
 COPY --chmod=0700 entrypoint.sh /root/entrypoint.sh

app/build.sh

@@ -22,11 +22,11 @@ fi
 
 echo version: $VERSION  build-date: $BUILD_DATE   image: $IMAGE
 if [[ $1 == dev ]];then
-docker build --build-arg "VERSION=${VERSION}" --build-arg "LOG_LVL=DEBUG" --label "org.label-schema.build-date=${BUILD_DATE}" --label "org.opencontainers.image.version=${VERSION}" -t ${IMAGE}:latest app
+docker build --build-arg "VERSION=${VERSION}" --build-arg environment=dev --build-arg "LOG_LVL=DEBUG" --label "org.label-schema.build-date=${BUILD_DATE}" --label "org.opencontainers.image.version=${VERSION}" -t ${IMAGE}:latest app
 elif [[ $1 == rc ]];then
-docker build --no-cache --build-arg "VERSION=${VERSION}" --label "org.label-schema.build-date=${BUILD_DATE}" --label "org.opencontainers.image.version=${VERSION}" -t ${IMAGE}:latest app
+docker build --build-arg "VERSION=${VERSION}" --build-arg environment=production --label "org.label-schema.build-date=${BUILD_DATE}" --label "org.opencontainers.image.version=${VERSION}" -t ${IMAGE}:latest app
 elif [[ $1 == rel ]];then
-docker build --no-cache --build-arg "VERSION=${VERSION}" --label "org.label-schema.build-date=${BUILD_DATE}" --label "org.opencontainers.image.version=${VERSION}" -t ${IMAGE}:latest -t ${IMAGE}:${MAJOR} -t ${IMAGE}:${VERSION} app
+docker build --no-cache --build-arg "VERSION=${VERSION}" --build-arg environment=production --label "org.label-schema.build-date=${BUILD_DATE}" --label "org.opencontainers.image.version=${VERSION}" -t ${IMAGE}:latest -t ${IMAGE}:${MAJOR} -t ${IMAGE}:${VERSION} app
 docker push ghcr.io/s-allius/tsun-gen3-proxy:latest
 docker push ghcr.io/s-allius/tsun-gen3-proxy:${MAJOR}
 docker push ghcr.io/s-allius/tsun-gen3-proxy:${VERSION}

app/config/default_config.toml

@@ -15,6 +15,8 @@ mqtt.passwd  = ''
 ha.auto_conf_prefix = 'homeassistant'       # MQTT prefix for subscribing for homeassistant status updates
 ha.discovery_prefix = 'homeassistant'       # MQTT prefix for discovery topic 
 ha.entity_prefix    = 'tsun'                # MQTT topic prefix for publishing inverter values
+ha.proxy_node_id    = 'proxy'               # MQTT node id, for the proxy_node_id
+ha.proxy_unique_id  = 'P170000000000001'    # MQTT unique id, to identify a proxy instance
 
 # microinverters
 inverters.allow_all = true   # allow inverters, even if we have no inverter mapping

app/entrypoint.sh

@@ -11,10 +11,12 @@ if [ "$user" = '0' ]; then
     mkdir -p /home/$SERVICE_NAME/log /home/$SERVICE_NAME/config
     
     if ! id $SERVICE_NAME &> /dev/null; then
+        echo "# create user"
         addgroup --gid $GID $SERVICE_NAME 2> /dev/null
         adduser -G $SERVICE_NAME -s /bin/false -D -H -g "" -u $UID $SERVICE_NAME
+    	chown -R $SERVICE_NAME:$SERVICE_NAME /home/$SERVICE_NAME || true
+        rm -fr /usr/sbin/addgroup /usr/sbin/adduser /bin/chown
     fi    
-	chown -R $SERVICE_NAME:$SERVICE_NAME /home/$SERVICE_NAME || true
     echo "######################################################"
     echo "#"
 

app/hardening_base.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+rm -fr /var/spool/cron
+rm -fr /etc/crontabs
+rm -fr /etc/periodic
+
+# Remove every user and group but root
+sed -i -r '/^(root)/!d' /etc/group
+sed -i -r '/^(root)/!d' /etc/passwd    
+
+# Remove init scripts since we do not use them.
+rm -fr /etc/inittab
+
+# Remove kernel tunables since we do not need them.
+rm -fr /etc/sysctl*
+rm -fr /etc/modprobe.d
+
+# Remove fstab since we do not need it.
+rm -f /etc/fstab

app/hardening_final.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+# For production images delete all uneeded admin commands and remove dangerous commands.
+# addgroup, adduser and chmod will be removed in entrypoint.sh during first start
+# su-exec will be needed for ever restart of the cotainer
+if [ "$environment" = "production" ] ; then \
+  find /sbin /usr/sbin  ! -type d \
+  -a ! -name addgroup \
+  -a ! -name adduser \
+  -a ! -name nologin \
+  -a ! -name su-exec \
+   -delete; \
+  find /bin /usr/bin -xdev \( \
+  -name chgrp -o \
+  -name chmod -o \
+  -name hexdump -o \
+  -name ln -o \
+  -name od -o \
+  -name strings -o \
+  -name su -o \
+  -name wget -o \
+  \) -delete  \
+; fi

app/src/async_stream.py

@@ -1,95 +1,67 @@
-import logging, traceback
-from config import Config
-#import gc
+import logging
+import traceback
+# from config import Config
+# import gc
 from messages import Message, hex_dump_memory
 
 logger = logging.getLogger('conn')
 
+
 class AsyncStream(Message):
 
-    def __init__(self, reader, writer, addr, remote_stream, server_side: bool) -> None:
-        super().__init__()
+    def __init__(self, reader, writer, addr, remote_stream, server_side: bool,
+                 id_str=b'') -> None:
+        super().__init__(server_side, id_str)
         self.reader = reader
         self.writer = writer
         self.remoteStream = remote_stream
-        self.server_side = server_side
         self.addr = addr
-        self.unique_id = 0
-        self.node_id = ''
-        
+        self.r_addr = ''
+        self.l_addr = ''
+
     '''
     Our puplic methods
     '''
-    def set_serial_no(self, serial_no : str):
-        logger.debug(f'SerialNo: {serial_no}')
-       
-        if self.unique_id != serial_no: 
-       
-            inverters = Config.get('inverters')
-            #logger.debug(f'Inverters: {inverters}')
-                
-            if serial_no in inverters:
-                logger.debug(f'SerialNo {serial_no} allowed!')
-                inv = inverters[serial_no]
-                self.node_id = inv['node_id']
-                self.sug_area    = inv['suggested_area']
-            else:    
-                logger.debug(f'SerialNo {serial_no} not known!')
-                self.node_id = ''
-                self.sug_area    = ''
-                if not inverters['allow_all']:
-                    self.unique_id = None
-            
-                    logger.warning(f'ignore message from unknow inverter! (SerialNo: {serial_no})')
-                    return
+    async def loop(self):
+        self.r_addr = self.writer.get_extra_info('peername')
+        self.l_addr = self.writer.get_extra_info('sockname')
 
-            self.unique_id = serial_no
-            
-            
-            
-
-    
-    async def loop(self) -> None:
-        
         while True:
             try:
-                await self.__async_read()     
-                
-                if self.id_str:
-                    self.set_serial_no(self.id_str.decode("utf-8"))
-            
-                if self.unique_id: 
-                    await self.__async_write()     
+                await self.__async_read()
+
+                if self.unique_id:
+                    await self.__async_write()
                     await self.__async_forward()
                     await self.async_publ_mqtt()
-                
-      
+
             except (ConnectionResetError,
                     ConnectionAbortedError,
+                    BrokenPipeError,
                     RuntimeError) as error:
-                logger.warning(f'In loop for {self.addr}: {error}')
+                logger.warning(f'In loop for l{self.l_addr} | '
+                               f'r{self.r_addr}: {error}')
                 self.close()
-                return
+                return self
             except Exception:
+                self.inc_counter('SW_Exception')
                 logger.error(
                     f"Exception for {self.addr}:\n"
                     f"{traceback.format_exc()}")
                 self.close()
-                return
-            
+                return self
+
     def disc(self) -> None:
-        logger.debug(f'in AsyncStream.disc() {self.addr}')
+        logger.debug(f'in AsyncStream.disc() l{self.l_addr} | r{self.r_addr}')
         self.writer.close()
-            
-        
+
     def close(self):
-        logger.debug(f'in AsyncStream.close() {self.addr}')
+        logger.debug(f'in AsyncStream.close() l{self.l_addr} | r{self.r_addr}')
         self.writer.close()
         super().close()         # call close handler in the parent class
 
-#        logger.info (f'AsyncStream refs: {gc.get_referrers(self)}')
+#        logger.info(f'AsyncStream refs: {gc.get_referrers(self)}')
 
-    
     '''
     Our private methods
     '''
@@ -100,33 +72,38 @@ class AsyncStream(Message):
             self.read()                # call read in parent class
         else:
             raise RuntimeError("Peer closed.")
-            
+
     async def __async_write(self) -> None:
         if self._send_buffer:
-            hex_dump_memory(logging.INFO, f'Transmit to {self.addr}:', self._send_buffer, len(self._send_buffer))
+            hex_dump_memory(logging.INFO, f'Transmit to {self.addr}:',
+                            self._send_buffer, len(self._send_buffer))
             self.writer.write(self._send_buffer)
             await self.writer.drain()
-            self._send_buffer = bytearray(0)  #self._send_buffer[sent:]
-            
+            self._send_buffer = bytearray(0)  # self._send_buffer[sent:]
+
     async def __async_forward(self) -> None:
         if self._forward_buffer:
             if not self.remoteStream:
-                await self.async_create_remote()  # only implmeneted for server side => syncServerStream
-                
+                await self.async_create_remote()
+                if self.remoteStream:
+                    self.remoteStream._init_new_client_conn(self.contact_name,
+                                                            self.contact_mail)
+                    await self.remoteStream.__async_write()
+
             if self.remoteStream:
-                hex_dump_memory(logging.DEBUG, f'Forward to {self.remoteStream.addr}:', self._forward_buffer, len(self._forward_buffer))
-                self.remoteStream.writer.write (self._forward_buffer)
-                await self.remoteStream.writer.drain()                    
+                hex_dump_memory(logging.INFO,
+                                f'Forward to {self.remoteStream.addr}:',
+                                self._forward_buffer,
+                                len(self._forward_buffer))
+                self.remoteStream.writer.write(self._forward_buffer)
+                await self.remoteStream.writer.drain()
                 self._forward_buffer = bytearray(0)
 
     async def async_create_remote(self) -> None:
         pass
 
     async def async_publ_mqtt(self) -> None:
-        pass       
-
-
-    def __del__ (self):
-        logging.debug (f"AsyncStream.__del__  {self.addr}")     
-
+        pass
 
+    def __del__(self):
+        logging.debug(f"AsyncStream.__del__  l{self.l_addr} | r{self.r_addr}")

app/src/config.py

@@ -1,76 +1,90 @@
 '''Config module handles the proxy configuration in the config.toml file'''
 
-import shutil, tomllib, logging
+import shutil
+import tomllib
+import logging
 from schema import Schema, And, Use, Optional
 
+
 class Config():
-    '''Static class Config is reads and sanitize the config. 
-    
-    Read config.toml file and sanitize it with read(). 
+    '''Static class Config is reads and sanitize the config.
+
+    Read config.toml file and sanitize it with read().
     Get named parts of the config with get()'''
 
     config = {}
-    conf_schema = Schema({  'tsun': {
-                                    'enabled': Use(bool),
-                                    'host':    Use(str), 
-                                    'port':    And(Use(int), lambda n: 1024 <= n <= 65535)}, 
+    conf_schema = Schema({
+        'tsun': {
+            'enabled': Use(bool),
+            'host':    Use(str),
+            'port':    And(Use(int), lambda n: 1024 <= n <= 65535)
+            },
+        'mqtt': {
+            'host':    Use(str),
+            'port':    And(Use(int), lambda n: 1024 <= n <= 65535),
+            'user':    And(Use(str), Use(lambda s: s if len(s) > 0 else None)),
+            'passwd':  And(Use(str), Use(lambda s: s if len(s) > 0 else None))
+            },
+        'ha': {
+            'auto_conf_prefix': Use(str),
+            'discovery_prefix': Use(str),
+            'entity_prefix':    Use(str),
+            'proxy_node_id':    Use(str),
+            'proxy_unique_id':  Use(str)
+            },
+        'inverters': {
+            'allow_all': Use(bool), And(Use(str), lambda s: len(s) == 16): {
+                Optional('node_id', default=""): And(Use(str),
+                                                     Use(lambda s: s + '/'
+                                                         if len(s) > 0 and
+                                                         s[-1] != '/' else s)),
 
-                            'mqtt': {
-                                    'host':    Use(str), 
-                                    'port':    And(Use(int), lambda n: 1024 <= n <= 65535), 
-                                    'user':    And(Use(str), Use(lambda s: s if len(s) >0 else None)), 
-                                    'passwd':  And(Use(str), Use(lambda s: s if len(s) >0 else None))},
-
-                            
-                            'ha': {
-                                    'auto_conf_prefix': Use(str),
-                                    'discovery_prefix': Use(str),
-                                    'entity_prefix':    Use(str)},
-                         
-                            'inverters': {
-                                    'allow_all' : Use(bool),
-                                    And(Use(str), lambda s: len(s) == 16 ): { 
-                                           Optional('node_id',         default=""): And(Use(str),Use(lambda s: s +'/' if len(s)> 0 and s[-1] != '/' else s)), 
-                                           Optional('suggested_area',  default=""): Use(str)
-                                           }}
-                            }, ignore_extra_keys=True)
+                Optional('suggested_area',  default=""): Use(str)
+                }}
+            }, ignore_extra_keys=True
+        )
 
     @classmethod
     def read(cls) -> None:
-        '''Read config file, merge it with the default config and sanitize the result'''
+        '''Read config file, merge it with the default config
+        and sanitize the result'''
 
         config = {}
         logger = logging.getLogger('data')
 
         try:
-            # make the default config transparaent by copying it in the config.example file
+            # make the default config transparaent by copying it
+            # in the config.example file
             shutil.copy2("default_config.toml", "config/config.example.toml")
 
             # read example config file as default configuration
             with open("default_config.toml", "rb") as f:
                 def_config = tomllib.load(f)
 
-            # overwrite the default values, with values from the config.toml file
+            # overwrite the default values, with values from
+            # the config.toml file
             with open("config/config.toml", "rb") as f:
                 usr_config = tomllib.load(f)
- 
-            config['tsun']      = def_config['tsun']      | usr_config['tsun']
-            config['mqtt']      = def_config['mqtt']      | usr_config['mqtt']
-            config['ha']        = def_config['ha']        | usr_config['ha']
-            config['inverters'] = def_config['inverters'] | usr_config['inverters']
+
+            config['tsun'] = def_config['tsun'] | usr_config['tsun']
+            config['mqtt'] = def_config['mqtt'] | usr_config['mqtt']
+            config['ha'] = def_config['ha'] | usr_config['ha']
+            config['inverters'] = def_config['inverters'] | \
+                usr_config['inverters']
 
             cls.config = cls.conf_schema.validate(config)
-            #logging.debug(f'Readed config: "{cls.config}" ')
- 
+            # logging.debug(f'Readed config: "{cls.config}" ')
+
         except Exception as error:
             logger.error(f'Config.read: {error}')
             cls.config = {}
 
     @classmethod
-    def get(cls, member:str = None):
-        '''Get a named attribute from the proxy config. If member == None it returns the complete config dict'''
+    def get(cls, member: str = None):
+        '''Get a named attribute from the proxy config. If member ==
+          None it returns the complete config dict'''
 
         if member:
             return cls.config.get(member, {})
         else:
-            return cls.config
+            return cls.config

app/src/infos.py

@@ -1,255 +1,403 @@
-import struct, json, logging, os
+import struct
+import json
+import logging
+import os
 
 
+class Infos:
+    stat = {}
+    app_name = os.getenv('SERVICE_NAME', 'proxy')
+    version = os.getenv('VERSION', 'unknown')
+
+    @classmethod
+    def static_init(cls):
+        logging.info('Initialize proxy statistics')
+        # init proxy counter in the class.stat dictionary
+        cls.stat['proxy'] = {}
+        for key in cls.__info_defs:
+            name = cls.__info_defs[key]['name']
+            if name[0] == 'proxy':
+                cls.stat['proxy'][name[1]] = 0
+
+        # add values from the environment to the device definition table
+        prxy = cls.__info_devs['proxy']
+        prxy['sw'] = cls.version
+        prxy['mdl'] = cls.app_name
 
-class Infos:    
     def __init__(self):
         self.db = {}
-        self.app_name = os.getenv('SERVICE_NAME', 'proxy')
-        self.version  = os.getenv('VERSION', 'unknown')
         self.tracer = logging.getLogger('data')
 
-    __info_devs={
-        'controller':{                    'name':'Controller',     'mdl':0x00092f90, 'mf':0x000927c0, 'sw':0x00092ba8},
-        'inverter':  {'via':'controller', 'name':'Micro Inverter', 'mdl':0x00000032, 'mf':0x00000014, 'sw':0x0000001e},
-        'input_pv1': {'via':'inverter',   'name':'Module PV1'},
-        'input_pv2': {'via':'inverter',   'name':'Module PV2'},
-        'input_pv3': {'via':'inverter',   'name':'Module PV3'},
-        'input_pv4': {'via':'inverter',   'name':'Module PV4'},
+    __info_devs = {
+        'proxy':      {'singleton': True,   'name': 'Proxy', 'mf': 'Stefan Allius'},  # noqa: E501
+        'controller': {'via': 'proxy',      'name': 'Controller',     'mdl': 0x00092f90, 'mf': 0x000927c0, 'sw': 0x00092ba8},  # noqa: E501
+        'inverter':   {'via': 'controller', 'name': 'Micro Inverter', 'mdl': 0x00000032, 'mf': 0x00000014, 'sw': 0x0000001e},  # noqa: E501
+        'input_pv1':  {'via': 'inverter',   'name': 'Module PV1'},
+        'input_pv2':  {'via': 'inverter',   'name': 'Module PV2', 'dep': {'reg': 0x00013880, 'gte': 2}},  # noqa: E501
+        'input_pv3':  {'via': 'inverter',   'name': 'Module PV3', 'dep': {'reg': 0x00013880, 'gte': 3}},  # noqa: E501
+        'input_pv4':  {'via': 'inverter',   'name': 'Module PV4', 'dep': {'reg': 0x00013880, 'gte': 4}},  # noqa: E501
     }
 
-    __info_defs={
-        # collector values used for device registration:
-            0x00092ba8:  {'name':['collector', 'Collector_Fw_Version'],       'level': logging.INFO,  'unit': ''},
-            0x000927c0:  {'name':['collector', 'Chip_Type'],                  'level': logging.DEBUG, 'unit': ''},
-            0x00092f90:  {'name':['collector', 'Chip_Model'],                 'level': logging.DEBUG, 'unit': ''},
-            0x00095a88:  {'name':['collector', 'Trace_URL'],                  'level': logging.DEBUG, 'unit': ''},
-            0x00095aec:  {'name':['collector', 'Logger_URL'],                 'level': logging.DEBUG, 'unit': ''},
-       
-        # inverter values used for device registration:
-            0x0000000a:  {'name':['inverter', 'Product_Name'],                'level': logging.DEBUG, 'unit': ''},
-            0x00000014:  {'name':['inverter', 'Manufacturer'],                'level': logging.DEBUG, 'unit': ''},
-            0x0000001e:  {'name':['inverter', 'Version'],                     'level': logging.INFO,  'unit': ''},
-            0x00000028:  {'name':['inverter', 'Serial_Number'],               'level': logging.DEBUG, 'unit': ''},
-            0x00000032:  {'name':['inverter', 'Equipment_Model'],             'level': logging.DEBUG, 'unit': ''},
-       
-        # events
-            0x00000191:  {'name':['events', '401_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x00000192:  {'name':['events', '402_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x00000193:  {'name':['events', '403_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x00000194:  {'name':['events', '404_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x00000195:  {'name':['events', '405_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x00000196:  {'name':['events', '406_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x00000197:  {'name':['events', '407_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x00000198:  {'name':['events', '408_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x00000199:  {'name':['events', '409_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x0000019a:  {'name':['events', '410_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x0000019b:  {'name':['events', '411_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x0000019c:  {'name':['events', '412_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x0000019d:  {'name':['events', '413_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x0000019e:  {'name':['events', '414_'],                          'level': logging.DEBUG, 'unit': ''},
-            0x0000019f:  {'name':['events', '415_GridFreqOverRating'],        'level': logging.DEBUG, 'unit': ''},
-            0x000001a0:  {'name':['events', '416_'],                          'level': logging.DEBUG, 'unit': ''},
-        
-        # grid measures:
-            0x000003e8:  {'name':['grid', 'Voltage'],                         'level': logging.DEBUG, 'unit': 'V',    'ha':{'dev':'inverter', 'dev_cla': 'voltage',     'stat_cla': 'measurement', 'id':'out_volt_',  'fmt':'| float','name': 'Grid Voltage'}},
-            0x0000044c:  {'name':['grid', 'Current'],                         'level': logging.DEBUG, 'unit': 'A',    'ha':{'dev':'inverter', 'dev_cla': 'current',     'stat_cla': 'measurement', 'id':'out_cur_',   'fmt':'| float','name': 'Grid Current'}},
-            0x000004b0:  {'name':['grid', 'Frequency'],                       'level': logging.DEBUG, 'unit': 'Hz',   'ha':{'dev':'inverter', 'dev_cla': 'frequency',   'stat_cla': 'measurement', 'id':'out_freq_',  'fmt':'| float','name': 'Grid Frequency'}},
-            0x00000640:  {'name':['grid', 'Output_Power'],                    'level': logging.INFO,  'unit': 'W',    'ha':{'dev':'inverter', 'dev_cla': 'power',       'stat_cla': 'measurement', 'id':'out_power_', 'fmt':'| float','name': 'Power'}},
-            0x000005dc:  {'name':['env',  'Rated_Power'],                     'level': logging.DEBUG, 'unit': 'W',    'ha':{'dev':'inverter', 'dev_cla': 'power',       'stat_cla': 'measurement', 'id':'rated_power_','fmt':'| int', 'name': 'Rated Power'}},
-            0x00000514:  {'name':['env',  'Inverter_Temp'],                   'level': logging.DEBUG, 'unit': '°C',   'ha':{'dev':'inverter', 'dev_cla': 'temperature', 'stat_cla': 'measurement', 'id':'temp_',   'fmt':'| int','name': 'Temperature'}},
+    __comm_type_val_tpl = "{%set com_types = ['n/a','Wi-Fi', 'G4', 'G5', 'GPRS'] %}{{com_types[value_json['Communication_Type']|int(0)]|default(value_json['Communication_Type'])}}"    # noqa: E501
 
-        # input measures:           
-            0x000006a4:  {'name':['input', 'pv1', 'Voltage'],                 'level': logging.DEBUG, 'unit': 'V',    'ha':{'dev':'input_pv1', 'dev_cla': 'voltage', 'stat_cla': 'measurement', 'id':'volt_pv1_', 'name': 'Voltage', 'val_tpl' :"{{ (value_json['pv1']['Voltage'] | float)}}", 'unvisible':1, 'icon':'mdi:gauge'}},
-            0x00000708:  {'name':['input', 'pv1', 'Current'],                 'level': logging.DEBUG, 'unit': 'A',    'ha':{'dev':'input_pv1', 'dev_cla': 'current', 'stat_cla': 'measurement', 'id':'cur_pv1_',  'name': 'Current', 'val_tpl' :"{{ (value_json['pv1']['Current'] | float)}}", 'unvisible':1, 'icon':'mdi:gauge'}},
-            0x0000076c:  {'name':['input', 'pv1', 'Power'],                   'level': logging.INFO,  'unit': 'W',    'ha':{'dev':'input_pv1', 'dev_cla': 'power',   'stat_cla': 'measurement', 'id':'power_pv1_','name': 'Power',   'val_tpl' :"{{ (value_json['pv1']['Power'] | float)}}", 'icon':'mdi:gauge'}},
-            0x000007d0:  {'name':['input', 'pv2', 'Voltage'],                 'level': logging.DEBUG, 'unit': 'V',    'ha':{'dev':'input_pv2', 'dev_cla': 'voltage', 'stat_cla': 'measurement', 'id':'volt_pv2_', 'name': 'Voltage', 'val_tpl' :"{{ (value_json['pv2']['Voltage'] | float)}}", 'unvisible':1, 'icon':'mdi:gauge'}},
-            0x00000834:  {'name':['input', 'pv2', 'Current'],                 'level': logging.DEBUG, 'unit': 'A',    'ha':{'dev':'input_pv2', 'dev_cla': 'current', 'stat_cla': 'measurement', 'id':'cur_pv2_',  'name': 'Current', 'val_tpl' :"{{ (value_json['pv2']['Current'] | float)}}", 'unvisible':1, 'icon':'mdi:gauge'}},
-            0x00000898:  {'name':['input', 'pv2', 'Power'],                   'level': logging.INFO,  'unit': 'W',    'ha':{'dev':'input_pv2', 'dev_cla': 'power',   'stat_cla': 'measurement', 'id':'power_pv2_','name': 'Power',   'val_tpl' :"{{ (value_json['pv2']['Power'] | float)}}", 'icon':'mdi:gauge'}},
-            0x000008fc:  {'name':['input', 'pv3', 'Voltage'],                 'level': logging.DEBUG, 'unit': 'V',    'ha':{'dev':'input_pv3', 'dev_cla': 'voltage', 'stat_cla': 'measurement', 'id':'volt_pv3_', 'name': 'Voltage', 'val_tpl' :"{{ (value_json['pv3']['Voltage'] | float)}}", 'unvisible':1, 'icon':'mdi:gauge'}},
-            0x00000960:  {'name':['input', 'pv3', 'Current'],                 'level': logging.DEBUG, 'unit': 'A',    'ha':{'dev':'input_pv3', 'dev_cla': 'current', 'stat_cla': 'measurement', 'id':'cur_pv3_',  'name': 'Current', 'val_tpl' :"{{ (value_json['pv3']['Current'] | float)}}", 'unvisible':1, 'icon':'mdi:gauge'}},
-            0x000009c4:  {'name':['input', 'pv3', 'Power'],                   'level': logging.DEBUG, 'unit': 'W',    'ha':{'dev':'input_pv3', 'dev_cla': 'power',   'stat_cla': 'measurement', 'id':'power_pv3_','name': 'Power',   'val_tpl' :"{{ (value_json['pv3']['Power'] | float)}}", 'icon':'mdi:gauge'}},
-            0x00000a28:  {'name':['input', 'pv4', 'Voltage'],                 'level': logging.DEBUG, 'unit': 'V',    'ha':{'dev':'input_pv4', 'dev_cla': 'voltage', 'stat_cla': 'measurement', 'id':'volt_pv4_', 'name': 'Voltage', 'val_tpl' :"{{ (value_json['pv4']['Voltage'] | float)}}", 'unvisible':1, 'icon':'mdi:gauge'}},
-            0x00000a8c:  {'name':['input', 'pv4', 'Current'],                 'level': logging.DEBUG, 'unit': 'A',    'ha':{'dev':'input_pv4', 'dev_cla': 'current', 'stat_cla': 'measurement', 'id':'cur_pv4_',  'name': 'Current', 'val_tpl' :"{{ (value_json['pv4']['Current'] | float)}}", 'unvisible':1, 'icon':'mdi:gauge'}},
-            0x00000af0:  {'name':['input', 'pv4', 'Power'],                   'level': logging.DEBUG, 'unit': 'W',    'ha':{'dev':'input_pv4', 'dev_cla': 'power',   'stat_cla': 'measurement', 'id':'power_pv4_','name': 'Power',   'val_tpl' :"{{ (value_json['pv4']['Power'] | float)}}", 'icon':'mdi:gauge'}},
-            0x00000c1c:  {'name':['input', 'pv1', 'Daily_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha':{'dev':'input_pv1', 'dev_cla': 'energy', 'stat_cla': 'total_increasing', 'id':'daily_gen_pv1_','name': 'Daily Generation', 'val_tpl' :"{{ (value_json['pv1']['Daily_Generation'] | float)}}", 'icon':'mdi:solar-power-variant'}},          
-            0x00000c80:  {'name':['input', 'pv1', 'Total_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha':{'dev':'input_pv1', 'dev_cla': 'energy', 'stat_cla': 'total',            'id':'total_gen_pv1_','name': 'Total Generation', 'val_tpl' :"{{ (value_json['pv1']['Total_Generation'] | float)}}", 'icon':'mdi:solar-power'}},                    
-            0x00000ce4:  {'name':['input', 'pv2', 'Daily_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha':{'dev':'input_pv2', 'dev_cla': 'energy', 'stat_cla': 'total_increasing', 'id':'daily_gen_pv2_','name': 'Daily Generation', 'val_tpl' :"{{ (value_json['pv2']['Daily_Generation'] | float)}}", 'icon':'mdi:solar-power-variant'}},          
-            0x00000d48:  {'name':['input', 'pv2', 'Total_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha':{'dev':'input_pv2', 'dev_cla': 'energy', 'stat_cla': 'total',            'id':'total_gen_pv2_','name': 'Total Generation', 'val_tpl' :"{{ (value_json['pv2']['Total_Generation'] | float)}}", 'icon':'mdi:solar-power'}},          
-            0x00000dac:  {'name':['input', 'pv3', 'Daily_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha':{'dev':'input_pv3', 'dev_cla': 'energy', 'stat_cla': 'total_increasing', 'id':'daily_gen_pv3_','name': 'Daily Generation', 'val_tpl' :"{{ (value_json['pv3']['Daily_Generation'] | float)}}", 'icon':'mdi:solar-power-variant'}},          
-            0x00000e10:  {'name':['input', 'pv3', 'Total_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha':{'dev':'input_pv3', 'dev_cla': 'energy', 'stat_cla': 'total',            'id':'total_gen_pv3_','name': 'Total Generation', 'val_tpl' :"{{ (value_json['pv3']['Total_Generation'] | float)}}", 'icon':'mdi:solar-power'}},                    
-            0x00000e74:  {'name':['input', 'pv4', 'Daily_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha':{'dev':'input_pv4', 'dev_cla': 'energy', 'stat_cla': 'total_increasing', 'id':'daily_gen_pv4_','name': 'Daily Generation', 'val_tpl' :"{{ (value_json['pv4']['Daily_Generation'] | float)}}", 'icon':'mdi:solar-power-variant'}},          
-            0x00000ed8:  {'name':['input', 'pv4', 'Total_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha':{'dev':'input_pv4', 'dev_cla': 'energy', 'stat_cla': 'total',            'id':'total_gen_pv4_','name': 'Total Generation', 'val_tpl' :"{{ (value_json['pv4']['Total_Generation'] | float)}}", 'icon':'mdi:solar-power'}},          
-        # total:    
-            0x00000b54:  {'name':['total', 'Daily_Generation'],               'level': logging.INFO,  'unit': 'kWh',  'ha':{'dev':'inverter', 'dev_cla': 'energy', 'stat_cla': 'total_increasing', 'id':'daily_gen_', 'fmt':'| float','name': 'Daily Generation', 'icon':'mdi:solar-power-variant'}},
-            0x00000bb8:  {'name':['total', 'Total_Generation'],               'level': logging.INFO,  'unit': 'kWh',  'ha':{'dev':'inverter', 'dev_cla': 'energy', 'stat_cla': 'total',            'id':'total_gen_', 'fmt':'| float','name': 'Total Generation', 'icon':'mdi:solar-power'}},
+    __info_defs = {
+        # collector values used for device registration:
+        0x00092ba8:  {'name': ['collector', 'Collector_Fw_Version'],       'level': logging.INFO,  'unit': ''},  # noqa: E501
+        0x000927c0:  {'name': ['collector', 'Chip_Type'],                  'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00092f90:  {'name': ['collector', 'Chip_Model'],                 'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00095a88:  {'name': ['collector', 'Trace_URL'],                  'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00095aec:  {'name': ['collector', 'Logger_URL'],                 'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+
+        # inverter values used for device registration:
+        0x0000000a:  {'name': ['inverter', 'Product_Name'],                'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00000014:  {'name': ['inverter', 'Manufacturer'],                'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x0000001e:  {'name': ['inverter', 'Version'],                     'level': logging.INFO,  'unit': ''},  # noqa: E501
+        0x00000028:  {'name': ['inverter', 'Serial_Number'],               'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00000032:  {'name': ['inverter', 'Equipment_Model'],             'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00013880:  {'name': ['inverter', 'No_Inputs'],                   'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+
+        # proxy:
+        0xffffff00:  {'name': ['proxy', 'Inverter_Cnt'],       'singleton': True,   'ha': {'dev': 'proxy', 'comp': 'sensor', 'dev_cla': None, 'stat_cla': None, 'id': 'inv_count_',     'fmt': '| int', 'name': 'Active Inverter Connections',    'icon': 'mdi:counter'}},  # noqa: E501
+        0xffffff01:  {'name': ['proxy', 'Unknown_SNR'],        'singleton': True,   'ha': {'dev': 'proxy', 'comp': 'sensor', 'dev_cla': None, 'stat_cla': None, 'id': 'unknown_snr_',   'fmt': '| int', 'name': 'Unknown Serial No',    'icon': 'mdi:counter', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0xffffff02:  {'name': ['proxy', 'Unknown_Msg'],        'singleton': True,   'ha': {'dev': 'proxy', 'comp': 'sensor', 'dev_cla': None, 'stat_cla': None, 'id': 'unknown_msg_',   'fmt': '| int', 'name': 'Unknown Msg Type',     'icon': 'mdi:counter', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0xffffff03:  {'name': ['proxy', 'Invalid_Data_Type'],  'singleton': True,   'ha': {'dev': 'proxy', 'comp': 'sensor', 'dev_cla': None, 'stat_cla': None, 'id': 'inv_data_type_', 'fmt': '| int', 'name': 'Invalid Data Type',    'icon': 'mdi:counter', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0xffffff04:  {'name': ['proxy', 'Internal_Error'],     'singleton': True,   'ha': {'dev': 'proxy', 'comp': 'sensor', 'dev_cla': None, 'stat_cla': None, 'id': 'intern_err_',    'fmt': '| int', 'name': 'Internal Error',       'icon': 'mdi:counter', 'ent_cat': 'diagnostic', 'en': False}},  # noqa: E501
+        0xffffff05:  {'name': ['proxy', 'Unknown_Ctrl'],       'singleton': True,   'ha': {'dev': 'proxy', 'comp': 'sensor', 'dev_cla': None, 'stat_cla': None, 'id': 'unknown_ctrl_',  'fmt': '| int', 'name': 'Unknown Control Type', 'icon': 'mdi:counter', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0xffffff06:  {'name': ['proxy', 'OTA_Start_Msg'],      'singleton': True,   'ha': {'dev': 'proxy', 'comp': 'sensor', 'dev_cla': None, 'stat_cla': None, 'id': 'ota_start_cmd_', 'fmt': '| int', 'name': 'OTA Start Cmd',        'icon': 'mdi:counter', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0xffffff07:  {'name': ['proxy', 'SW_Exception'],       'singleton': True,   'ha': {'dev': 'proxy', 'comp': 'sensor', 'dev_cla': None, 'stat_cla': None, 'id': 'sw_exception_',  'fmt': '| int', 'name': 'Internal SW Exception', 'icon': 'mdi:counter', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        # 0xffffff03:  {'name':['proxy', 'Voltage'],                        'level': logging.DEBUG, 'unit': 'V',    'ha':{'dev':'proxy', 'dev_cla': 'voltage',     'stat_cla': 'measurement', 'id':'proxy_volt_',  'fmt':'| float','name': 'Grid Voltage'}},  # noqa: E501
+
+        # events
+        0x00000191:  {'name': ['events', '401_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00000192:  {'name': ['events', '402_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00000193:  {'name': ['events', '403_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00000194:  {'name': ['events', '404_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00000195:  {'name': ['events', '405_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00000196:  {'name': ['events', '406_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00000197:  {'name': ['events', '407_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00000198:  {'name': ['events', '408_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x00000199:  {'name': ['events', '409_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x0000019a:  {'name': ['events', '410_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x0000019b:  {'name': ['events', '411_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x0000019c:  {'name': ['events', '412_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x0000019d:  {'name': ['events', '413_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x0000019e:  {'name': ['events', '414_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x0000019f:  {'name': ['events', '415_GridFreqOverRating'],        'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+        0x000001a0:  {'name': ['events', '416_'],                          'level': logging.DEBUG, 'unit': ''},  # noqa: E501
+
+        # grid measures:
+        0x000003e8:  {'name': ['grid', 'Voltage'],                         'level': logging.DEBUG, 'unit': 'V',    'ha': {'dev': 'inverter', 'dev_cla': 'voltage',     'stat_cla': 'measurement', 'id': 'out_volt_',  'fmt': '| float', 'name': 'Grid Voltage', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x0000044c:  {'name': ['grid', 'Current'],                         'level': logging.DEBUG, 'unit': 'A',    'ha': {'dev': 'inverter', 'dev_cla': 'current',     'stat_cla': 'measurement', 'id': 'out_cur_',   'fmt': '| float', 'name': 'Grid Current', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x000004b0:  {'name': ['grid', 'Frequency'],                       'level': logging.DEBUG, 'unit': 'Hz',   'ha': {'dev': 'inverter', 'dev_cla': 'frequency',   'stat_cla': 'measurement', 'id': 'out_freq_',  'fmt': '| float', 'name': 'Grid Frequency', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x00000640:  {'name': ['grid', 'Output_Power'],                    'level': logging.INFO,  'unit': 'W',    'ha': {'dev': 'inverter', 'dev_cla': 'power',       'stat_cla': 'measurement', 'id': 'out_power_', 'fmt': '| float', 'name': 'Power'}},  # noqa: E501
+        0x000005dc:  {'name': ['env',  'Rated_Power'],                     'level': logging.DEBUG, 'unit': 'W',    'ha': {'dev': 'inverter', 'dev_cla': None,          'stat_cla': None,          'id': 'rated_power_', 'fmt': '| string + " W"', 'name': 'Rated Power', 'icon': 'mdi:lightning-bolt', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x00000514:  {'name': ['env',  'Inverter_Temp'],                   'level': logging.DEBUG, 'unit': '°C',   'ha': {'dev': 'inverter', 'dev_cla': 'temperature', 'stat_cla': 'measurement', 'id': 'temp_',       'fmt': '| int', 'name': 'Temperature'}},  # noqa: E501
+
+        # input measures:
+        0x000006a4:  {'name': ['input', 'pv1', 'Voltage'],                 'level': logging.DEBUG, 'unit': 'V',    'ha': {'dev': 'input_pv1', 'dev_cla': 'voltage', 'stat_cla': 'measurement', 'id': 'volt_pv1_',  'val_tpl': "{{ (value_json['pv1']['Voltage'] | float)}}", 'icon': 'mdi:gauge', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x00000708:  {'name': ['input', 'pv1', 'Current'],                 'level': logging.DEBUG, 'unit': 'A',    'ha': {'dev': 'input_pv1', 'dev_cla': 'current', 'stat_cla': 'measurement', 'id': 'cur_pv1_',   'val_tpl': "{{ (value_json['pv1']['Current'] | float)}}", 'icon': 'mdi:gauge', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x0000076c:  {'name': ['input', 'pv1', 'Power'],                   'level': logging.INFO,  'unit': 'W',    'ha': {'dev': 'input_pv1', 'dev_cla': 'power',   'stat_cla': 'measurement', 'id': 'power_pv1_', 'val_tpl': "{{ (value_json['pv1']['Power'] | float)}}"}},  # noqa: E501
+        0x000007d0:  {'name': ['input', 'pv2', 'Voltage'],                 'level': logging.DEBUG, 'unit': 'V',    'ha': {'dev': 'input_pv2', 'dev_cla': 'voltage', 'stat_cla': 'measurement', 'id': 'volt_pv2_',  'val_tpl': "{{ (value_json['pv2']['Voltage'] | float)}}", 'icon': 'mdi:gauge', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x00000834:  {'name': ['input', 'pv2', 'Current'],                 'level': logging.DEBUG, 'unit': 'A',    'ha': {'dev': 'input_pv2', 'dev_cla': 'current', 'stat_cla': 'measurement', 'id': 'cur_pv2_',   'val_tpl': "{{ (value_json['pv2']['Current'] | float)}}", 'icon': 'mdi:gauge', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x00000898:  {'name': ['input', 'pv2', 'Power'],                   'level': logging.INFO,  'unit': 'W',    'ha': {'dev': 'input_pv2', 'dev_cla': 'power',   'stat_cla': 'measurement', 'id': 'power_pv2_', 'val_tpl': "{{ (value_json['pv2']['Power'] | float)}}"}},  # noqa: E501
+        0x000008fc:  {'name': ['input', 'pv3', 'Voltage'],                 'level': logging.DEBUG, 'unit': 'V',    'ha': {'dev': 'input_pv3', 'dev_cla': 'voltage', 'stat_cla': 'measurement', 'id': 'volt_pv3_',  'val_tpl': "{{ (value_json['pv3']['Voltage'] | float)}}", 'icon': 'mdi:gauge', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x00000960:  {'name': ['input', 'pv3', 'Current'],                 'level': logging.DEBUG, 'unit': 'A',    'ha': {'dev': 'input_pv3', 'dev_cla': 'current', 'stat_cla': 'measurement', 'id': 'cur_pv3_',   'val_tpl': "{{ (value_json['pv3']['Current'] | float)}}", 'icon': 'mdi:gauge', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x000009c4:  {'name': ['input', 'pv3', 'Power'],                   'level': logging.DEBUG, 'unit': 'W',    'ha': {'dev': 'input_pv3', 'dev_cla': 'power',   'stat_cla': 'measurement', 'id': 'power_pv3_', 'val_tpl': "{{ (value_json['pv3']['Power'] | float)}}"}},  # noqa: E501
+        0x00000a28:  {'name': ['input', 'pv4', 'Voltage'],                 'level': logging.DEBUG, 'unit': 'V',    'ha': {'dev': 'input_pv4', 'dev_cla': 'voltage', 'stat_cla': 'measurement', 'id': 'volt_pv4_',  'val_tpl': "{{ (value_json['pv4']['Voltage'] | float)}}", 'icon': 'mdi:gauge', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x00000a8c:  {'name': ['input', 'pv4', 'Current'],                 'level': logging.DEBUG, 'unit': 'A',    'ha': {'dev': 'input_pv4', 'dev_cla': 'current', 'stat_cla': 'measurement', 'id': 'cur_pv4_',   'val_tpl': "{{ (value_json['pv4']['Current'] | float)}}", 'icon': 'mdi:gauge', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x00000af0:  {'name': ['input', 'pv4', 'Power'],                   'level': logging.DEBUG, 'unit': 'W',    'ha': {'dev': 'input_pv4', 'dev_cla': 'power',   'stat_cla': 'measurement', 'id': 'power_pv4_', 'val_tpl': "{{ (value_json['pv4']['Power'] | float)}}"}},  # noqa: E501
+        0x00000c1c:  {'name': ['input', 'pv1', 'Daily_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha': {'dev': 'input_pv1', 'dev_cla': 'energy', 'stat_cla': 'total_increasing', 'id': 'daily_gen_pv1_', 'name': 'Daily Generation', 'val_tpl': "{{ (value_json['pv1']['Daily_Generation'] | float)}}", 'icon': 'mdi:solar-power-variant', 'must_incr': True}},  # noqa: E501
+        0x00000c80:  {'name': ['input', 'pv1', 'Total_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha': {'dev': 'input_pv1', 'dev_cla': 'energy', 'stat_cla': 'total',            'id': 'total_gen_pv1_', 'name': 'Total Generation', 'val_tpl': "{{ (value_json['pv1']['Total_Generation'] | float)}}", 'icon': 'mdi:solar-power', 'must_incr': True}},  # noqa: E501
+        0x00000ce4:  {'name': ['input', 'pv2', 'Daily_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha': {'dev': 'input_pv2', 'dev_cla': 'energy', 'stat_cla': 'total_increasing', 'id': 'daily_gen_pv2_', 'name': 'Daily Generation', 'val_tpl': "{{ (value_json['pv2']['Daily_Generation'] | float)}}", 'icon': 'mdi:solar-power-variant', 'must_incr': True}},  # noqa: E501
+        0x00000d48:  {'name': ['input', 'pv2', 'Total_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha': {'dev': 'input_pv2', 'dev_cla': 'energy', 'stat_cla': 'total',            'id': 'total_gen_pv2_', 'name': 'Total Generation', 'val_tpl': "{{ (value_json['pv2']['Total_Generation'] | float)}}", 'icon': 'mdi:solar-power', 'must_incr': True}},  # noqa: E501
+        0x00000dac:  {'name': ['input', 'pv3', 'Daily_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha': {'dev': 'input_pv3', 'dev_cla': 'energy', 'stat_cla': 'total_increasing', 'id': 'daily_gen_pv3_', 'name': 'Daily Generation', 'val_tpl': "{{ (value_json['pv3']['Daily_Generation'] | float)}}", 'icon': 'mdi:solar-power-variant', 'must_incr': True}},  # noqa: E501
+        0x00000e10:  {'name': ['input', 'pv3', 'Total_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha': {'dev': 'input_pv3', 'dev_cla': 'energy', 'stat_cla': 'total',            'id': 'total_gen_pv3_', 'name': 'Total Generation', 'val_tpl': "{{ (value_json['pv3']['Total_Generation'] | float)}}", 'icon': 'mdi:solar-power', 'must_incr': True}},  # noqa: E501
+        0x00000e74:  {'name': ['input', 'pv4', 'Daily_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha': {'dev': 'input_pv4', 'dev_cla': 'energy', 'stat_cla': 'total_increasing', 'id': 'daily_gen_pv4_', 'name': 'Daily Generation', 'val_tpl': "{{ (value_json['pv4']['Daily_Generation'] | float)}}", 'icon': 'mdi:solar-power-variant', 'must_incr': True}},  # noqa: E501
+        0x00000ed8:  {'name': ['input', 'pv4', 'Total_Generation'],        'level': logging.DEBUG, 'unit': 'kWh',  'ha': {'dev': 'input_pv4', 'dev_cla': 'energy', 'stat_cla': 'total',            'id': 'total_gen_pv4_', 'name': 'Total Generation', 'val_tpl': "{{ (value_json['pv4']['Total_Generation'] | float)}}", 'icon': 'mdi:solar-power', 'must_incr': True}},  # noqa: E501
+        # total:
+        0x00000b54:  {'name': ['total', 'Daily_Generation'],               'level': logging.INFO,  'unit': 'kWh',  'ha': {'dev': 'inverter', 'dev_cla': 'energy', 'stat_cla': 'total_increasing', 'id': 'daily_gen_', 'fmt': '| float', 'name': 'Daily Generation', 'icon': 'mdi:solar-power-variant', 'must_incr': True}},  # noqa: E501
+        0x00000bb8:  {'name': ['total', 'Total_Generation'],               'level': logging.INFO,  'unit': 'kWh',  'ha': {'dev': 'inverter', 'dev_cla': 'energy', 'stat_cla': 'total',            'id': 'total_gen_', 'fmt': '| float', 'name': 'Total Generation', 'icon': 'mdi:solar-power', 'must_incr': True}},  # noqa: E501
 
         # controller:
-            0x000c3500:  {'name':['controller', 'Signal_Strength'],           'level': logging.DEBUG, 'unit': '%' ,  'ha':{'dev':'controller', 'dev_cla': None,       'stat_cla': 'measurement', 'id':'signal_',         'fmt':'| int', 'name': 'Signal Strength', 'icon':'mdi:wifi'}},
-            0x000c96a8:  {'name':['controller', 'Power_On_Time'],             'level': logging.DEBUG, 'unit': 's',   'ha':{'dev':'controller', 'dev_cla': 'duration', 'stat_cla': 'measurement', 'id':'power_on_time_',                 'name': 'Power on Time',   'val_tpl':"{{ (value_json['Power_On_Time'] | float)}}", 'nat_prc':'3'}},
-            0x000cf850:  {'name':['controller', 'Data_Up_Interval'],          'level': logging.DEBUG, 'unit': 's',   'ha':{'dev':'controller', 'dev_cla': None,       'stat_cla': 'measurement', 'id':'data_up_intval_', 'fmt':'| int', 'name': 'Data Up Interval', 'icon':'mdi:update'}},
+        0x000c3500:  {'name': ['controller', 'Signal_Strength'],           'level': logging.DEBUG, 'unit': '%',    'ha': {'dev': 'controller', 'dev_cla': None,       'stat_cla': 'measurement', 'id': 'signal_',              'fmt': '| int',           'name': 'Signal Strength', 'icon': 'mdi:wifi'}},  # noqa: E501
+        0x000c96a8:  {'name': ['controller', 'Power_On_Time'],             'level': logging.DEBUG, 'unit': 's',    'ha': {'dev': 'controller', 'dev_cla': 'duration', 'stat_cla': 'measurement', 'id': 'power_on_time_',       'fmt': '| float',         'name': 'Power on Time', 'nat_prc': '3', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x000d0020:  {'name': ['controller', 'Collect_Interval'],          'level': logging.DEBUG, 'unit': 's',    'ha': {'dev': 'controller', 'dev_cla': None,       'stat_cla': None,          'id': 'data_collect_intval_', 'fmt': '| string + " s"', 'name': 'Data Collect Interval', 'icon': 'mdi:update', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x000cfc38:  {'name': ['controller', 'Connect_Count'],             'level': logging.DEBUG, 'unit': '',     'ha': {'dev': 'controller', 'dev_cla': None,       'stat_cla': None,          'id': 'connect_count_',       'fmt': '| int',           'name': 'Connect Count',    'icon': 'mdi:counter', 'comp': 'sensor', 'ent_cat': 'diagnostic'}},  # noqa: E501
+        0x000c7f38:  {'name': ['controller', 'Communication_Type'],        'level': logging.DEBUG, 'unit': '',     'ha': {'dev': 'controller', 'dev_cla': None,       'stat_cla': None,          'id': 'comm_type_',           'name': 'Communication Type', 'val_tpl': __comm_type_val_tpl, 'comp': 'sensor', 'icon': 'mdi:wifi'}},  # noqa: E501
+        # 0x000c7f38:  {'name': ['controller', 'Communication_Type'],        'level': logging.DEBUG, 'unit': 's',    'new_value': 5},  # noqa: E501
+        0x000cf850:  {'name': ['controller', 'Data_Up_Interval'],          'level': logging.DEBUG, 'unit': 's',    'ha': {'dev': 'controller', 'dev_cla': None,       'stat_cla': None,          'id': 'data_up_intval_', 'fmt': '| string + " s"', 'name': 'Data Up Interval', 'icon': 'mdi:update', 'ent_cat': 'diagnostic'}},  # noqa: E501
 
-    }          
-                                    
-    def dev_value(self, idx:str|int) -> str|int|float|None:
+    }
+
+    def dev_value(self, idx: str | int) -> str | int | float | None:
         '''returns the stored device value from our database
 
-        idx:int ==> lookup the value in the database and return it as str, int or flout. If the value is not available return 'None'
-        idx:str ==> returns the string as a fixed value without a database loopup  
+        idx:int ==> lookup the value in the database and return it as str,
+                    int or flout. If the value is not available return 'None'
+        idx:str ==> returns the string as a fixed value without a
+                    database loopup
         '''
-        if type (idx) is str:
-            return idx               # return idx as a fixed value 
+        if type(idx) is str:
+            return idx               # return idx as a fixed value
         elif idx in self.__info_defs:
-            dict = self.db
             row = self.__info_defs[idx]
+            if 'singleton' in row and row['singleton']:
+                dict = self.stat
+            else:
+                dict = self.db
+
             keys = row['name']
 
             for key in keys:
                 if key not in dict:
                     return None      # value not found in the database
                 dict = dict[key]
-            return dict              # value of the reqeusted entry   
-            
+            return dict              # value of the reqeusted entry
+
         return None                  # unknwon idx, not in __info_defs
 
+    def ignore_this_device(self, dep: dict) -> bool:
+        '''Checks the equation in the dep dict
 
-    def ha_confs(self, prfx="tsun/garagendach/", snr='123', sug_area =''):
-        '''Generator function yields a json register struct for home-assistant auto configuration and a unique entity string
+            returns 'False' only if the equation is valid;
+                    'True'  in any other case'''
+        if 'reg' in dep:
+            value = self.dev_value(dep['reg'])
+            if not value:
+                return True
+
+            if 'gte' in dep:
+                return not value >= dep['gte']
+            elif 'less_eq' in dep:
+                return not value <= dep['less_eq']
+        return True
+
+    def ha_confs(self, ha_prfx, node_id, snr,  singleton: bool, sug_area=''):
+        '''Generator function yields a json register struct for home-assistant
+        auto configuration and a unique entity string
 
         arguments:
         prfx:str     ==> MQTT prefix for the home assistant 'stat_t string
-        snr:str      ==> serial number of the inverter, used to build unique entity strings
+        snr:str      ==> serial number of the inverter, used to build unique
+                         entity strings
         sug_area:str ==> suggested area string from the config file'''
         tab = self.__info_defs
         for key in tab:
             row = tab[key]
+            if 'singleton' in row:
+                if singleton != row['singleton']:
+                    continue
+            elif singleton:
+                continue
+            prfx = ha_prfx + node_id
 
-            #check if we have details for home assistant
+            # check if we have details for home assistant
             if 'ha' in row:
                 ha = row['ha']
                 if 'comp' in ha:
                     component = ha['comp']
                 else:
                     component = 'sensor'
-                attr = {}                                     # dict to collect all the sensor entity details 
+                attr = {}
                 if 'name' in ha:
-                    attr['name']   = ha['name']               # take the entity name from the ha dict
-                else:                 
-                    attr['name']   = row['name'][-1]          # otherwise take a name from the name array 
+                    attr['name'] = ha['name']
+                else:
+                    attr['name'] = row['name'][-1]
 
-                attr['stat_t'] = prfx +row['name'][0]         # eg.  'stat_t': "tsun/garagendach/grid"
-                attr['dev_cla']  = ha['dev_cla']              # eg.  'dev_cla': 'power'
-                attr['stat_cla'] = ha['stat_cla']             # eg.  'stat_cla': "measurement"
-                attr['uniq_id']  = ha['id']+snr               # build the 'uniq_id' from the id str + the serial no of the inverter
+                attr['stat_t'] = prfx + row['name'][0]
+                attr['dev_cla'] = ha['dev_cla']
+                attr['stat_cla'] = ha['stat_cla']
+                attr['uniq_id'] = ha['id']+snr
                 if 'val_tpl' in ha:
-                    attr['val_tpl']  = ha['val_tpl']          # get value template for complexe data structures
+                    attr['val_tpl'] = ha['val_tpl']
                 elif 'fmt' in ha:
-                    attr['val_tpl']  = '{{value_json' + f"['{row['name'][-1]}'] {ha['fmt']}" + '}}'       # eg.   'val_tpl': "{{ value_json['Output_Power']|float }}"
+                    attr['val_tpl'] = '{{value_json' + f"['{row['name'][-1]}'] {ha['fmt']}" + '}}'       # eg.   'val_tpl': "{{ value_json['Output_Power']|float }} # noqa: E501
+                else:
+                    self.inc_counter('Internal_Error')
+                    logging.error(f"Infos.__info_defs: the row for {key} do"
+                                  " not have a 'val_tpl' nor a 'fmt' value")
 
-                if 'unit' in row:
-                    attr['unit_of_meas'] = row['unit']        # optional add a 'unit_of_meas' e.g. 'W'
+                # add unit_of_meas only, if status_class isn't none. If
+                # status_cla is None we want a number format and not line
+                # graph in home assistant. A unit will change the number
+                # format to a line graph
+                if 'unit' in row and attr['stat_cla'] is not None:
+                    attr['unit_of_meas'] = row['unit']  # 'unit_of_meas'
                 if 'icon' in ha:
-                    attr['icon'] = ha['icon']                 # optional add an icon for the entity
+                    attr['ic'] = ha['icon']             # icon for the entity
                 if 'nat_prc' in ha:
-                    attr['sug_dsp_prc'] = ha['nat_prc']     # optional add the precison of floats
-                    
-                # eg. 'dev':{'name':'Microinverter','mdl':'MS-600','ids':["inverter_123"],'mf':'TSUN','sa': 'auf Garagendach'}
-                # attr['dev'] = {'name':'Microinverter','mdl':'MS-600','ids':[f'inverter_{snr}'],'mf':'TSUN','sa': 'auf Garagendach'}   
+                    attr['sug_dsp_prc'] = ha['nat_prc']  # precison of floats
+                if 'ent_cat' in ha:
+                    attr['ent_cat'] = ha['ent_cat']     # diagnostic, config
+
+                # enabled_by_default is deactivated, since it avoid the via
+                # setup of the devices. It seems, that there is a bug in home
+                # assistant. tested with 'Home Assistant 2023.10.4'
+                # if 'en' in ha:                       # enabled_by_default
+                #    attr['en'] = ha['en']
+
                 if 'dev' in ha:
                     device = self.__info_devs[ha['dev']]
+
+                    if 'dep' in device and self.ignore_this_device(device['dep']):  # noqa: E501
+                        continue
+
                     dev = {}
 
-                    # the same name fpr 'name' and 'suggested area', so we get dedicated devices in home assistant with short value name and headline 
-                    if 'name' in device:
+                    # the same name for 'name' and 'suggested area', so we get
+                    # dedicated devices in home assistant with short value
+                    # name and headline
+                    if (sug_area == '' or
+                            ('singleton' in device and device['singleton'])):
                         dev['name'] = device['name']
-                        dev['sa']   = device['name']
-                    # fixme: we ignore the suggested area, since one area make no sense for multiple devices    
-                    #else:    
-                    #    dev['name'] = sug_area  
-                    #    dev['sa']   = sug_area
+                        dev['sa'] = device['name']
+                    else:
+                        dev['name'] = device['name']+' - '+sug_area
+                        dev['sa'] = device['name']+' - '+sug_area
 
-                    if 'via' in device:                       # add the link to the parent device
-                        dev['via_device'] = f"{device['via']}_{snr}"
+                    if 'via' in device:  # add the link to the parent device
+                        via = device['via']
+                        if via in self.__info_devs:
+                            via_dev = self.__info_devs[via]
+                            if 'singleton' in via_dev and via_dev['singleton']:
+                                dev['via_device'] = via
+                            else:
+                                dev['via_device'] = f"{via}_{snr}"
+                        else:
+                            self.inc_counter('Internal_Error')
+                            logging.error(f"Infos.__info_defs: the row for "
+                                          f"{key} has an invalid via value: "
+                                          f"{via}")
 
-                    for key in ('mdl','mf', 'sw', 'hw'):      # add optional values fpr 'modell', 'manufaturer', 'sw version' and 'hw version'
+                    for key in ('mdl', 'mf', 'sw', 'hw'):      # add optional
+                        # values fpr 'modell', 'manufacturer', 'sw version' and
+                        # 'hw version'
                         if key in device:
                             data = self.dev_value(device[key])
-                            if data is not None: dev[key]  = data
+                            if data is not None:
+                                dev[key] = data
+
+                    if 'singleton' in device and device['singleton']:
+                        dev['ids'] = [f"{ha['dev']}"]
+                    else:
+                        dev['ids'] = [f"{ha['dev']}_{snr}"]
 
-                    dev['ids']  = [f"{ha['dev']}_{snr}"]
                     attr['dev'] = dev
 
                     origin = {}
                     origin['name'] = self.app_name
                     origin['sw'] = self.version
                     attr['o'] = origin
+                else:
+                    self.inc_counter('Internal_Error')
+                    logging.error(f"Infos.__info_defs: the row for {key} "
+                                  "missing 'dev' value for ha register")
 
+                yield json.dumps(attr), component, node_id, attr['uniq_id']
 
-                yield json.dumps (attr), component, attr['uniq_id']
-   
+    def inc_counter(self, counter: str) -> None:
+        '''inc proxy statistic counter'''
+        dict = self.stat['proxy']
+        dict[counter] += 1
 
+    def dec_counter(self, counter: str) -> None:
+        '''dec proxy statistic counter'''
+        dict = self.stat['proxy']
+        dict[counter] -= 1
 
-                                        
-                                  
-    
     def __key_obj(self, id) -> list:
-        d = self.__info_defs.get(id, {'name': None, 'level': logging.DEBUG, 'unit': ''})
-        return d['name'], d['level'], d['unit']
-    
-    
-    def parse(self, buf) -> None:
-        '''parse a data sequence received from the inverter and stores the values in Infos.db
-        
+        d = self.__info_defs.get(id, {'name': None, 'level': logging.DEBUG,
+                                      'unit': ''})
+        if 'ha' in d and 'must_incr' in d['ha']:
+            must_incr = d['ha']['must_incr']
+        else:
+            must_incr = False
+        new_val = None
+        # if 'new_value' in d:
+        #     new_val = d['new_value']
+
+        return d['name'], d['level'], d['unit'], must_incr, new_val
+
+    def parse(self, buf, ind=0) -> None:
+        '''parse a data sequence received from the inverter and
+        stores the values in Infos.db
+
         buf: buffer of the sequence to parse'''
-        result = struct.unpack_from('!l', buf, 0)
+        result = struct.unpack_from('!l', buf, ind)
         elms = result[0]
         i = 0
-        ind = 4
+        ind += 4
         while i < elms:
             result = struct.unpack_from('!lB', buf, ind)
-            info_id   = result[0]             
+            info_id = result[0]
             data_type = result[1]
             ind += 5
-            keys, level, unit = self.__key_obj(info_id)
-            
-            if data_type==0x54:   # 'T' -> Pascal-String
+            keys, level, unit, must_incr, new_val = self.__key_obj(info_id)
+
+            if data_type == 0x54:   # 'T' -> Pascal-String
                 str_len = buf[ind]
-                result = struct.unpack_from(f'!{str_len+1}p', buf, ind)[0].decode(encoding='ascii', errors='replace')
+                result = struct.unpack_from(f'!{str_len+1}p', buf,
+                                            ind)[0].decode(encoding='ascii',
+                                                           errors='replace')
                 ind += str_len+1
-            
-            elif data_type==0x49: # 'I' -> int32
-                result = struct.unpack_from(f'!l', buf, ind)[0]
+
+            elif data_type == 0x49:  # 'I' -> int32
+                # if new_val:
+                #    struct.pack_into('!l', buf, ind, new_val)
+                result = struct.unpack_from('!l', buf, ind)[0]
                 ind += 4
 
-            elif data_type==0x53: # 'S' -> short
-                result = struct.unpack_from(f'!h', buf, ind)[0]
+            elif data_type == 0x53:  # 'S' -> short
+                # if new_val:
+                #     struct.pack_into('!h', buf, ind, new_val)
+                result = struct.unpack_from('!h', buf, ind)[0]
                 ind += 2
 
-            elif data_type==0x46: # 'F' -> float32
-                result = round(struct.unpack_from(f'!f', buf, ind)[0],2)
+            elif data_type == 0x46:  # 'F' -> float32
+                # if new_val:
+                #     struct.pack_into('!f', buf, ind, new_val)
+                result = round(struct.unpack_from('!f', buf, ind)[0], 2)
                 ind += 4
 
+            elif data_type == 0x4c:  # 'L' -> int64
+                # if new_val:
+                #     struct.pack_into('!q', buf, ind, new_val)
+                result = struct.unpack_from('!q', buf, ind)[0]
+                ind += 8
+
+            else:
+                self.inc_counter('Invalid_Data_Type')
+                logging.error(f"Infos.parse: data_type: {data_type}"
+                              " not supported")
+                return
 
             if keys:
                 dict = self.db
                 name = ''
-            
+
                 for key in keys[:-1]:
                     if key not in dict:
                         dict[key] = {}
                     dict = dict[key]
                     name += key + '.'
 
-                update = keys[-1] not in dict or dict[keys[-1]] != result
-                dict[keys[-1]] = result
-                name += keys[-1]
-                yield keys[0], update    
-            else:
-                update = False    
-                name = str(f'info-id.0x{info_id:x}')
-            
-            self.tracer.log(level, f'{name} : {result}{unit}')
- 
-            i +=1
+                if keys[-1] not in dict:
+                    update = (not must_incr or result > 0)
+                else:
+                    if must_incr:
+                        update = dict[keys[-1]] < result
+                    else:
+                        update = dict[keys[-1]] != result
 
-   
+                if update:
+                    dict[keys[-1]] = result
+                name += keys[-1]
+                yield keys[0], update
+            else:
+                update = False
+                name = str(f'info-id.0x{info_id:x}')
+
+            self.tracer.log(level, f'{name} : {result}{unit}'
+                            f'  update: {update}')
+
+            i += 1

app/src/inverter.py

@@ -1,103 +1,216 @@
-import asyncio, logging, traceback, json
+import asyncio
+import logging
+import traceback
+import json
 from config import Config
 from async_stream import AsyncStream
 from mqtt import Mqtt
-#import gc
+from aiomqtt import MqttCodeError
+from infos import Infos
 
-logger = logging.getLogger('conn')
+# import gc
 
+# logger = logging.getLogger('conn')
+logger_mqtt = logging.getLogger('mqtt')
 
 
 class Inverter(AsyncStream):
+    '''class Inverter is a derivation of an Async_Stream
+
+    The class has some class method for managing common resources like a
+    connection to the MQTT broker or proxy error counter which are common
+    for all inverter connection
+
+    Instances of the class are connections to an inverter and can have an
+    optional link to an remote connection to the TSUN cloud. A remote
+    connection dies with the inverter connection.
+
+    class methods:
+        class_init():  initialize the common resources of the proxy (MQTT
+                       broker, Proxy DB, etc). Must be called before the
+                       first inverter instance can be created
+        class_close(): release the common resources of the proxy. Should not
+                       be called before any instances of the class are
+                       destroyed
+
+    methods:
+        server_loop(addr): Async loop method for receiving messages from the
+                           inverter (server-side)
+        client_loop(addr): Async loop method for receiving messages from the
+                           TSUN cloud (client-side)
+        async_create_remote(): Establish a client connection to the TSUN cloud
+        async_publ_mqtt(): Publish data to MQTT broker
+        close(): Release method which must be called before a instance can be
+                 destroyed
+    '''
+    @classmethod
+    def class_init(cls) -> None:
+        logging.debug('Inverter.class_init')
+        # initialize the proxy statistics
+        Infos.static_init()
+        cls.db_stat = Infos()
 
-    def __init__ (self, reader, writer, addr):
-        super().__init__(reader, writer, addr, None, True)
-        self.mqtt = Mqtt()
-        self.ha_restarts = 0
         ha = Config.get('ha')
-        self.entitiy_prfx = ha['entity_prefix'] + '/'
-        self.discovery_prfx = ha['discovery_prefix'] + '/'
+        cls.entity_prfx = ha['entity_prefix'] + '/'
+        cls.discovery_prfx = ha['discovery_prefix'] + '/'
+        cls.proxy_node_id = ha['proxy_node_id'] + '/'
+        cls.proxy_unique_id = ha['proxy_unique_id']
 
+        # call Mqtt singleton to establisch the connection to the mqtt broker
+        cls.mqtt = Mqtt(cls.__cb_mqtt_is_up)
+
+    @classmethod
+    async def __cb_mqtt_is_up(cls) -> None:
+        logging.info('Initialize proxy device on home assistant')
+        # register proxy status counters at home assistant
+        await cls.__register_proxy_stat_home_assistant()
+
+        # send values of the proxy status counters
+        await asyncio.sleep(0.5)            # wait a bit, before sending data
+        cls.new_stat_data['proxy'] = True   # force sending data to sync ha
+        await cls.__async_publ_mqtt_proxy_stat('proxy')
+
+    @classmethod
+    async def __register_proxy_stat_home_assistant(cls) -> None:
+        '''register all our topics at home assistant'''
+        for data_json, component, node_id, id in cls.db_stat.ha_confs(
+                 cls.entity_prfx, cls.proxy_node_id,
+                 cls.proxy_unique_id, True):
+            logger_mqtt.debug(f"MQTT Register: cmp:'{component}' node_id:'{node_id}' {data_json}")      # noqa: E501
+            await cls.mqtt.publish(f'{cls.discovery_prfx}{component}/{node_id}{id}/config', data_json)  # noqa: E501
+
+    @classmethod
+    async def __async_publ_mqtt_proxy_stat(cls, key) -> None:
+        stat = Infos.stat
+        if key in stat and cls.new_stat_data[key]:
+            data_json = json.dumps(stat[key])
+            node_id = cls.proxy_node_id
+            logger_mqtt.debug(f'{key}: {data_json}')
+            await cls.mqtt.publish(f"{cls.entity_prfx}{node_id}{key}",
+                                   data_json)
+            cls.new_stat_data[key] = False
+
+    @classmethod
+    def class_close(cls, loop) -> None:
+        logging.debug('Inverter.class_close')
+        logging.info('Close MQTT Task')
+        loop.run_until_complete(cls.mqtt.close())
+        cls.mqtt = None
+
+    def __init__(self, reader, writer, addr):
+        super().__init__(reader, writer, addr, None, True)
+        self.ha_restarts = -1
 
     async def server_loop(self, addr):
         '''Loop for receiving messages from the inverter (server-side)'''
-        logger.info(f'Accept connection from  {addr}')        
+        logging.info(f'Accept connection from  {addr}')
+        self.inc_counter('Inverter_Cnt')
         await self.loop()
-        logging.info(f'Server loop stopped for {addr}')
-        
-        # if the server connection closes, we also have to disconnect the connection to te TSUN cloud
+        self.dec_counter('Inverter_Cnt')
+        logging.info(f'Server loop stopped for r{self.r_addr}')
+
+        # if the server connection closes, we also have to disconnect
+        # the connection to te TSUN cloud
         if self.remoteStream:
-            logging.debug ("disconnect client connection")
+            logging.debug("disconnect client connection")
             self.remoteStream.disc()
-        
+        try:
+            await self.__async_publ_mqtt_proxy_stat('proxy')
+        except Exception:
+            pass
+
     async def client_loop(self, addr):
         '''Loop for receiving messages from the TSUN cloud (client-side)'''
-        await self.remoteStream.loop()    
-        logging.info(f'Client loop stopped for {addr}')
+        clientStream = await self.remoteStream.loop()
+        logging.info(f'Client loop stopped for l{clientStream.l_addr}')
+
+        # if the client connection closes, we don't touch the server
+        # connection. Instead we erase the client connection stream,
+        # thus on the next received packet from the inverter, we can
+        # establish a new connection to the TSUN cloud
+
+        # erase backlink to inverter
+        clientStream.remoteStream = None
+
+        if self.remoteStream == clientStream:
+            # logging.debug(f'Client l{clientStream.l_addr} refs:'
+            #               f' {gc.get_referrers(clientStream)}')
+            # than erase client connection
+            self.remoteStream = None
 
-        # if the client connection closes, we don't touch the server connection. Instead we erase the client
-        # connection stream, thus on the next received packet from the inverter, we can establish a new connection 
-        # to the TSUN cloud
-        self.remoteStream.remoteStream = None    # erase backlink to inverter instance
-        self.remoteStream = None                 # than erase client connection 
-        
     async def async_create_remote(self) -> None:
         '''Establish a client connection to the TSUN cloud'''
         tsun = Config.get('tsun')
         host = tsun['host']
-        port = tsun['port']     
+        port = tsun['port']
         addr = (host, port)
-            
+
         try:
             logging.info(f'Connected to {addr}')
             connect = asyncio.open_connection(host, port)
-            reader, writer = await connect    
-            self.remoteStream = AsyncStream(reader, writer, addr, self, False)
+            reader, writer = await connect
+            self.remoteStream = AsyncStream(reader, writer, addr, self,
+                                            False, self.id_str)
             asyncio.create_task(self.client_loop(addr))
-            
+
         except ConnectionRefusedError as error:
             logging.info(f'{error}')
         except Exception:
+            self.inc_counter('SW_Exception')
             logging.error(
                 f"Inverter: Exception for {addr}:\n"
                 f"{traceback.format_exc()}")
-        
-    
 
     async def async_publ_mqtt(self) -> None:
-        '''puplish data to MQTT broker'''
-        db = self.db.db
-        # check if new inverter or collector infos are available or when the home assistant has changed the status back to online
-        if (('inverter' in self.new_data and self.new_data['inverter']) or 
-             ('collector' in self.new_data and self.new_data['collector']) or
-               self.mqtt.ha_restarts != self.ha_restarts):
-            await self.__register_home_assistant()
-            self.ha_restarts = self.mqtt.ha_restarts
-
-        for key in self.new_data:
-            if self.new_data[key] and key in db:
-                data_json = json.dumps(db[key])
-                logger.info(f'{key}: {data_json}')
-                await self.mqtt.publish(f"{self.entitiy_prfx}{self.node_id}{key}", data_json)
-                self.new_data[key] = False
-
-    async def __register_home_assistant(self) -> None:
-        '''register all our topics at home assistant'''
+        '''publish data to MQTT broker'''
+        # check if new inverter or collector infos are available or when the
+        #  home assistant has changed the status back to online
         try:
-            for data_json, component, id in self.db.ha_confs(self.entitiy_prfx + self.node_id, self.unique_id, self.sug_area):
-                    #logger.debug(f'MQTT Register: {data_json}')                                
-                    await self.mqtt.publish(f"{self.discovery_prfx}{component}/{self.node_id}{id}/config", data_json)
+            if (('inverter' in self.new_data and self.new_data['inverter'])
+                    or ('collector' in self.new_data and
+                        self.new_data['collector'])
+                    or self.mqtt.ha_restarts != self.ha_restarts):
+                await self.__register_proxy_stat_home_assistant()
+                await self.__register_home_assistant()
+                self.ha_restarts = self.mqtt.ha_restarts
+
+            for key in self.new_data:
+                await self.__async_publ_mqtt_packet(key)
+            for key in self.new_stat_data:
+                await self.__async_publ_mqtt_proxy_stat(key)
+
+        except MqttCodeError as error:
+            logging.error(f'Mqtt except: {error}')
         except Exception:
+            self.inc_counter('SW_Exception')
             logging.error(
                 f"Inverter: Exception:\n"
                 f"{traceback.format_exc()}")
-            
+
+    async def __async_publ_mqtt_packet(self, key):
+        db = self.db.db
+        if key in db and self.new_data[key]:
+            data_json = json.dumps(db[key])
+            node_id = self.node_id
+            logger_mqtt.debug(f'{key}: {data_json}')
+            await self.mqtt.publish(f'{self.entity_prfx}{node_id}{key}', data_json)  # noqa: E501
+            self.new_data[key] = False
+
+    async def __register_home_assistant(self) -> None:
+        '''register all our topics at home assistant'''
+        for data_json, component, node_id, id in self.db.ha_confs(
+                self.entity_prfx, self.node_id, self.unique_id,
+                False, self.sug_area):
+            logger_mqtt.debug(f"MQTT Register: cmp:'{component}'"
+                              f" node_id:'{node_id}' {data_json}")
+            await self.mqtt.publish(f"{self.discovery_prfx}{component}"
+                                    f"/{node_id}{id}/config", data_json)
+
     def close(self) -> None:
-        logging.debug(f'Inverter.close() {self.addr}')
+        logging.debug(f'Inverter.close() l{self.l_addr} | r{self.r_addr}')
         super().close()         # call close handler in the parent class
 #        logger.debug (f'Inverter refs: {gc.get_referrers(self)}')
 
-
-    def __del__ (self):
-        logging.debug ("Inverter.__del__")
-        super().__del__()  
+    def __del__(self):
+        logging.debug("Inverter.__del__")
+        super().__del__()

app/src/logging.ini

@@ -11,30 +11,32 @@ keys=console_formatter,file_formatter
 level=DEBUG
 handlers=console_handler,file_handler_name1
 
-[logger_mesg]
-level=DEBUG
-handlers=console_handler,file_handler_name1,file_handler_name2
-propagate=0
-qualname=msg
 
 [logger_conn]
 level=DEBUG
-handlers=console_handler,file_handler_name1,file_handler_name2
+handlers=console_handler,file_handler_name1
 propagate=0
 qualname=conn
 
-[logger_data]
-level=DEBUG
-handlers=file_handler_name1,file_handler_name2
-propagate=0
-qualname=data
-
 [logger_mqtt]
 level=INFO
 handlers=console_handler,file_handler_name1
 propagate=0
 qualname=mqtt
 
+[logger_data]
+level=DEBUG
+handlers=file_handler_name1
+propagate=0
+qualname=data
+
+
+[logger_mesg]
+level=DEBUG
+handlers=file_handler_name2
+propagate=0
+qualname=msg
+
 [logger_tracer]
 level=INFO
 handlers=file_handler_name2
@@ -60,9 +62,9 @@ args=('log/trace.log', when:='midnight')
 
 [formatter_console_formatter]
 format=%(asctime)s %(levelname)5s | %(name)4s | %(message)s'
-datefmt='%d-%m-%Y %H:%M:%S
+datefmt='%Y-%m-%d %H:%M:%S
 
 [formatter_file_formatter]
 format=%(asctime)s %(levelname)5s | %(name)4s | %(message)s'
-datefmt='%d-%m-%Y %H:%M:%S
+datefmt='%Y-%m-%d %H:%M:%S
 

app/src/messages.py

@@ -1,30 +1,26 @@
-import struct, logging, time, datetime
-import weakref
+import struct
+import logging
+import time
 from datetime import datetime
+import weakref
 
 if __name__ == "app.src.messages":
     from app.src.infos import Infos
     from app.src.config import Config
-else:
+else:  # pragma: no cover
     from infos import Infos
     from config import Config
 
 logger = logging.getLogger('msg')
-    
-        
+
+
 def hex_dump_memory(level, info, data, num):
-    s = ''
     n = 0
     lines = []
     lines.append(info)
     tracer = logging.getLogger('tracer')
-    if not tracer.isEnabledFor(level): return
-
-
-    #data = list((num * ctypes.c_byte).from_address(ptr))
-
-    if len(data) == 0:
-        return '<empty>'
+    if not tracer.isEnabledFor(level):
+        return
 
     for i in range(0, num, 16):
         line = '  '
@@ -32,131 +28,198 @@ def hex_dump_memory(level, info, data, num):
         n += 16
 
         for j in range(n-16, n):
-            if j >= len(data): break
+            if j >= len(data):
+                break
             line += '%02x ' % abs(data[j])
 
         line += ' ' * (3 * 16 + 9 - len(line)) + ' | '
 
         for j in range(n-16, n):
-            if j >= len(data): break
+            if j >= len(data):
+                break
             c = data[j] if not (data[j] < 0x20 or data[j] > 0x7e) else '.'
             line += '%c' % c
 
         lines.append(line)
 
     tracer.log(level, '\n'.join(lines))
-        
-    #return '\n'.join(lines)
 
 
 class Control:
-    def __init__(self, ctrl:int):
+    def __init__(self, ctrl: int):
         self.ctrl = ctrl
-    
+
     def __int__(self) -> int:
         return self.ctrl
 
     def is_ind(self) -> bool:
-        return not (self.ctrl & 0x08)
-    
-    #def is_req(self) -> bool:
-    #    return not (self.ctrl & 0x08)
-    
+        return (self.ctrl == 0x91)
+
+    def is_req(self) -> bool:
+        return (self.ctrl == 0x70)
+
     def is_resp(self) -> bool:
-        return self.ctrl & 0x08
+        return (self.ctrl == 0x99)
+
 
 class IterRegistry(type):
     def __iter__(cls):
         for ref in cls._registry:
             obj = ref()
-            if obj is not None: yield obj
+            if obj is not None:
+                yield obj
 
 
 class Message(metaclass=IterRegistry):
     _registry = []
+    new_stat_data = {}
 
-    def __init__(self):
+    def __init__(self, server_side: bool, id_str=b''):
         self._registry.append(weakref.ref(self))
+        self.server_side = server_side
         self.header_valid = False
         self.header_len = 0
         self.data_len = 0
-        self._recv_buffer = b''
+        self.unique_id = 0
+        self.node_id = ''
+        self.sug_area = ''
+        self.await_conn_resp_cnt = 0
+        self.id_str = id_str
+        self.contact_name = b''
+        self.contact_mail = b''
+        self._recv_buffer = bytearray(0)
         self._send_buffer = bytearray(0)
         self._forward_buffer = bytearray(0)
-        self.db = Infos() 
+        self.db = Infos()
         self.new_data = {}
-        self.switch={
+        self.switch = {
             0x00: self.msg_contact_info,
+            0x13: self.msg_ota_update,
             0x22: self.msg_get_time,
             0x71: self.msg_collector_data,
             0x04: self.msg_inverter_data,
         }
-    
+
     '''
-    Empty methods, that have to be implemented in any child class which don't use asyncio
+    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  
+    def _read(self) -> None:     # read data bytes from socket and copy them
+        # to our _recv_buffer
+        return  # pragma: no cover
 
     '''
     Our puplic methods
     '''
     def close(self) -> None:
         # we have refernces to methods of this class in self.switch
-        # so we have to erase self.switch, otherwise this instance can't be 
+        # so we have to erase self.switch, otherwise this instance can't be
         # deallocated by the garbage collector ==> we get a memory leak
-        del self.switch 
-        
+        self.switch.clear()
+
+    def inc_counter(self, counter: str) -> None:
+        self.db.inc_counter(counter)
+        self.new_stat_data['proxy'] = True
+
+    def dec_counter(self, counter: str) -> None:
+        self.db.dec_counter(counter)
+        self.new_stat_data['proxy'] = True
+
+    def set_serial_no(self, serial_no: str):
+
+        if self.unique_id == serial_no:
+            logger.debug(f'SerialNo: {serial_no}')
+        else:
+            inverters = Config.get('inverters')
+            # logger.debug(f'Inverters: {inverters}')
+
+            if serial_no in inverters:
+                inv = inverters[serial_no]
+                self.node_id = inv['node_id']
+                self.sug_area = inv['suggested_area']
+                logger.debug(f'SerialNo {serial_no} allowed! area:{self.sug_area}')  # noqa: E501
+            else:
+                self.node_id = ''
+                self.sug_area = ''
+                if 'allow_all' not in inverters or not inverters['allow_all']:
+                    self.inc_counter('Unknown_SNR')
+                    self.unique_id = None
+                    logger.warning(f'ignore message from unknow inverter! (SerialNo: {serial_no})')  # noqa: E501
+                    return
+                logger.debug(f'SerialNo {serial_no} not known but accepted!')
+
+            self.unique_id = serial_no
 
     def read(self) -> None:
         self._read()
-        
+
         if not self.header_valid:
             self.__parse_header(self._recv_buffer, len(self._recv_buffer))
-        
-        if self.header_valid and len(self._recv_buffer) >= (self.header_len+self.data_len):
+
+        if self.header_valid and len(self._recv_buffer) >= (self.header_len +
+                                                            self.data_len):
+            hex_dump_memory(logging.INFO, f'Received from {self.addr}:',
+                            self._recv_buffer, self.header_len+self.data_len)
+
+            self.set_serial_no(self.id_str.decode("utf-8"))
             self.__dispatch_msg()
             self.__flush_recv_msg()
         return
-        
+
     def forward(self, buffer, buflen) -> None:
         tsun = Config.get('tsun')
         if tsun['enabled']:
             self._forward_buffer = buffer[:buflen]
-            hex_dump_memory(logging.DEBUG, 'Store for forwarding:', buffer, buflen)
+            hex_dump_memory(logging.DEBUG, 'Store for forwarding:',
+                            buffer, buflen)
 
-            self.__parse_header(self._forward_buffer, len(self._forward_buffer))
+            self.__parse_header(self._forward_buffer,
+                                len(self._forward_buffer))
             fnc = self.switch.get(self.msg_id, self.msg_unknown)
-            logger.info(self.__flow_str(self.server_side, 'forwrd') + f' Ctl: {int(self.ctrl):#02x} Msg: {fnc.__name__!r}' )
+            logger.info(self.__flow_str(self.server_side, 'forwrd') +
+                        f' Ctl: {int(self.ctrl):#02x} Msg: {fnc.__name__!r}')
         return
-    
+
+    def _init_new_client_conn(self, contact_name, contact_mail) -> None:
+        logger.info(f'name: {contact_name} mail: {contact_mail}')
+        self.msg_id = 0
+        self.await_conn_resp_cnt += 1
+        self.__build_header(0x91)
+        self._send_buffer += struct.pack(f'!{len(contact_name)+1}p'
+                                         f'{len(contact_mail)+1}p',
+                                         contact_name, contact_mail)
+
+        self.__finish_send_msg()
+
     '''
     Our private methods
     '''
-    def __flow_str(self, server_side:bool, type:('rx','tx','forwrd', 'drop')):
-        switch={
-            'rx':     '  <',
-            'tx':     '  >',
-            'forwrd': '<< ',
-            'drop':   ' xx',
-            'rxS':    '>  ',
-            'txS':    '<  ',
-            'forwrdS':' >>',
-            'dropS':  'xx ',
+    def __flow_str(self, server_side: bool, type:
+                   ('rx', 'tx', 'forwrd', 'drop')):  # noqa: F821
+        switch = {
+            'rx':      '  <',
+            'tx':      '  >',
+            'forwrd':  '<< ',
+            'drop':    ' xx',
+            'rxS':     '>  ',
+            'txS':     '<  ',
+            'forwrdS': ' >>',
+            'dropS':   'xx ',
         }
-        if server_side: type +='S'
+        if server_side:
+            type += 'S'
         return switch.get(type, '???')
 
-    def __timestamp(self):
+    def _timestamp(self):   # pragma: no cover
         if False:
-            # utc as epoche 
+            # utc as epoche
             ts = time.time()
         else:
-            # convert localtime in epoche 
-            ts = (datetime.now() - datetime(1970,1,1)).total_seconds()
-        return round(ts*1000)    
+            # convert localtime in epoche
+            ts = (datetime.now() - datetime(1970, 1, 1)).total_seconds()
+        return round(ts*1000)
 
-    # check if there is a complete header in the buffer, parse it 
+    # check if there is a complete header in the buffer, parse it
     # and set
     #   self.header_len
     #   self.data_len
@@ -165,51 +228,53 @@ class Message(metaclass=IterRegistry):
     #   self.msg_id
     #
     # if the header is incomplete, than self.header_len is still 0
-    #   
-    def __parse_header(self, buf:bytes, buf_len:int) -> None:
-    
-        if (buf_len <5):      # enough bytes to read len and id_len?
+    #
+    def __parse_header(self, buf: bytes, buf_len: int) -> None:
+
+        if (buf_len < 5):      # enough bytes to read len and id_len?
             return
         result = struct.unpack_from('!lB', buf, 0)
-        len    = result[0]    # len of complete message
+        len = result[0]    # len of complete message
         id_len = result[1]    # len of variable id string
 
         hdr_len = 5+id_len+2
-    
+
         if (buf_len < hdr_len):  # enough bytes for complete header?
             return
-        
+
         result = struct.unpack_from(f'!{id_len+1}pBB', buf, 4)
-        
-        # store parsed header values in the class 
+
+        # store parsed header values in the class
         self.id_str = result[0]
-        self.ctrl   = Control(result[1])
-        self.msg_id = result[2] 
+        self.ctrl = Control(result[1])
+        self.msg_id = result[2]
         self.data_len = len-id_len-3
         self.header_len = hdr_len
         self.header_valid = True
         return
-    
+
     def __build_header(self, ctrl) -> None:
-        self.send_msg_ofs = len (self._send_buffer)
-        self._send_buffer += struct.pack(f'!l{len(self.id_str)+1}pBB', 0, self.id_str, ctrl, self.msg_id)
+        self.send_msg_ofs = len(self._send_buffer)
+        self._send_buffer += struct.pack(f'!l{len(self.id_str)+1}pBB',
+                                         0, self.id_str, ctrl, self.msg_id)
         fnc = self.switch.get(self.msg_id, self.msg_unknown)
-        logger.info(self.__flow_str(self.server_side, 'tx') + f' Ctl: {int(ctrl):#02x} Msg: {fnc.__name__!r}' )
-        
+        logger.info(self.__flow_str(self.server_side, 'tx') +
+                    f' Ctl: {int(ctrl):#02x} Msg: {fnc.__name__!r}')
+
     def __finish_send_msg(self) -> None:
         _len = len(self._send_buffer) - self.send_msg_ofs
-        struct.pack_into('!l',self._send_buffer, self.send_msg_ofs, _len-4)
-    
-    
+        struct.pack_into('!l', self._send_buffer, self.send_msg_ofs, _len-4)
 
     def __dispatch_msg(self) -> None:
-        hex_dump_memory(logging.INFO, f'Received from {self.addr}:', self._recv_buffer, self.header_len+self.data_len)
-        
         fnc = self.switch.get(self.msg_id, self.msg_unknown)
-        logger.info(self.__flow_str(self.server_side, 'rx') + f' Ctl: {int(self.ctrl):#02x} Msg: {fnc.__name__!r}' )
-        fnc()
-        
-    
+        if self.unique_id:
+            logger.info(self.__flow_str(self.server_side, 'rx') +
+                        f' Ctl: {int(self.ctrl):#02x} Msg: {fnc.__name__!r}')
+            fnc()
+        else:
+            logger.info(self.__flow_str(self.server_side, 'drop') +
+                        f' Ctl: {int(self.ctrl):#02x} Msg: {fnc.__name__!r}')
+
     def __flush_recv_msg(self) -> None:
         self._recv_buffer = self._recv_buffer[(self.header_len+self.data_len):]
         self.header_valid = False
@@ -219,85 +284,134 @@ class Message(metaclass=IterRegistry):
     '''
     def msg_contact_info(self):
         if self.ctrl.is_ind():
-            self.__build_header(0x99)
-            self._send_buffer += b'\x01'
-            self.__finish_send_msg()
-        elif self.ctrl.is_resp():
-            return # ignore received response from tsun
-        self.forward(self._recv_buffer, self.header_len+self.data_len)
+            if self.server_side and self.__process_contact_info():
+                self.__build_header(0x91)
+                self._send_buffer += b'\x01'
+                self.__finish_send_msg()
+            # don't forward this contact info here, we will build one
+            # when the remote connection is established
+            elif self.await_conn_resp_cnt > 0:
+                self.await_conn_resp_cnt -= 1
+            else:
+                self.forward(self._recv_buffer, self.header_len+self.data_len)
+            return
+        else:
+            logger.warning('Unknown Ctrl')
+            self.inc_counter('Unknown_Ctrl')
+            self.forward(self._recv_buffer, self.header_len+self.data_len)
+
+    def __process_contact_info(self) -> bool:
+        result = struct.unpack_from('!B', self._recv_buffer, self.header_len)
+        name_len = result[0]
+        if self.data_len < name_len+2:
+            return False
+        result = struct.unpack_from(f'!{name_len+1}pB', self._recv_buffer,
+                                    self.header_len)
+        self.contact_name = result[0]
+        mail_len = result[1]
+        logger.info(f'name: {self.contact_name}')
+
+        result = struct.unpack_from(f'!{mail_len+1}p', self._recv_buffer,
+                                    self.header_len+name_len+1)
+        self.contact_mail = result[0]
+        logger.info(f'mail: {self.contact_mail}')
+        return True
 
     def msg_get_time(self):
-        if self.ctrl.is_ind():
-            ts = self.__timestamp()
-            logger.debug(f'time: {ts:08x}')
-            
-            self.__build_header(0x99)
-            self._send_buffer += struct.pack('!q', ts)
-            self.__finish_send_msg()
-    
-        elif self.ctrl.is_resp():
-            result = struct.unpack_from(f'!q', self._recv_buffer, self.header_len)
-            logger.debug(f'tsun-time: {result[0]:08x}')
-            return # ignore received response from tsun
-        
-        self.forward(self._recv_buffer, self.header_len+self.data_len)
-            
+        tsun = Config.get('tsun')
+        if tsun['enabled']:
+            if self.ctrl.is_ind():
+                if self.data_len >= 8:
+                    ts = self._timestamp()
+                    result = struct.unpack_from('!q', self._recv_buffer,
+                                                self.header_len)
+                    logger.debug(f'tsun-time: {result[0]:08x}'
+                                 f'  proxy-time: {ts:08x}')
+            else:
+                logger.warning('Unknown Ctrl')
+                self.inc_counter('Unknown_Ctrl')
+            self.forward(self._recv_buffer, self.header_len+self.data_len)
+        else:
+            if self.ctrl.is_ind():
+                if self.data_len == 0:
+                    ts = self._timestamp()
+                    logger.debug(f'time: {ts:08x}')
 
+                    self.__build_header(0x91)
+                    self._send_buffer += struct.pack('!q', ts)
+                    self.__finish_send_msg()
+
+            else:
+                logger.warning('Unknown Ctrl')
+                self.inc_counter('Unknown_Ctrl')
 
     def parse_msg_header(self):
         result = struct.unpack_from('!lB', self._recv_buffer, self.header_len)
 
         data_id = result[0]    # len of complete message
-        id_len  = result[1]    # len of variable id string
+        id_len = result[1]     # len of variable id string
         logger.debug(f'Data_ID: {data_id}   id_len:  {id_len}')
- 
-        msg_hdr_len= 5+id_len+9
-    
-        result = struct.unpack_from(f'!{id_len+1}pBq', self._recv_buffer, self.header_len+4)
- 
+
+        msg_hdr_len = 5+id_len+9
+
+        result = struct.unpack_from(f'!{id_len+1}pBq', self._recv_buffer,
+                                    self.header_len + 4)
+
         logger.debug(f'ID: {result[0]}  B: {result[1]}')
         logger.debug(f'time: {result[2]:08x}')
-        #logger.info(f'time: {datetime.utcfromtimestamp(result[2]).strftime("%Y-%m-%d %H:%M:%S")}')
+        # logger.info(f'time: {datetime.utcfromtimestamp(result[2]).strftime(
+        # "%Y-%m-%d %H:%M:%S")}')
         return msg_hdr_len
- 
 
     def msg_collector_data(self):
         if self.ctrl.is_ind():
             self.__build_header(0x99)
             self._send_buffer += b'\x01'
             self.__finish_send_msg()
-        
-        elif self.ctrl.is_resp():
-            return # ignore received response
-        
-        self.forward(self._recv_buffer, self.header_len+self.data_len)
-        self.__process_data()
+            self.__process_data()
 
+        elif self.ctrl.is_resp():
+            return  # ignore received response
+        else:
+            logger.warning('Unknown Ctrl')
+            self.inc_counter('Unknown_Ctrl')
+
+        self.forward(self._recv_buffer, self.header_len+self.data_len)
 
     def msg_inverter_data(self):
         if self.ctrl.is_ind():
             self.__build_header(0x99)
             self._send_buffer += b'\x01'
             self.__finish_send_msg()
-        
+            self.__process_data()
+
         elif self.ctrl.is_resp():
-            return # ignore received response
-        
+            return  # ignore received response
+        else:
+            logger.warning('Unknown Ctrl')
+            self.inc_counter('Unknown_Ctrl')
+
         self.forward(self._recv_buffer, self.header_len+self.data_len)
-        self.__process_data()
-        
+
     def __process_data(self):
         msg_hdr_len = self.parse_msg_header()
 
-        for key, update in self.db.parse(self._recv_buffer[self.header_len + msg_hdr_len:]):
-            if update: self.new_data[key] = True
+        for key, update in self.db.parse(self._recv_buffer, self.header_len
+                                         + msg_hdr_len):
+            if update:
+                self.new_data[key] = True
 
-
-
-    def msg_unknown(self):
-        logger.warning (f"Unknow Msg: ID:{self.msg_id}")       
+    def msg_ota_update(self):
+        if self.ctrl.is_req():
+            self.inc_counter('OTA_Start_Msg')
+        elif self.ctrl.is_ind():
+            pass
+        else:
+            logger.warning('Unknown Ctrl')
+            self.inc_counter('Unknown_Ctrl')
         self.forward(self._recv_buffer, self.header_len+self.data_len)
 
-        
-
-
+    def msg_unknown(self):
+        logger.warning(f"Unknow Msg: ID:{self.msg_id}")
+        self.inc_counter('Unknown_Msg')
+        self.forward(self._recv_buffer, self.header_len+self.data_len)

app/src/mqtt.py

@@ -1,4 +1,5 @@
-import asyncio, logging
+import asyncio
+import logging
 import aiomqtt
 from config import Config
 
@@ -7,72 +8,86 @@ logger_mqtt = logging.getLogger('mqtt')
 
 class Singleton(type):
     _instances = {}
+
     def __call__(cls, *args, **kwargs):
-        logger_mqtt.debug(f'singleton: __call__')                                
+        logger_mqtt.debug('singleton: __call__')
         if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+            cls._instances[cls] = super(Singleton,
+                                        cls).__call__(*args, **kwargs)
         return cls._instances[cls]
 
 
 class Mqtt(metaclass=Singleton):
     client = None
-    
-    def __init__(self):
-        logger_mqtt.debug(f'MQTT: __init__') 
+    cb_MqttIsUp = None
+
+    def __init__(self, cb_MqttIsUp):
+        logger_mqtt.debug('MQTT: __init__')
+        if cb_MqttIsUp:
+            self.cb_MqttIsUp = cb_MqttIsUp
         loop = asyncio.get_event_loop()
         self.task = loop.create_task(self.__loop())
-        self.ha_restarts = 0        
+        self.ha_restarts = 0
 
-    
     @property
     def ha_restarts(self):
         return self._ha_restarts
-        
+
     @ha_restarts.setter
     def ha_restarts(self, value):
         self._ha_restarts = value
-            
+
     def __del__(self):
-        logger_mqtt.debug(f'MQTT: __del__')
-    
+        logger_mqtt.debug('MQTT: __del__')
 
     async def close(self) -> None:
-        logger_mqtt.debug(f'MQTT: close') 
+        logger_mqtt.debug('MQTT: close')
         self.task.cancel()
         try:
             await self.task
         except Exception as e:
             logging.debug(f"Mqtt.close: exception: {e} ...")
-        
-  
 
-    async def publish(self, topic: str, payload: str | bytes | bytearray | int | float | None = None) -> None:
+    async def publish(self, topic: str, payload: str | bytes | bytearray
+                      | int | float | None = None) -> None:
         if self.client:
             await self.client.publish(topic, payload)
 
-
     async def __loop(self) -> None:
         mqtt = Config.get('mqtt')
         ha = Config.get('ha')
-        logger_mqtt.info(f'start MQTT: host:{mqtt["host"]}  port:{mqtt["port"]}  user:{mqtt["user"]}')                                
-        self.client = aiomqtt.Client(hostname=mqtt['host'], port=mqtt['port'], username=mqtt['user'], password=mqtt['passwd'])
-     
+        logger_mqtt.info(f'start MQTT: host:{mqtt["host"]}  port:'
+                         f'{mqtt["port"]}  '
+                         f'user:{mqtt["user"]}')
+        self.client = aiomqtt.Client(hostname=mqtt['host'], port=mqtt['port'],
+                                     username=mqtt['user'],
+                                     password=mqtt['passwd'])
+
         interval = 5  # Seconds
         while True:
             try:
                 async with self.client:
+                    logger_mqtt.info('MQTT broker connection established')
+
+                    if self.cb_MqttIsUp:
+                        await self.cb_MqttIsUp()
+
                     async with self.client.messages() as messages:
-                        await self.client.subscribe(f"{ha['auto_conf_prefix']}/status")
+                        await self.client.subscribe(f"{ha['auto_conf_prefix']}"
+                                                    "/status")
                         async for message in messages:
                             status = message.payload.decode("UTF-8")
-                            logger_mqtt.info(f'Home-Assistant Status: {status}')
+                            logger_mqtt.info('Home-Assistant Status:'
+                                             f' {status}')
                             if status == 'online':
                                 self.ha_restarts += 1
+                                await self.cb_MqttIsUp()
 
             except aiomqtt.MqttError:
-                logger_mqtt.info(f"Connection lost; Reconnecting in {interval} seconds ...")
+                logger_mqtt.info(f"Connection lost; Reconnecting in {interval}"
+                                 " seconds ...")
                 await asyncio.sleep(interval)
             except asyncio.CancelledError:
-                logger_mqtt.debug(f"MQTT task cancelled")
+                logger_mqtt.debug("MQTT task cancelled")
                 self.client = None
                 return

app/src/server.py

@@ -1,16 +1,19 @@
-import logging, asyncio, signal, functools, os
-from logging import config
+import logging
+import asyncio
+import signal
+import functools
+import os
+from logging import config  # noqa F401
 from async_stream import AsyncStream
 from inverter import Inverter
 from config import Config
-from mqtt import Mqtt
 
-    
+
 async def handle_client(reader, writer):
     '''Handles a new incoming connection and starts an async loop'''
 
     addr = writer.get_extra_info('peername')
-    await Inverter(reader, writer, addr).server_loop(addr) 
+    await Inverter(reader, writer, addr).server_loop(addr)
 
 
 def handle_SIGTERM(loop):
@@ -30,14 +33,15 @@ def handle_SIGTERM(loop):
     loop.stop()
 
     logging.info('Shutdown complete')
-    
+
 
 def get_log_level() -> int:
-    '''checks if LOG_LVL is set in the environment and returns the corresponding logging.LOG_LEVEL'''
+    '''checks if LOG_LVL is set in the environment and returns the
+    corresponding logging.LOG_LEVEL'''
     log_level = os.getenv('LOG_LVL', 'INFO')
-    if log_level== 'DEBUG':
+    if log_level == 'DEBUG':
         log_level = logging.DEBUG
-    elif log_level== 'WARN':
+    elif log_level == 'WARN':
         log_level = logging.WARNING
     else:
         log_level = logging.INFO
@@ -49,47 +53,46 @@ if __name__ == "__main__":
     # Setup our daily, rotating logger
     #
     serv_name = os.getenv('SERVICE_NAME', 'proxy')
-    version   = os.getenv('VERSION', 'unknown')
-    
+    version = os.getenv('VERSION', 'unknown')
+
     logging.config.fileConfig('logging.ini')
     logging.info(f'Server "{serv_name} - {version}" will be started')
-    
+
     # set lowest-severity for 'root', 'msg', 'conn' and 'data' logger
     log_level = get_log_level()
     logging.getLogger().setLevel(log_level)
     logging.getLogger('msg').setLevel(log_level)
     logging.getLogger('conn').setLevel(log_level)
     logging.getLogger('data').setLevel(log_level)
-    
+
     # read config file
-    Config.read()    
+    Config.read()
 
-    loop = asyncio.get_event_loop()
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
 
-    # call Mqtt singleton to establisch the connection to the mqtt broker
-    mqtt = Mqtt()
-    
+    Inverter.class_init()
     #
-    # Register some UNIX Signal handler for a gracefully server shutdown on Docker restart and stop
-    #  
-    for signame in ('SIGINT','SIGTERM'):
-        loop.add_signal_handler(getattr(signal, signame), functools.partial(handle_SIGTERM, loop))
+    # Register some UNIX Signal handler for a gracefully server shutdown
+    # on Docker restart and stop
+    #
+    for signame in ('SIGINT', 'SIGTERM'):
+        loop.add_signal_handler(getattr(signal, signame),
+                                functools.partial(handle_SIGTERM, loop))
 
     #
-    # Create a task for our listening server. This must be a task! If we call start_server directly out
-    # of our main task, the eventloop will be blocked and we can't receive and handle the UNIX signals!
-    #   
+    # Create a task for our listening server. This must be a task! If we call
+    # start_server directly out of our main task, the eventloop will be blocked
+    # and we can't receive and handle the UNIX signals!
+    #
     loop.create_task(asyncio.start_server(handle_client, '0.0.0.0', 5005))
-       
+
     try:
         loop.run_forever()
     except KeyboardInterrupt:
         pass
     finally:
-        logging.info ('Close MQTT Task')        
-        loop.run_until_complete(mqtt.close())
-        mqtt = None   # release the last reference to the singleton
-        logging.info ('Close event loop')        
+        Inverter.class_close(loop)
+        logging.info('Close event loop')
         loop.close()
-        logging.info (f'Finally, exit Server "{serv_name}"')
-    
+        logging.info(f'Finally, exit Server "{serv_name}"')

app/tests/test_infos.py

@@ -12,10 +12,166 @@ def ContrDataSeq(): # Get Time Request message
     msg +=  b'\x49\x00\x00\x00\x02\x00\x0d\x04\x08\x49\x00\x00\x00\x00\x00\x07\xa1\x84\x49\x00\x00\x00\x01\x00\x0c\x50\x59\x49\x00\x00\x00\x4c\x00\x0d\x1f\x60\x49\x00\x00\x00\x00'
     return msg
 
+@pytest.fixture
+def Contr2DataSeq(): # Get Time Request message
+    msg  =  b'\x00\x00\x00\x39\x00\x09\x2b\xa8\x54\x10\x52'
+    msg +=  b'\x53\x57\x5f\x34\x30\x30\x5f\x56\x31\x2e\x30\x30\x2e\x32\x30\x00'
+    msg +=  b'\x09\x27\xc0\x54\x06\x52\x61\x79\x6d\x6f\x6e\x00\x09\x2f\x90\x54'
+    msg +=  b'\x0b\x52\x53\x57\x2d\x31\x2d\x31\x30\x30\x30\x31\x00\x09\x5a\x88'
+    msg +=  b'\x54\x0f\x74\x2e\x72\x61\x79\x6d\x6f\x6e\x69\x6f\x74\x2e\x63\x6f'
+    msg +=  b'\x6d\x00\x09\x5a\xec\x54\x1c\x6c\x6f\x67\x67\x65\x72\x2e\x74\x61'
+    msg +=  b'\x6c\x65\x6e\x74\x2d\x6d\x6f\x6e\x69\x74\x6f\x72\x69\x6e\x67\x2e'
+    msg +=  b'\x63\x6f\x6d\x00\x0d\x2f\x00\x54\x10\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x32\xe8\x54\x10\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00'
+    msg +=  b'\x0d\x36\xd0\x54\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\x00\x0d\x3a\xb8\x54\x10\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x3e\xa0\x54'
+    msg +=  b'\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\x00\x0d\x42\x88\x54\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x46\x70\x54\x10\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x4a'
+    msg +=  b'\x58\x54\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\x00\x0d\x4e\x40\x54\x10\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x52\x28\x54\x10\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00'
+    msg +=  b'\x0d\x56\x10\x54\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\x00\x0d\x59\xf8\x54\x10\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x5d\xe0\x54'
+    msg +=  b'\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\x00\x0d\x61\xc8\x54\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x65\xb0\x54\x10\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x69'
+    msg +=  b'\x98\x54\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\x00\x0d\x6d\x80\x54\x10\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x71\x68\x54\x10\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00'
+    msg +=  b'\x0d\x75\x50\x54\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\x00\x0d\x79\x38\x54\x10\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x7d\x20\x54'
+    msg +=  b'\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\x00\x0d\x81\x08\x54\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x84\xf0\x54\x10\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x88'
+    msg +=  b'\xd8\x54\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\x00\x0d\x8c\xc0\x54\x10\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x90\xa8\x54\x10\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00'
+    msg +=  b'\x0d\x94\x90\x54\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\x00\x0d\x98\x78\x54\x10\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x0d\x9c\x60\x54'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+    msg +=  b'\x00\x0d\x00\x20\x49\x00\x00\x00\x01\x00\x0c\x35\x00\x49\x00\x00'
+    msg +=  b'\x00\x10\x00\x0c\x96\xa8\x49\x00\x00\x01\x4e\x00\x0c\x7f\x38\x49'
+    msg +=  b'\x00\x00\x00\x01\x00\x0c\xfc\x38\x49\x00\x00\x00\x01\x00\x0c\xf8'
+    msg +=  b'\x50\x49\x00\x00\x01\x2c\x00\x0c\x63\xe0\x49\x00\x00\x00\x00\x00'
+    msg +=  b'\x0c\x67\xc8\x49\x00\x00\x00\x00\x00\x0c\x50\x58\x49\x00\x00\x00'
+    msg +=  b'\x01\x00\x09\x5e\x70\x49\x00\x00\x13\x8d\x00\x09\x5e\xd4\x49\x00'
+    msg +=  b'\x00\x13\x8d\x00\x09\x5b\x50\x49\x00\x00\x00\x02\x00\x0d\x04\x08'
+    msg +=  b'\x49\x00\x00\x00\x00\x00\x07\xa1\x84\x49\x00\x00\x00\x01\x00\x0c'
+    msg +=  b'\x50\x59\x49\x00\x00\x00\x33\x00\x0d\x1f\x60\x49\x00\x00\x00\x00'
+    msg +=  b'\x00\x0d\x23\x48\x49\xff\xff\xff\xff\x00\x0d\x27\x30\x49\xff\xff'
+    msg +=  b'\xff\xff\x00\x0d\x2b\x18\x4c\x00\x00\x00\x00\x00\x00\xff\xff\x00'
+    msg +=  b'\x0c\xa2\x60\x49\x00\x00\x00\x00\x00\x0d\xa0\x48\x49\x00\x00\x00'
+    msg +=  b'\x00\x00\x0d\xa4\x30\x49\x00\x00\x00\x00\x00\x0d\xa8\x18\x49\x00'
+    msg +=  b'\x00\x00\x00'
+    return msg
+
 @pytest.fixture
 def InvDataSeq(): # Data indication from the controller
     msg =   b'\x00\x00\x00\x06\x00\x00\x00\x0a\x54\x08\x4d\x69\x63\x72\x6f\x69\x6e\x76\x00\x00\x00\x14\x54\x04\x54\x53\x55\x4e\x00\x00\x00\x1E\x54\x07\x56\x35\x2e\x30\x2e\x31\x31\x00\x00\x00\x28'
-    msg +=  b'\x54\x10\x54\x31\x37\x45\x37\x33\x30\x37\x30\x32\x31\x44\x30\x30\x36\x41\x00\x00\x00\x32\x54\x0a\x54\x53\x4f\x4c\x2d\x4d\x53\x36\x30\x30\x00\x00\x00\x3c\x54\x05\x41\x2c\x42\x2c\x43'
+    msg +=  b'\x54\x10T170000000000001\x00\x00\x00\x32\x54\x0a\x54\x53\x4f\x4c\x2d\x4d\x53\x36\x30\x30\x00\x00\x00\x3c\x54\x05\x41\x2c\x42\x2c\x43'
+    return msg
+
+@pytest.fixture
+def InvalidDataSeq(): # Data indication from the controller
+    msg =   b'\x00\x00\x00\x06\x00\x00\x00\x0a\x54\x08\x4d\x69\x63\x72\x6f\x69\x6e\x76\x00\x00\x00\x14\x64\x04\x54\x53\x55\x4e\x00\x00\x00\x1E\x54\x07\x56\x35\x2e\x30\x2e\x31\x31\x00\x00\x00\x28'
+    msg +=  b'\x54\x10T170000000000001\x00\x00\x00\x32\x54\x0a\x54\x53\x4f\x4c\x2d\x4d\x53\x36\x30\x30\x00\x00\x00\x3c\x54\x05\x41\x2c\x42\x2c\x43'
+    return msg
+
+@pytest.fixture
+def InvDataSeq2(): # Data indication from the controller
+    msg =   b'\x00\x00\x00\xa3\x00\x00\x00\x64\x53\x00\x01\x00\x00\x00\xc8\x53\x00\x02\x00\x00\x01\x2c\x53\x00\x00\x00\x00\x01\x90\x49\x00\x00\x00\x00\x00\x00\x01\x91\x53\x00\x00'
+    msg +=  b'\x00\x00\x01\x92\x53\x00\x00\x00\x00\x01\x93\x53\x00\x00\x00\x00\x01\x94\x53\x00\x00\x00\x00\x01\x95\x53\x00\x00\x00\x00\x01\x96\x53\x00\x00\x00\x00\x01\x97\x53\x00'
+    msg +=  b'\x00\x00\x00\x01\x98\x53\x00\x00\x00\x00\x01\x99\x53\x00\x00\x00\x00\x01\x9a\x53\x00\x00\x00\x00\x01\x9b\x53\x00\x00\x00\x00\x01\x9c\x53\x00\x00\x00\x00\x01\x9d\x53'
+    msg +=  b'\x00\x00\x00\x00\x01\x9e\x53\x00\x00\x00\x00\x01\x9f\x53\x00\x00\x00\x00\x01\xa0\x53\x00\x00\x00\x00\x01\xf4\x49\x00\x00\x00\x00\x00\x00\x01\xf5\x53\x00\x00\x00\x00'
+    msg +=  b'\x01\xf6\x53\x00\x00\x00\x00\x01\xf7\x53\x00\x00\x00\x00\x01\xf8\x53\x00\x00\x00\x00\x01\xf9\x53\x00\x00\x00\x00\x01\xfa\x53\x00\x00\x00\x00\x01\xfb\x53\x00\x00\x00'
+    msg +=  b'\x00\x01\xfc\x53\x00\x00\x00\x00\x01\xfd\x53\x00\x00\x00\x00\x01\xfe\x53\x00\x00\x00\x00\x01\xff\x53\x00\x00\x00\x00\x02\x00\x53\x00\x00\x00\x00\x02\x01\x53\x00\x00'
+    msg +=  b'\x00\x00\x02\x02\x53\x00\x00\x00\x00\x02\x03\x53\x00\x00\x00\x00\x02\x04\x53\x00\x00\x00\x00\x02\x58\x49\x00\x00\x00\x00\x00\x00\x02\x59\x53\x00\x00\x00\x00\x02\x5a'
+    msg +=  b'\x53\x00\x00\x00\x00\x02\x5b\x53\x00\x00\x00\x00\x02\x5c\x53\x00\x00\x00\x00\x02\x5d\x53\x00\x00\x00\x00\x02\x5e\x53\x00\x00\x00\x00\x02\x5f\x53\x00\x00\x00\x00\x02'
+    msg +=  b'\x60\x53\x00\x00\x00\x00\x02\x61\x53\x00\x00\x00\x00\x02\x62\x53\x00\x00\x00\x00\x02\x63\x53\x00\x00\x00\x00\x02\x64\x53\x00\x00\x00\x00\x02\x65\x53\x00\x00\x00\x00'
+    msg +=  b'\x02\x66\x53\x00\x00\x00\x00\x02\x67\x53\x00\x00\x00\x00\x02\x68\x53\x00\x00\x00\x00\x02\xbc\x49\x00\x00\x00\x00\x00\x00\x02\xbd\x53\x00\x00\x00\x00\x02\xbe\x53\x00'
+    msg +=  b'\x00\x00\x00\x02\xbf\x53\x00\x00\x00\x00\x02\xc0\x53\x00\x00\x00\x00\x02\xc1\x53\x00\x00\x00\x00\x02\xc2\x53\x00\x00\x00\x00\x02\xc3\x53\x00\x00\x00\x00\x02\xc4\x53'
+    msg +=  b'\x00\x00\x00\x00\x02\xc5\x53\x00\x00\x00\x00\x02\xc6\x53\x00\x00\x00\x00\x02\xc7\x53\x00\x00\x00\x00\x02\xc8\x53\x00\x00\x00\x00\x02\xc9\x53\x00\x00\x00\x00\x02\xca'
+    msg +=  b'\x53\x00\x00\x00\x00\x02\xcb\x53\x00\x00\x00\x00\x02\xcc\x53\x00\x00\x00\x00\x03\x20\x53\x00\x00\x00\x00\x03\x84\x53\x50\x11\x00\x00\x03\xe8\x46\x43\x61\x66\x66\x00'
+    msg +=  b'\x00\x04\x4c\x46\x3e\xeb\x85\x1f\x00\x00\x04\xb0\x46\x42\x48\x14\x7b\x00\x00\x05\x14\x53\x00\x17\x00\x00\x05\x78\x53\x00\x00\x00\x00\x05\xdc\x53\x02\x58\x00\x00\x06'
+    msg +=  b'\x40\x46\x42\xd3\x66\x66\x00\x00\x06\xa4\x46\x42\x06\x66\x66\x00\x00\x07\x08\x46\x3f\xf4\x7a\xe1\x00\x00\x07\x6c\x46\x42\x81\x00\x00\x00\x00\x07\xd0\x46\x42\x06\x00'
+    msg +=  b'\x00\x00\x00\x08\x34\x46\x3f\xae\x14\x7b\x00\x00\x08\x98\x46\x42\x36\xcc\xcd\x00\x00\x08\xfc\x46\x00\x00\x00\x00\x00\x00\x09\x60\x46\x00\x00\x00\x00\x00\x00\x09\xc4'
+    msg +=  b'\x46\x00\x00\x00\x00\x00\x00\x0a\x28\x46\x00\x00\x00\x00\x00\x00\x0a\x8c\x46\x00\x00\x00\x00\x00\x00\x0a\xf0\x46\x00\x00\x00\x00\x00\x00\x0b\x54\x46\x3f\xd9\x99\x9a'
+    msg +=  b'\x00\x00\x0b\xb8\x46\x41\x8a\xe1\x48\x00\x00\x0c\x1c\x46\x3f\x8a\x3d\x71\x00\x00\x0c\x80\x46\x41\x1b\xd7\x0a\x00\x00\x0c\xe4\x46\x3f\x1e\xb8\x52\x00\x00\x0d\x48\x46'
+    msg +=  b'\x40\xf3\xd7\x0a\x00\x00\x0d\xac\x46\x00\x00\x00\x00\x00\x00\x0e\x10\x46\x00\x00\x00\x00\x00\x00\x0e\x74\x46\x00\x00\x00\x00\x00\x00\x0e\xd8\x46\x00\x00\x00\x00\x00'
+    msg +=  b'\x00\x0f\x3c\x53\x00\x00\x00\x00\x0f\xa0\x53\x00\x00\x00\x00\x10\x04\x53\x55\xaa\x00\x00\x10\x68\x53\x00\x00\x00\x00\x10\xcc\x53\x00\x00\x00\x00\x11\x30\x53\x00\x00'
+    msg +=  b'\x00\x00\x11\x94\x53\x00\x00\x00\x00\x11\xf8\x53\xff\xff\x00\x00\x12\x5c\x53\xff\xff\x00\x00\x12\xc0\x53\x00\x02\x00\x00\x13\x24\x53\xff\xff\x00\x00\x13\x88\x53\xff'
+    msg +=  b'\xff\x00\x00\x13\xec\x53\xff\xff\x00\x00\x14\x50\x53\xff\xff\x00\x00\x14\xb4\x53\xff\xff\x00\x00\x15\x18\x53\xff\xff\x00\x00\x15\x7c\x53\x00\x00\x00\x00\x27\x10\x53'
+    msg +=  b'\x00\x02\x00\x00\x27\x74\x53\x00\x3c\x00\x00\x27\xd8\x53\x00\x68\x00\x00\x28\x3c\x53\x05\x00\x00\x00\x28\xa0\x46\x43\x79\x00\x00\x00\x00\x29\x04\x46\x43\x48\x00\x00'
+    msg +=  b'\x00\x00\x29\x68\x46\x42\x48\x33\x33\x00\x00\x29\xcc\x46\x42\x3e\x3d\x71\x00\x00\x2a\x30\x53\x00\x01\x00\x00\x2a\x94\x46\x43\x37\x00\x00\x00\x00\x2a\xf8\x46\x42\xce'
+    msg +=  b'\x00\x00\x00\x00\x2b\x5c\x53\x00\x96\x00\x00\x2b\xc0\x53\x00\x10\x00\x00\x2c\x24\x46\x43\x90\x00\x00\x00\x00\x2c\x88\x46\x43\x95\x00\x00\x00\x00\x2c\xec\x53\x00\x06'
+    msg +=  b'\x00\x00\x2d\x50\x53\x00\x06\x00\x00\x2d\xb4\x46\x43\x7d\x00\x00\x00\x00\x2e\x18\x46\x42\x3d\xeb\x85\x00\x00\x2e\x7c\x46\x42\x3d\xeb\x85\x00\x00\x2e\xe0\x53\x00\x03'
+    msg +=  b'\x00\x00\x2f\x44\x53\x00\x03\x00\x00\x2f\xa8\x46\x42\x4d\xeb\x85\x00\x00\x30\x0c\x46\x42\x4d\xeb\x85\x00\x00\x30\x70\x53\x00\x03\x00\x00\x30\xd4\x53\x00\x03\x00\x00'
+    msg +=  b'\x31\x38\x46\x42\x08\x00\x00\x00\x00\x31\x9c\x53\x00\x05\x00\x00\x32\x00\x53\x04\x00\x00\x00\x32\x64\x53\x00\x01\x00\x00\x32\xc8\x53\x13\x9c\x00\x00\x33\x2c\x53\x0f'
+    msg +=  b'\xa0\x00\x00\x33\x90\x53\x00\x4f\x00\x00\x33\xf4\x53\x00\x66\x00\x00\x34\x58\x53\x03\xe8\x00\x00\x34\xbc\x53\x04\x00\x00\x00\x35\x20\x53\x00\x00\x00\x00\x35\x84\x53'
+    msg +=  b'\x00\x00\x00\x00\x35\xe8\x53\x00\x00\x00\x00\x36\x4c\x53\x00\x00\x00\x01\x38\x80\x53\x00\x02\x00\x01\x38\x81\x53\x00\x01\x00\x01\x38\x82\x53\x00\x01\x00\x01\x38\x83'
+    msg +=  b'\x53\x00\x00'  
+    return msg
+
+@pytest.fixture
+def InvDataSeq2_Zero(): # Data indication from the controller
+    msg =   b'\x00\x00\x00\xa3\x00\x00\x00\x64\x53\x00\x01\x00\x00\x00\xc8\x53\x00\x02\x00\x00\x01\x2c\x53\x00\x00\x00\x00\x01\x90\x49\x00\x00\x00\x00\x00\x00\x01\x91\x53\x00\x00'
+    msg +=  b'\x00\x00\x01\x92\x53\x00\x00\x00\x00\x01\x93\x53\x00\x00\x00\x00\x01\x94\x53\x00\x00\x00\x00\x01\x95\x53\x00\x00\x00\x00\x01\x96\x53\x00\x00\x00\x00\x01\x97\x53\x00'
+    msg +=  b'\x00\x00\x00\x01\x98\x53\x00\x00\x00\x00\x01\x99\x53\x00\x00\x00\x00\x01\x9a\x53\x00\x00\x00\x00\x01\x9b\x53\x00\x00\x00\x00\x01\x9c\x53\x00\x00\x00\x00\x01\x9d\x53'
+    msg +=  b'\x00\x00\x00\x00\x01\x9e\x53\x00\x00\x00\x00\x01\x9f\x53\x00\x00\x00\x00\x01\xa0\x53\x00\x00\x00\x00\x01\xf4\x49\x00\x00\x00\x00\x00\x00\x01\xf5\x53\x00\x00\x00\x00'
+    msg +=  b'\x01\xf6\x53\x00\x00\x00\x00\x01\xf7\x53\x00\x00\x00\x00\x01\xf8\x53\x00\x00\x00\x00\x01\xf9\x53\x00\x00\x00\x00\x01\xfa\x53\x00\x00\x00\x00\x01\xfb\x53\x00\x00\x00'
+    msg +=  b'\x00\x01\xfc\x53\x00\x00\x00\x00\x01\xfd\x53\x00\x00\x00\x00\x01\xfe\x53\x00\x00\x00\x00\x01\xff\x53\x00\x00\x00\x00\x02\x00\x53\x00\x00\x00\x00\x02\x01\x53\x00\x00'
+    msg +=  b'\x00\x00\x02\x02\x53\x00\x00\x00\x00\x02\x03\x53\x00\x00\x00\x00\x02\x04\x53\x00\x00\x00\x00\x02\x58\x49\x00\x00\x00\x00\x00\x00\x02\x59\x53\x00\x00\x00\x00\x02\x5a'
+    msg +=  b'\x53\x00\x00\x00\x00\x02\x5b\x53\x00\x00\x00\x00\x02\x5c\x53\x00\x00\x00\x00\x02\x5d\x53\x00\x00\x00\x00\x02\x5e\x53\x00\x00\x00\x00\x02\x5f\x53\x00\x00\x00\x00\x02'
+    msg +=  b'\x60\x53\x00\x00\x00\x00\x02\x61\x53\x00\x00\x00\x00\x02\x62\x53\x00\x00\x00\x00\x02\x63\x53\x00\x00\x00\x00\x02\x64\x53\x00\x00\x00\x00\x02\x65\x53\x00\x00\x00\x00'
+    msg +=  b'\x02\x66\x53\x00\x00\x00\x00\x02\x67\x53\x00\x00\x00\x00\x02\x68\x53\x00\x00\x00\x00\x02\xbc\x49\x00\x00\x00\x00\x00\x00\x02\xbd\x53\x00\x00\x00\x00\x02\xbe\x53\x00'
+    msg +=  b'\x00\x00\x00\x02\xbf\x53\x00\x00\x00\x00\x02\xc0\x53\x00\x00\x00\x00\x02\xc1\x53\x00\x00\x00\x00\x02\xc2\x53\x00\x00\x00\x00\x02\xc3\x53\x00\x00\x00\x00\x02\xc4\x53'
+    msg +=  b'\x00\x00\x00\x00\x02\xc5\x53\x00\x00\x00\x00\x02\xc6\x53\x00\x00\x00\x00\x02\xc7\x53\x00\x00\x00\x00\x02\xc8\x53\x00\x00\x00\x00\x02\xc9\x53\x00\x00\x00\x00\x02\xca'
+    msg +=  b'\x53\x00\x00\x00\x00\x02\xcb\x53\x00\x00\x00\x00\x02\xcc\x53\x00\x00\x00\x00\x03\x20\x53\x00\x00\x00\x00\x03\x84\x53\x50\x11\x00\x00\x03\xe8\x46\x43\x61\x66\x66\x00'
+    msg +=  b'\x00\x04\x4c\x46\x3e\xeb\x85\x1f\x00\x00\x04\xb0\x46\x42\x48\x14\x7b\x00\x00\x05\x14\x53\x00\x00\x00\x00\x05\x78\x53\x00\x00\x00\x00\x05\xdc\x53\x00\x00\x00\x00\x06'
+    msg +=  b'\x40\x46\x42\xd3\x66\x66\x00\x00\x06\xa4\x46\x42\x06\x66\x66\x00\x00\x07\x08\x46\x3f\xf4\x7a\xe1\x00\x00\x07\x6c\x46\x00\x00\x00\x00\x00\x00\x07\xd0\x46\x42\x06\x00'
+    msg +=  b'\x00\x00\x00\x08\x34\x46\x3f\xae\x14\x7b\x00\x00\x08\x98\x46\x00\x00\x00\x00\x00\x00\x08\xfc\x46\x00\x00\x00\x00\x00\x00\x09\x60\x46\x00\x00\x00\x00\x00\x00\x09\xc4'
+    msg +=  b'\x46\x00\x00\x00\x00\x00\x00\x0a\x28\x46\x00\x00\x00\x00\x00\x00\x0a\x8c\x46\x00\x00\x00\x00\x00\x00\x0a\xf0\x46\x00\x00\x00\x00\x00\x00\x0b\x54\x46\x00\x00\x00\x00'
+    msg +=  b'\x00\x00\x0b\xb8\x46\x00\x00\x00\x00\x00\x00\x0c\x1c\x46\x00\x00\x00\x00\x00\x00\x0c\x80\x46\x00\x00\x00\x00\x00\x00\x0c\xe4\x46\x00\x00\x00\x00\x00\x00\x0d\x48\x46'
+    msg +=  b'\x00\x00\x00\x00\x00\x00\x0d\xac\x46\x00\x00\x00\x00\x00\x00\x0e\x10\x46\x00\x00\x00\x00\x00\x00\x0e\x74\x46\x00\x00\x00\x00\x00\x00\x0e\xd8\x46\x00\x00\x00\x00\x00'
+    msg +=  b'\x00\x0f\x3c\x53\x00\x00\x00\x00\x0f\xa0\x53\x00\x00\x00\x00\x10\x04\x53\x55\xaa\x00\x00\x10\x68\x53\x00\x00\x00\x00\x10\xcc\x53\x00\x00\x00\x00\x11\x30\x53\x00\x00'
+    msg +=  b'\x00\x00\x11\x94\x53\x00\x00\x00\x00\x11\xf8\x53\xff\xff\x00\x00\x12\x5c\x53\xff\xff\x00\x00\x12\xc0\x53\x00\x02\x00\x00\x13\x24\x53\xff\xff\x00\x00\x13\x88\x53\xff'
+    msg +=  b'\xff\x00\x00\x13\xec\x53\xff\xff\x00\x00\x14\x50\x53\xff\xff\x00\x00\x14\xb4\x53\xff\xff\x00\x00\x15\x18\x53\xff\xff\x00\x00\x15\x7c\x53\x00\x00\x00\x00\x27\x10\x53'
+    msg +=  b'\x00\x02\x00\x00\x27\x74\x53\x00\x3c\x00\x00\x27\xd8\x53\x00\x68\x00\x00\x28\x3c\x53\x05\x00\x00\x00\x28\xa0\x46\x43\x79\x00\x00\x00\x00\x29\x04\x46\x43\x48\x00\x00'
+    msg +=  b'\x00\x00\x29\x68\x46\x42\x48\x33\x33\x00\x00\x29\xcc\x46\x42\x3e\x3d\x71\x00\x00\x2a\x30\x53\x00\x01\x00\x00\x2a\x94\x46\x43\x37\x00\x00\x00\x00\x2a\xf8\x46\x42\xce'
+    msg +=  b'\x00\x00\x00\x00\x2b\x5c\x53\x00\x96\x00\x00\x2b\xc0\x53\x00\x10\x00\x00\x2c\x24\x46\x43\x90\x00\x00\x00\x00\x2c\x88\x46\x43\x95\x00\x00\x00\x00\x2c\xec\x53\x00\x06'
+    msg +=  b'\x00\x00\x2d\x50\x53\x00\x06\x00\x00\x2d\xb4\x46\x43\x7d\x00\x00\x00\x00\x2e\x18\x46\x42\x3d\xeb\x85\x00\x00\x2e\x7c\x46\x42\x3d\xeb\x85\x00\x00\x2e\xe0\x53\x00\x03'
+    msg +=  b'\x00\x00\x2f\x44\x53\x00\x03\x00\x00\x2f\xa8\x46\x42\x4d\xeb\x85\x00\x00\x30\x0c\x46\x42\x4d\xeb\x85\x00\x00\x30\x70\x53\x00\x03\x00\x00\x30\xd4\x53\x00\x03\x00\x00'
+    msg +=  b'\x31\x38\x46\x42\x08\x00\x00\x00\x00\x31\x9c\x53\x00\x05\x00\x00\x32\x00\x53\x04\x00\x00\x00\x32\x64\x53\x00\x01\x00\x00\x32\xc8\x53\x13\x9c\x00\x00\x33\x2c\x53\x0f'
+    msg +=  b'\xa0\x00\x00\x33\x90\x53\x00\x4f\x00\x00\x33\xf4\x53\x00\x66\x00\x00\x34\x58\x53\x03\xe8\x00\x00\x34\xbc\x53\x04\x00\x00\x00\x35\x20\x53\x00\x00\x00\x00\x35\x84\x53'
+    msg +=  b'\x00\x00\x00\x00\x35\xe8\x53\x00\x00\x00\x00\x36\x4c\x53\x00\x00\x00\x01\x38\x80\x53\x00\x02\x00\x01\x38\x81\x53\x00\x01\x00\x01\x38\x82\x53\x00\x01\x00\x01\x38\x83'
+    msg +=  b'\x53\x00\x00'  
     return msg
 
 
@@ -25,7 +181,15 @@ def test_parse_control(ContrDataSeq):
         pass
 
     assert json.dumps(i.db) == json.dumps(
-{"collector": {"Collector_Fw_Version": "RSW_400_V1.00.06", "Chip_Type": "Raymon", "Chip_Model": "RSW-1-10001", "Trace_URL": "t.raymoniot.com", "Logger_URL": "logger.talent-monitoring.com"}, "controller": {"Signal_Strength": 100, "Power_On_Time": 29, "Data_Up_Interval": 300}})        
+{"collector": {"Collector_Fw_Version": "RSW_400_V1.00.06", "Chip_Type": "Raymon", "Chip_Model": "RSW-1-10001", "Trace_URL": "t.raymoniot.com", "Logger_URL": "logger.talent-monitoring.com"}, "controller": {"Collect_Interval": 1, "Signal_Strength": 100, "Power_On_Time": 29, "Communication_Type": 1, "Connect_Count": 1, "Data_Up_Interval": 300}})        
+
+def test_parse_control2(Contr2DataSeq):
+    i = Infos()
+    for key, result in i.parse (Contr2DataSeq):
+        pass
+
+    assert json.dumps(i.db) == json.dumps(
+{"collector": {"Collector_Fw_Version": "RSW_400_V1.00.20", "Chip_Type": "Raymon", "Chip_Model": "RSW-1-10001", "Trace_URL": "t.raymoniot.com", "Logger_URL": "logger.talent-monitoring.com"}, "controller": {"Collect_Interval": 1, "Signal_Strength": 16, "Power_On_Time": 334, "Communication_Type": 1, "Connect_Count": 1, "Data_Up_Interval": 300}})
 
 def test_parse_inverter(InvDataSeq):
     i = Infos()
@@ -33,7 +197,7 @@ def test_parse_inverter(InvDataSeq):
         pass
 
     assert json.dumps(i.db) == json.dumps(
-{"inverter": {"Product_Name": "Microinv", "Manufacturer": "TSUN", "Version": "V5.0.11", "Serial_Number": "T17E7307021D006A", "Equipment_Model": "TSOL-MS600"}})
+{"inverter": {"Product_Name": "Microinv", "Manufacturer": "TSUN", "Version": "V5.0.11", "Serial_Number": "T170000000000001", "Equipment_Model": "TSOL-MS600"}})
 
 def test_parse_cont_and_invert(ContrDataSeq, InvDataSeq):
     i = Infos()
@@ -45,14 +209,16 @@ def test_parse_cont_and_invert(ContrDataSeq, InvDataSeq):
 
     assert json.dumps(i.db) == json.dumps(
     {
-"collector": {"Collector_Fw_Version": "RSW_400_V1.00.06", "Chip_Type": "Raymon", "Chip_Model": "RSW-1-10001", "Trace_URL": "t.raymoniot.com", "Logger_URL": "logger.talent-monitoring.com"}, "controller": {"Signal_Strength": 100, "Power_On_Time": 29, "Data_Up_Interval": 300},
-"inverter": {"Product_Name": "Microinv", "Manufacturer": "TSUN", "Version": "V5.0.11", "Serial_Number": "T17E7307021D006A", "Equipment_Model": "TSOL-MS600"}})
+"collector": {"Collector_Fw_Version": "RSW_400_V1.00.06", "Chip_Type": "Raymon", "Chip_Model": "RSW-1-10001", "Trace_URL": "t.raymoniot.com", "Logger_URL": "logger.talent-monitoring.com"}, "controller": {"Collect_Interval": 1, "Signal_Strength": 100, "Power_On_Time": 29, "Communication_Type": 1, "Connect_Count": 1, "Data_Up_Interval": 300},
+"inverter": {"Product_Name": "Microinv", "Manufacturer": "TSUN", "Version": "V5.0.11", "Serial_Number": "T170000000000001", "Equipment_Model": "TSOL-MS600"}})
 
 
 def test_build_ha_conf1(ContrDataSeq):
     i = Infos()
+    i.static_init()                # initialize counter
+
     tests = 0
-    for d_json, comp, id in i.ha_confs(prfx="tsun/garagendach/", snr='123'):
+    for d_json, comp, node_id, id in i.ha_confs(ha_prfx="tsun/", node_id="garagendach/", snr='123', singleton=False):
 
         if id == 'out_power_123':
             assert comp == 'sensor'
@@ -61,58 +227,304 @@ def test_build_ha_conf1(ContrDataSeq):
 
         elif id == 'daily_gen_123':
             assert comp == 'sensor'
-            assert  d_json == json.dumps({"name": "Daily Generation", "stat_t": "tsun/garagendach/total", "dev_cla": "energy", "stat_cla": "total_increasing", "uniq_id": "daily_gen_123", "val_tpl": "{{value_json['Daily_Generation'] | float}}", "unit_of_meas": "kWh", "icon": "mdi:solar-power-variant", "dev": {"name": "Micro Inverter", "sa": "Micro Inverter", "via_device": "controller_123", "ids": ["inverter_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
+            assert  d_json == json.dumps({"name": "Daily Generation", "stat_t": "tsun/garagendach/total", "dev_cla": "energy", "stat_cla": "total_increasing", "uniq_id": "daily_gen_123", "val_tpl": "{{value_json['Daily_Generation'] | float}}", "unit_of_meas": "kWh", "ic": "mdi:solar-power-variant", "dev": {"name": "Micro Inverter", "sa": "Micro Inverter", "via_device": "controller_123", "ids": ["inverter_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
             tests +=1
 
         elif id == 'power_pv1_123':
             assert comp == 'sensor'
-            assert  d_json == json.dumps({"name": "Power", "stat_t": "tsun/garagendach/input", "dev_cla": "power", "stat_cla": "measurement", "uniq_id": "power_pv1_123", "val_tpl": "{{ (value_json['pv1']['Power'] | float)}}", "unit_of_meas": "W", "icon": "mdi:gauge", "dev": {"name": "Module PV1", "sa": "Module PV1", "via_device": "inverter_123", "ids": ["input_pv1_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
+            assert  d_json == json.dumps({"name": "Power", "stat_t": "tsun/garagendach/input", "dev_cla": "power", "stat_cla": "measurement", "uniq_id": "power_pv1_123", "val_tpl": "{{ (value_json['pv1']['Power'] | float)}}", "unit_of_meas": "W", "dev": {"name": "Module PV1", "sa": "Module PV1", "via_device": "inverter_123", "ids": ["input_pv1_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
             tests +=1
 
         elif id == 'power_pv2_123':
-            assert comp == 'sensor'
-            assert  d_json == json.dumps({"name": "Power", "stat_t": "tsun/garagendach/input", "dev_cla": "power", "stat_cla": "measurement", "uniq_id": "power_pv2_123", "val_tpl": "{{ (value_json['pv2']['Power'] | float)}}", "unit_of_meas": "W", "icon": "mdi:gauge", "dev": {"name": "Module PV2", "sa": "Module PV2", "via_device": "inverter_123", "ids": ["input_pv2_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
-            tests +=1
+            assert False    # if we haven't received and parsed a control data msg, we don't know the number of inputs. In this case we only register the first one!!
+
 
         elif id == 'signal_123':
             assert comp == 'sensor'
-            assert  d_json == json.dumps({"name": "Signal Strength", "stat_t": "tsun/garagendach/controller", "dev_cla": None, "stat_cla": "measurement", "uniq_id": "signal_123", "val_tpl": "{{value_json[\'Signal_Strength\'] | int}}", "unit_of_meas": "%", "icon": "mdi:wifi", "dev": {"name": "Controller", "sa": "Controller", "ids": ["controller_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
+            assert  d_json == json.dumps({"name": "Signal Strength", "stat_t": "tsun/garagendach/controller", "dev_cla": None, "stat_cla": "measurement", "uniq_id": "signal_123", "val_tpl": "{{value_json[\'Signal_Strength\'] | int}}", "unit_of_meas": "%", "ic": "mdi:wifi", "dev": {"name": "Controller", "sa": "Controller", "via_device": "proxy", "ids": ["controller_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
             tests +=1
+        elif id == 'inv_count_456':
+            assert False
+
+    assert tests==4
+
+
+    for d_json, comp, node_id, id in i.ha_confs(ha_prfx="tsun/", node_id = 'proxy/', snr = '456', singleton=True):
+
+        if id == 'out_power_123':
+            assert False
+        elif id == 'daily_gen_123':
+            assert False
+        elif id == 'power_pv1_123':
+            assert False
+        elif id == 'power_pv2_123':
+            assert False    # if we haven't received and parsed a control data msg, we don't know the number of inputs. In this case we only register the first one!!
+
+        elif id == 'signal_123':
+            assert False
+        elif id == 'inv_count_456':
+            assert comp == 'sensor'
+            assert  d_json == json.dumps({"name": "Active Inverter Connections", "stat_t": "tsun/proxy/proxy", "dev_cla": None, "stat_cla": None, "uniq_id": "inv_count_456", "val_tpl": "{{value_json['Inverter_Cnt'] | int}}", "ic": "mdi:counter", "dev": {"name": "Proxy", "sa": "Proxy", "mdl": "proxy", "mf": "Stefan Allius", "sw": "unknown", "ids": ["proxy"]}, "o": {"name": "proxy", "sw": "unknown"}})
+            tests +=1
+
     assert tests==5
 
-def test_build_ha_conf2(ContrDataSeq, InvDataSeq):
+def test_build_ha_conf2(ContrDataSeq, InvDataSeq, InvDataSeq2):
     i = Infos()
     for key, result in i.parse (ContrDataSeq):
         pass
-
     for key, result in i.parse (InvDataSeq):
         pass
+    for key, result in i.parse (InvDataSeq2):
+        pass
 
     tests = 0
-    for d_json, comp, id in i.ha_confs(prfx="tsun/garagendach/", snr='123'):
+    for d_json, comp, node_id, id in i.ha_confs(ha_prfx="tsun/", node_id="garagendach/", snr='123', singleton=False, sug_area = 'roof'):
 
         if id == 'out_power_123':
             assert comp == 'sensor'
-            assert  d_json == json.dumps({"name": "Power", "stat_t": "tsun/garagendach/grid", "dev_cla": "power", "stat_cla": "measurement", "uniq_id": "out_power_123", "val_tpl": "{{value_json['Output_Power'] | float}}", "unit_of_meas": "W", "dev": {"name": "Micro Inverter", "sa": "Micro Inverter", "via_device": "controller_123", "mdl": "TSOL-MS600", "mf": "TSUN", "sw": "V5.0.11", "ids": ["inverter_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
+            assert  d_json == json.dumps({"name": "Power", "stat_t": "tsun/garagendach/grid", "dev_cla": "power", "stat_cla": "measurement", "uniq_id": "out_power_123", "val_tpl": "{{value_json['Output_Power'] | float}}", "unit_of_meas": "W", "dev": {"name": "Micro Inverter - roof", "sa": "Micro Inverter - roof", "via_device": "controller_123", "mdl": "TSOL-MS600", "mf": "TSUN", "sw": "V5.0.11", "ids": ["inverter_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
             tests +=1
 
-        elif id == 'daily_gen_123':
+        if id == 'daily_gen_123':
             assert comp == 'sensor'
-            assert  d_json == json.dumps({"name": "Daily Generation", "stat_t": "tsun/garagendach/total", "dev_cla": "energy", "stat_cla": "total_increasing", "uniq_id": "daily_gen_123", "val_tpl": "{{value_json['Daily_Generation'] | float}}", "unit_of_meas": "kWh", "icon": "mdi:solar-power-variant", "dev": {"name": "Micro Inverter", "sa": "Micro Inverter", "via_device": "controller_123", "mdl": "TSOL-MS600", "mf": "TSUN", "sw": "V5.0.11", "ids": ["inverter_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
+            assert  d_json == json.dumps({"name": "Daily Generation", "stat_t": "tsun/garagendach/total", "dev_cla": "energy", "stat_cla": "total_increasing", "uniq_id": "daily_gen_123", "val_tpl": "{{value_json['Daily_Generation'] | float}}", "unit_of_meas": "kWh", "ic": "mdi:solar-power-variant", "dev": {"name": "Micro Inverter - roof", "sa": "Micro Inverter - roof", "via_device": "controller_123", "mdl": "TSOL-MS600", "mf": "TSUN", "sw": "V5.0.11", "ids": ["inverter_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
             tests +=1
 
         elif id == 'power_pv1_123':
             assert comp == 'sensor'
-            assert  d_json == json.dumps({"name": "Power", "stat_t": "tsun/garagendach/input", "dev_cla": "power", "stat_cla": "measurement", "uniq_id": "power_pv1_123", "val_tpl": "{{ (value_json['pv1']['Power'] | float)}}", "unit_of_meas": "W", "icon": "mdi:gauge", "dev": {"name": "Module PV1", "sa": "Module PV1", "via_device": "inverter_123", "ids": ["input_pv1_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
+            assert  d_json == json.dumps({"name": "Power", "stat_t": "tsun/garagendach/input", "dev_cla": "power", "stat_cla": "measurement", "uniq_id": "power_pv1_123", "val_tpl": "{{ (value_json['pv1']['Power'] | float)}}", "unit_of_meas": "W", "dev": {"name": "Module PV1 - roof", "sa": "Module PV1 - roof", "via_device": "inverter_123", "ids": ["input_pv1_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
             tests +=1
 
         elif id == 'power_pv2_123':
             assert comp == 'sensor'
-            assert  d_json == json.dumps({"name": "Power", "stat_t": "tsun/garagendach/input", "dev_cla": "power", "stat_cla": "measurement", "uniq_id": "power_pv2_123", "val_tpl": "{{ (value_json['pv2']['Power'] | float)}}", "unit_of_meas": "W", "icon": "mdi:gauge", "dev": {"name": "Module PV2", "sa": "Module PV2", "via_device": "inverter_123", "ids": ["input_pv2_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
+            assert  d_json == json.dumps({"name": "Power", "stat_t": "tsun/garagendach/input", "dev_cla": "power", "stat_cla": "measurement", "uniq_id": "power_pv2_123", "val_tpl": "{{ (value_json['pv2']['Power'] | float)}}", "unit_of_meas": "W", "dev": {"name": "Module PV2 - roof", "sa": "Module PV2 - roof", "via_device": "inverter_123", "ids": ["input_pv2_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
             tests +=1
 
         elif id == 'signal_123':
             assert comp == 'sensor'
-            assert  d_json == json.dumps({"name": "Signal Strength", "stat_t": "tsun/garagendach/controller", "dev_cla": None, "stat_cla": "measurement", "uniq_id": "signal_123", "val_tpl": "{{value_json[\'Signal_Strength\'] | int}}", "unit_of_meas": "%", "icon": "mdi:wifi", "dev": {"name": "Controller", "sa": "Controller", "mdl": "RSW-1-10001", "mf": "Raymon", "sw": "RSW_400_V1.00.06", "ids": ["controller_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
+            assert  d_json == json.dumps({"name": "Signal Strength", "stat_t": "tsun/garagendach/controller", "dev_cla": None, "stat_cla": "measurement", "uniq_id": "signal_123", "val_tpl": "{{value_json[\'Signal_Strength\'] | int}}", "unit_of_meas": "%", "ic": "mdi:wifi", "dev": {"name": "Controller - roof", "sa": "Controller - roof", "via_device": "proxy", "mdl": "RSW-1-10001", "mf": "Raymon", "sw": "RSW_400_V1.00.06", "ids": ["controller_123"]}, "o": {"name": "proxy", "sw": "unknown"}})
             tests +=1
     assert tests==5
+
+def test_must_incr_total(InvDataSeq2, InvDataSeq2_Zero):
+    i = Infos()
+    tests = 0
+    for key, update in i.parse (InvDataSeq2):
+        if key == 'total':
+            assert update == True
+            tests +=1   
+        elif key == 'env':
+            assert update == True
+            tests +=1
+
+
+    assert tests==4
+    assert json.dumps(i.db['total']) == json.dumps({'Daily_Generation': 1.7, 'Total_Generation': 17.36})
+    assert json.dumps(i.db['input']) == json.dumps({"pv1": {"Voltage": 33.6, "Current": 1.91, "Power": 64.5, "Daily_Generation": 1.08, "Total_Generation": 9.74}, "pv2": {"Voltage": 33.5, "Current": 1.36, "Power": 45.7, "Daily_Generation": 0.62, "Total_Generation": 7.62}, "pv3": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}, "pv4": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}})
+    assert json.dumps(i.db['env']) == json.dumps({"Inverter_Temp": 23, "Rated_Power": 600})
+    tests = 0
+    for key, update in i.parse (InvDataSeq2):
+        if key == 'total':
+            assert update == False
+            tests +=1   
+        elif key == 'env':
+            assert update == False
+            tests +=1
+
+
+    assert tests==4
+    assert json.dumps(i.db['total']) == json.dumps({'Daily_Generation': 1.7, 'Total_Generation': 17.36})
+    assert json.dumps(i.db['input']) == json.dumps({"pv1": {"Voltage": 33.6, "Current": 1.91, "Power": 64.5, "Daily_Generation": 1.08, "Total_Generation": 9.74}, "pv2": {"Voltage": 33.5, "Current": 1.36, "Power": 45.7, "Daily_Generation": 0.62, "Total_Generation": 7.62}, "pv3": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}, "pv4": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}})
+    assert json.dumps(i.db['env']) == json.dumps({"Inverter_Temp": 23, "Rated_Power": 600})
+        
+    tests = 0
+    for key, update in i.parse (InvDataSeq2_Zero):
+        if key == 'total':
+            assert update == False
+            tests +=1   
+        elif key == 'env':
+            assert update == True
+            tests +=1
+
+    assert tests==4
+    assert json.dumps(i.db['total']) == json.dumps({'Daily_Generation': 1.7, 'Total_Generation': 17.36})
+    assert json.dumps(i.db['input']) == json.dumps({"pv1": {"Voltage": 33.6, "Current": 1.91, "Power": 0.0, "Daily_Generation": 1.08, "Total_Generation": 9.74}, "pv2": {"Voltage": 33.5, "Current": 1.36, "Power": 0.0, "Daily_Generation": 0.62, "Total_Generation": 7.62}, "pv3": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}, "pv4": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}})
+    assert json.dumps(i.db['env']) == json.dumps({"Inverter_Temp": 0, "Rated_Power": 0})
+
+def test_must_incr_total2(InvDataSeq2, InvDataSeq2_Zero):
+    i = Infos()
+    tests = 0
+    for key, update in i.parse (InvDataSeq2_Zero):
+        if key == 'total':
+            assert update == False
+            tests +=1   
+        elif key == 'env':
+            assert update == True
+            tests +=1
+
+    assert tests==4
+    assert json.dumps(i.db['total']) == json.dumps({})
+    assert json.dumps(i.db['input']) == json.dumps({"pv1": {"Voltage": 33.6, "Current": 1.91, "Power": 0.0}, "pv2": {"Voltage": 33.5, "Current": 1.36, "Power": 0.0}, "pv3": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}, "pv4": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}})
+    assert json.dumps(i.db['env']) == json.dumps({"Inverter_Temp": 0, "Rated_Power": 0})
+    
+    tests = 0
+    for key, update in i.parse (InvDataSeq2_Zero):
+        if key == 'total':
+            assert update == False
+            tests +=1   
+        elif key == 'env':
+            assert update == False
+            tests +=1
+
+    assert tests==4
+    assert json.dumps(i.db['total']) == json.dumps({})
+    assert json.dumps(i.db['input']) == json.dumps({"pv1": {"Voltage": 33.6, "Current": 1.91, "Power": 0.0}, "pv2": {"Voltage": 33.5, "Current": 1.36, "Power": 0.0}, "pv3": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}, "pv4": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}})
+    assert json.dumps(i.db['env']) == json.dumps({"Inverter_Temp": 0, "Rated_Power": 0})
+
+    tests = 0
+    for key, update in i.parse (InvDataSeq2):
+        if key == 'total':
+            assert update == True
+            tests +=1   
+        elif key == 'env':
+            assert update == True
+            tests +=1
+
+    assert tests==4
+    assert json.dumps(i.db['total']) == json.dumps({'Daily_Generation': 1.7, 'Total_Generation': 17.36})
+    assert json.dumps(i.db['input']) == json.dumps({"pv1": {"Voltage": 33.6, "Current": 1.91, "Power": 64.5, "Daily_Generation": 1.08, "Total_Generation": 9.74}, "pv2": {"Voltage": 33.5, "Current": 1.36, "Power": 45.7, "Daily_Generation": 0.62, "Total_Generation": 7.62}, "pv3": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}, "pv4": {"Voltage": 0.0, "Current": 0.0, "Power": 0.0}})
+    assert json.dumps(i.db['env']) == json.dumps({"Inverter_Temp": 23, "Rated_Power": 600})
+
+
+def test_statistic_counter():
+    i = Infos()
+    val = i.dev_value("Test-String")
+    assert val == "Test-String"
+
+    val = i.dev_value(0xffffffff)  # invalid addr
+    assert val == None
+    
+    val = i.dev_value(0xffffff00)  # valid addr but not initiliazed
+    assert val == None or val == 0
+
+    i.static_init()                # initialize counter
+    assert json.dumps(i.stat) == json.dumps({"proxy": {"Inverter_Cnt": 0, "Unknown_SNR": 0, "Unknown_Msg": 0, "Invalid_Data_Type": 0, "Internal_Error": 0,"Unknown_Ctrl": 0, "OTA_Start_Msg": 0, "SW_Exception": 0}})
+                                            
+    val = i.dev_value(0xffffff00)  # valid and initiliazed addr
+    assert val == 0
+
+    i.inc_counter('Inverter_Cnt')
+    assert json.dumps(i.stat) == json.dumps({"proxy": {"Inverter_Cnt": 1, "Unknown_SNR": 0, "Unknown_Msg": 0, "Invalid_Data_Type": 0, "Internal_Error": 0,"Unknown_Ctrl": 0, "OTA_Start_Msg": 0, "SW_Exception": 0}})
+    val = i.dev_value(0xffffff00)
+    assert val == 1
+
+    i.dec_counter('Inverter_Cnt')
+    val = i.dev_value(0xffffff00)
+    assert val == 0
+
+def test_dep_rules():
+    i = Infos()
+    i.static_init()                # initialize counter
+
+    res = i.ignore_this_device({})
+    assert res == True
+
+    res = i.ignore_this_device({'reg':0xffffffff})
+    assert res == True
+
+    i.inc_counter('Inverter_Cnt')    # is 1
+    val = i.dev_value(0xffffff00)
+    assert val == 1
+    res = i.ignore_this_device({'reg':0xffffff00})
+    assert res == True
+    res = i.ignore_this_device({'reg':0xffffff00, 'less_eq': 2})
+    assert res == False
+    res = i.ignore_this_device({'reg':0xffffff00, 'gte': 2})
+    assert res == True
+
+    i.inc_counter('Inverter_Cnt')   # is 2
+    res = i.ignore_this_device({'reg':0xffffff00, 'less_eq': 2})
+    assert res == False
+    res = i.ignore_this_device({'reg':0xffffff00, 'gte': 2})
+    assert res == False
+
+    i.inc_counter('Inverter_Cnt')   # is 3
+    res = i.ignore_this_device({'reg':0xffffff00, 'less_eq': 2})
+    assert res == True
+    res = i.ignore_this_device({'reg':0xffffff00, 'gte': 2})
+    assert res == False
+
+def test_table_definition():
+    i = Infos()
+    i.static_init()                # initialize counter
+
+    val = i.dev_value(0xffffff04)  # check internal error counter
+    assert val == 0
+
+    for d_json, comp, node_id, id in i.ha_confs(ha_prfx="tsun/", node_id="garagendach/", snr='123', singleton=False, sug_area = 'roof'):
+        pass
+
+    for d_json, comp, node_id, id in i.ha_confs(ha_prfx="tsun/", node_id = 'proxy/', snr = '456', singleton=True, sug_area = 'roof'):
+        pass
+
+    val = i.dev_value(0xffffff04)  # check internal error counter
+    assert val == 0
+
+    # test missing 'fmt' value
+    Infos._Infos__info_defs[0xfffffffe] =  {'name':['proxy', 'Internal_Test1'],  'singleton': True, 'ha':{'dev':'proxy', 'dev_cla': None,       'stat_cla': None, 'id':'intern_test1_'}}
+
+    tests = 0
+    for d_json, comp, node_id, id in i.ha_confs(ha_prfx="tsun/", node_id = 'proxy/', snr = '456', singleton=True, sug_area = 'roof'):
+        if id == 'intern_test1_456':
+            tests +=1
+
+    assert tests == 1
+
+    val = i.dev_value(0xffffff04)  # check internal error counter
+    assert val == 1
+
+    # test missing 'dev' value
+    Infos._Infos__info_defs[0xfffffffe] =  {'name':['proxy', 'Internal_Test2'],  'singleton': True, 'ha':{'dev_cla': None,       'stat_cla': None, 'id':'intern_test2_',  'fmt':'| int'}}
+    tests = 0
+    for d_json, comp, node_id, id in i.ha_confs(ha_prfx="tsun/", node_id = 'proxy/', snr = '456', singleton=True, sug_area = 'roof'):
+        if id == 'intern_test2_456':
+            tests +=1
+
+    assert tests == 1
+
+    val = i.dev_value(0xffffff04)  # check internal error counter
+    assert val == 2
+
+
+
+    # test invalid 'via' value
+    Infos._Infos__info_devs['test_dev'] = {'via':'xyz',   'name':'Module PV1'}
+
+    Infos._Infos__info_defs[0xfffffffe] =  {'name':['proxy', 'Internal_Test2'],  'singleton': True, 'ha':{'dev':'test_dev', 'dev_cla': None,       'stat_cla': None, 'id':'intern_test2_',  'fmt':'| int'}}
+    tests = 0
+    for d_json, comp, node_id, id in i.ha_confs(ha_prfx="tsun/", node_id = 'proxy/', snr = '456', singleton=True, sug_area = 'roof'):
+        if id == 'intern_test2_456':
+            tests +=1
+
+    assert tests == 1
+
+    val = i.dev_value(0xffffff04)  # check internal error counter
+    assert val == 3
+
+
+def test_invalid_data_type(InvalidDataSeq):
+    i = Infos()
+    i.static_init()                # initialize counter
+
+    val = i.dev_value(0xffffff03)  # check invalid data type counter
+    assert val == 0
+
+
+    for key, result in i.parse (InvalidDataSeq):
+        pass
+    assert json.dumps(i.db) == json.dumps({"inverter": {"Product_Name": "Microinv"}})
+
+    val = i.dev_value(0xffffff03)  # check invalid data type counter
+    assert val == 1
+

app/tests/test_messages.py

@@ -1,21 +1,29 @@
 # test_with_pytest.py
-import pytest
+import pytest, logging
 from app.src.messages import Message, Control
 from app.src.config import Config
+from app.src.infos import Infos
 
+# initialize the proxy statistics
+Infos.static_init()
 
+tracer = logging.getLogger('tracer')
+    
 class MemoryStream(Message):
-    def __init__(self, msg, chunks = (0,)):
-        super().__init__()
+    def __init__(self, msg, chunks = (0,), server_side: bool = True):
+        super().__init__(server_side)
         self.__msg = msg
         self.__msg_len = len(msg)
         self.__chunks = chunks
         self.__offs = 0
         self.__chunk_idx = 0
         self.msg_count = 0
-        self.server_side = False
         self.addr = 'Test: SrvSide'
 
+    def append_msg(self, msg):
+        self.__msg += msg
+        self.__msg_len += len(msg)    
+
     def _read(self) -> int:
         copied_bytes = 0
         try:    
@@ -34,15 +42,14 @@ class MemoryStream(Message):
             pass     
         return copied_bytes
     
+    def _timestamp(self):
+        return 1700260990000
     
     def _Message__flush_recv_msg(self) -> None:
         super()._Message__flush_recv_msg()
         self.msg_count += 1
         return
     
-    def __del__ (self):
-        super().__del__()
-
 
 @pytest.fixture
 def MsgContactInfo(): # Contact Info message
@@ -56,10 +63,112 @@ def MsgContactInfo_LongId():  # Contact Info message with longer ID
 
 @pytest.fixture
 def Msg2ContactInfo(): # two Contact Info messages
-    Config.config = {'tsun':{'enabled': True}}
     return b'\x00\x00\x00\x2c\x10R170000000000001\x91\x00\x08solarhub\x0fsolarhub\x40123456\x00\x00\x00\x2c\x10R170000000000002\x91\x00\x08solarhub\x0fsolarhub\x40123456'
 
+@pytest.fixture
+def MsgContactResp(): # Contact Response message
+    return b'\x00\x00\x00\x14\x10R170000000000001\x91\x00\x01'
 
+@pytest.fixture
+def MsgContactResp2(): # Contact Response message
+    return b'\x00\x00\x00\x14\x10R170000000000002\x91\x00\x01'
+
+@pytest.fixture
+def MsgContactInvalid(): # Contact Response message
+    return b'\x00\x00\x00\x14\x10R170000000000001\x93\x00\x01'
+
+@pytest.fixture
+def MsgGetTime(): # Get Time Request message
+    return b'\x00\x00\x00\x13\x10R170000000000001\x91\x22'           
+
+@pytest.fixture
+def MsgTimeResp(): # Get Time Resonse message
+    return b'\x00\x00\x00\x1b\x10R170000000000001\x91\x22\x00\x00\x01\x89\xc6\x63\x4d\x80'
+
+@pytest.fixture
+def MsgTimeInvalid(): # Get Time Request message
+    return b'\x00\x00\x00\x13\x10R170000000000001\x94\x22'           
+
+@pytest.fixture
+def MsgControllerInd(): # Data indication from the controller
+    msg  =  b'\x00\x00\x01\x2f\x10R170000000000001\x91\x71\x0e\x10\x00\x00\x10R170000000000001'
+    msg +=  b'\x01\x00\x00\x01\x89\xc6\x63\x55\x50'
+    msg +=  b'\x00\x00\x00\x15\x00\x09\x2b\xa8\x54\x10\x52\x53\x57\x5f\x34\x30\x30\x5f\x56\x31\x2e\x30\x30\x2e\x30\x36\x00\x09\x27\xc0\x54\x06\x52\x61\x79\x6d\x6f'
+    msg +=  b'\x6e\x00\x09\x2f\x90\x54\x0b\x52\x53\x57\x2d\x31\x2d\x31\x30\x30\x30\x31\x00\x09\x5a\x88\x54\x0f\x74\x2e\x72\x61\x79\x6d\x6f\x6e\x69\x6f\x74\x2e\x63\x6f\x6d\x00\x09\x5a\xec\x54'
+    msg +=  b'\x1c\x6c\x6f\x67\x67\x65\x72\x2e\x74\x61\x6c\x65\x6e\x74\x2d\x6d\x6f\x6e\x69\x74\x6f\x72\x69\x6e\x67\x2e\x63\x6f\x6d\x00\x0d\x00\x20\x49\x00\x00\x00\x01\x00\x0c\x35\x00\x49\x00'
+    msg +=  b'\x00\x00\x64\x00\x0c\x96\xa8\x49\x00\x00\x00\x1d\x00\x0c\x7f\x38\x49\x00\x00\x00\x01\x00\x0c\xfc\x38\x49\x00\x00\x00\x01\x00\x0c\xf8\x50\x49\x00\x00\x01\x2c\x00\x0c\x63\xe0\x49'
+    msg +=  b'\x00\x00\x00\x00\x00\x0c\x67\xc8\x49\x00\x00\x00\x00\x00\x0c\x50\x58\x49\x00\x00\x00\x01\x00\x09\x5e\x70\x49\x00\x00\x13\x8d\x00\x09\x5e\xd4\x49\x00\x00\x13\x8d\x00\x09\x5b\x50'
+    msg +=  b'\x49\x00\x00\x00\x02\x00\x0d\x04\x08\x49\x00\x00\x00\x00\x00\x07\xa1\x84\x49\x00\x00\x00\x01\x00\x0c\x50\x59\x49\x00\x00\x00\x4c\x00\x0d\x1f\x60\x49\x00\x00\x00\x00'
+    return msg
+
+@pytest.fixture
+def MsgControllerAck(): # Get Time Request message
+    return b'\x00\x00\x00\x14\x10R170000000000001\x99\x71\x01'
+
+@pytest.fixture
+def MsgControllerInvalid(): # Get Time Request message
+    return b'\x00\x00\x00\x14\x10R170000000000001\x92\x71\x01'
+
+@pytest.fixture
+def MsgInverterInd(): # Data indication from the controller
+    msg  =  b'\x00\x00\x00\x8b\x10R170000000000001\x91\x04\x01\x90\x00\x01\x10R170000000000001'
+    msg +=  b'\x01\x00\x00\x01\x89\xc6\x63\x61\x08'
+    msg +=  b'\x00\x00\x00\x06\x00\x00\x00\x0a\x54\x08\x4d\x69\x63\x72\x6f\x69\x6e\x76\x00\x00\x00\x14\x54\x04\x54\x53\x55\x4e\x00\x00\x00\x1E\x54\x07\x56\x35\x2e\x30\x2e\x31\x31\x00\x00\x00\x28'
+    msg +=  b'\x54\x10T170000000000001\x00\x00\x00\x32\x54\x0a\x54\x53\x4f\x4c\x2d\x4d\x53\x36\x30\x30\x00\x00\x00\x3c\x54\x05\x41\x2c\x42\x2c\x43'
+    return msg
+
+@pytest.fixture
+def MsgInverterAck(): # Get Time Request message
+    return b'\x00\x00\x00\x14\x10R170000000000001\x99\x04\x01'
+
+@pytest.fixture
+def MsgInverterInvalid(): # Get Time Request message
+    return b'\x00\x00\x00\x14\x10R170000000000001\x92\x04\x01'
+
+@pytest.fixture
+def MsgUnknown(): # Get Time Request message
+    return b'\x00\x00\x00\x17\x10R170000000000001\x91\x17\x01\x02\x03\x04'
+
+@pytest.fixture
+def ConfigTsunAllowAll():
+    Config.config = {'tsun':{'enabled': True}, 'inverters':{'allow_all':True}}
+
+@pytest.fixture
+def ConfigNoTsunInv1():
+    Config.config = {'tsun':{'enabled': False},'inverters':{'R170000000000001':{'node_id':'inv1','suggested_area':'roof'}}}
+
+@pytest.fixture
+def ConfigTsunInv1():
+    Config.config = {'tsun':{'enabled': True},'inverters':{'R170000000000001':{'node_id':'inv1','suggested_area':'roof'}}}
+
+@pytest.fixture
+def MsgOtaReq(): # Over the air update rewuest from tsun cloud
+    msg  =  b'\x00\x00\x01\x16\x10R170000000000001\x70\x13\x01\x02\x76\x35\x70\x68\x74\x74\x70'
+    msg +=  b'\x3a\x2f\x2f\x77\x77\x77\x2e\x74\x61\x6c\x65\x6e\x74\x2d\x6d\x6f'
+    msg +=  b'\x6e\x69\x74\x6f\x72\x69\x6e\x67\x2e\x63\x6f\x6d\x3a\x39\x30\x30'
+    msg +=  b'\x32\x2f\x70\x72\x6f\x64\x2d\x61\x70\x69\x2f\x72\x6f\x6d\x2f\x75'
+    msg +=  b'\x70\x64\x61\x74\x65\x2f\x64\x6f\x77\x6e\x6c\x6f\x61\x64\x3f\x76'
+    msg +=  b'\x65\x72\x3d\x56\x31\x2e\x30\x30\x2e\x31\x37\x26\x6e\x61\x6d\x65'
+    msg +=  b'\x3d\x47\x33\x2d\x57\x69\x46\x69\x2b\x2d\x56\x31\x2e\x30\x30\x2e'
+    msg +=  b'\x31\x37\x2d\x4f\x54\x41\x26\x65\x78\x74\x3d\x30\x60\x68\x74\x74'
+    msg +=  b'\x70\x3a\x2f\x2f\x77\x77\x77\x2e\x74\x61\x6c\x65\x6e\x74\x2d\x6d'
+    msg +=  b'\x6f\x6e\x69\x74\x6f\x72\x69\x6e\x67\x2e\x63\x6f\x6d\x3a\x39\x30'
+    msg +=  b'\x30\x32\x2f\x70\x72\x6f\x64\x2d\x61\x70\x69\x2f\x72\x6f\x6d\x2f'
+    msg +=  b'\x75\x70\x64\x61\x74\x65\x2f\x63\x61\x6c\x6c\x62\x61\x63\x6b\x3f'
+    msg +=  b'\x71\x69\x64\x3d\x31\x35\x30\x33\x36\x32\x26\x72\x69\x64\x3d\x32'
+    msg +=  b'\x32\x39\x26\x64\x69\x64\x3d\x31\x33\x34\x32\x32\x35\x20\x36\x35'
+    msg +=  b'\x66\x30\x64\x37\x34\x34\x62\x66\x33\x39\x61\x62\x38\x32\x34\x64'
+    msg +=  b'\x32\x38\x62\x38\x34\x64\x31\x39\x65\x64\x33\x31\x31\x63\x06\x34'
+    msg +=  b'\x36\x38\x36\x33\x33\x01\x31\x01\x30\x00'  
+    return msg    
+
+@pytest.fixture
+def MsgOtaAck(): # Over the air update rewuest from tsun cloud
+    return b'\x00\x00\x00\x14\x10R170000000000001\x91\x13\x01'
+
+@pytest.fixture
+def MsgOtaInvalid(): # Get Time Request message
+    return b'\x00\x00\x00\x14\x10R170000000000001\x99\x13\x01'
 
 
 def test_read_message(MsgContactInfo):
@@ -68,11 +177,39 @@ def test_read_message(MsgContactInfo):
     assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
     assert m.msg_count == 1
     assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == None
     assert int(m.ctrl)==145
     assert m.msg_id==0 
     assert m.header_len==23
     assert m.data_len==25
+    assert m._forward_buffer==b''
+    m.close()
 
+def test_read_message_twice(ConfigNoTsunInv1, MsgInverterInd):
+    ConfigNoTsunInv1
+    m = MemoryStream(MsgInverterInd, (0,))
+    m.append_msg(MsgInverterInd)
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==4
+    assert m.header_len==23
+    assert m.data_len==120
+    assert m._forward_buffer==b''
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 2
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==4
+    assert m.header_len==23
+    assert m.data_len==120
+    assert m._forward_buffer==b''
+    m.close()
  
 def test_read_message_long_id(MsgContactInfo_LongId):
     m = MemoryStream(MsgContactInfo_LongId, (23,24))
@@ -83,6 +220,7 @@ def test_read_message_long_id(MsgContactInfo_LongId):
     assert m.header_valid      # must be valid, since header is complete but not the msg
     assert m.msg_count == 0
     assert m.id_str == b"R1700000000000011" 
+    assert m.unique_id == 0
     assert int(m.ctrl)==145
     assert m.msg_id==0 
     assert m.header_len==24
@@ -90,6 +228,7 @@ def test_read_message_long_id(MsgContactInfo_LongId):
     m.read()        # try to read rest of message, but there is no chunk available
     assert m.header_valid      # must be valid, since header is complete but not the msg
     assert m.msg_count == 0
+    m.close()
     
 
 def test_read_message_in_chunks(MsgContactInfo):
@@ -101,6 +240,7 @@ def test_read_message_in_chunks(MsgContactInfo):
     assert m.header_valid      # must be valid, since header is complete but not the msg
     assert m.msg_count == 0
     assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 0
     assert int(m.ctrl)==145
     assert m.msg_id==0 
     assert m.header_len==23
@@ -108,6 +248,7 @@ def test_read_message_in_chunks(MsgContactInfo):
     m.read()    # read rest of message
     assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
     assert m.msg_count == 1
+    m.close()
     
 def test_read_message_in_chunks2(MsgContactInfo):
     m = MemoryStream(MsgContactInfo, (4,10,0))
@@ -122,6 +263,7 @@ def test_read_message_in_chunks2(MsgContactInfo):
     assert m.header_len==23
     assert m.data_len==25
     assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == None
     assert int(m.ctrl)==145
     assert m.msg_id==0 
     assert m.msg_count == 1
@@ -129,25 +271,424 @@ def test_read_message_in_chunks2(MsgContactInfo):
         pass
     assert m.msg_count == 1
     assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    m.close()
 
-def test_read_two_messages(Msg2ContactInfo):
+def test_read_two_messages(ConfigTsunAllowAll, Msg2ContactInfo,MsgContactResp,MsgContactResp2):
+    ConfigTsunAllowAll
     m = MemoryStream(Msg2ContactInfo, (0,))
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
     m.read()         # read complete msg, and dispatch msg
     assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
     assert m.msg_count == 1
     assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
     assert int(m.ctrl)==145
     assert m.msg_id==0 
     assert m.header_len==23
     assert m.data_len==25
+    assert m._forward_buffer==b''
+    assert m._send_buffer==MsgContactResp
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+
+    m._send_buffer = bytearray(0) # clear send buffer for next test
+    m._init_new_client_conn(b'solarhub', b'solarhub@123456')
+    assert m._send_buffer==b'\x00\x00\x00,\x10R170000000000001\x91\x00\x08solarhub\x0fsolarhub@123456'
+
+    m._send_buffer = bytearray(0) # clear send buffer for next test
     m.read()         # read complete msg, and dispatch msg
     assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
     assert m.msg_count == 2
     assert m.id_str == b"R170000000000002" 
+    assert m.unique_id == 'R170000000000002'
     assert int(m.ctrl)==145
     assert m.msg_id==0 
     assert m.header_len==23
     assert m.data_len==25
+    assert m._forward_buffer==b''
+    assert m._send_buffer==MsgContactResp2
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+
+    m._send_buffer = bytearray(0) # clear send buffer for next test
+    m._init_new_client_conn(b'solarhub', b'solarhub@123456')
+    assert m._send_buffer==b'\x00\x00\x00,\x10R170000000000002\x91\x00\x08solarhub\x0fsolarhub@123456'
+    m.close()
+
+def test_msg_contact_resp(ConfigTsunInv1, MsgContactResp):
+    ConfigTsunInv1
+    m = MemoryStream(MsgContactResp, (0,), False)
+    m.await_conn_resp_cnt = 1
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.await_conn_resp_cnt == 0
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==0
+    assert m.header_len==23
+    assert m.data_len==1
+    assert m._forward_buffer==b''
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+
+def test_msg_contact_resp_2(ConfigTsunInv1, MsgContactResp):
+    ConfigTsunInv1
+    m = MemoryStream(MsgContactResp, (0,), False)
+    m.await_conn_resp_cnt = 0
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.await_conn_resp_cnt == 0
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==0
+    assert m.header_len==23
+    assert m.data_len==1
+    assert m._forward_buffer==MsgContactResp
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+
+def test_msg_contact_resp_3(ConfigTsunInv1, MsgContactResp):
+    ConfigTsunInv1
+    m = MemoryStream(MsgContactResp, (0,), True)
+    m.await_conn_resp_cnt = 0
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.await_conn_resp_cnt == 0
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==0
+    assert m.header_len==23
+    assert m.data_len==1
+    assert m._forward_buffer==MsgContactResp
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+
+def test_msg_contact_invalid(ConfigTsunInv1, MsgContactInvalid):
+    ConfigTsunInv1
+    m = MemoryStream(MsgContactInvalid, (0,))
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==147
+    assert m.msg_id==0
+    assert m.header_len==23
+    assert m.data_len==1
+    assert m._forward_buffer==MsgContactInvalid
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 1
+    m.close()
+
+def test_msg_get_time(ConfigTsunInv1, MsgGetTime):
+    ConfigTsunInv1
+    m = MemoryStream(MsgGetTime, (0,))
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==34
+    assert m.header_len==23
+    assert m.data_len==0
+    assert m._forward_buffer==MsgGetTime
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+
+def test_msg_get_time_autark(ConfigNoTsunInv1, MsgGetTime):
+    ConfigNoTsunInv1
+    m = MemoryStream(MsgGetTime, (0,))
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==34
+    assert m.header_len==23
+    assert m.data_len==0
+    assert m._forward_buffer==b''
+    assert m._send_buffer==b'\x00\x00\x00\x1b\x10R170000000000001\x91"\x00\x00\x01\x8b\xdfs\xcc0'
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+
+def test_msg_time_resp(ConfigTsunInv1, MsgTimeResp):
+    ConfigTsunInv1
+    m = MemoryStream(MsgTimeResp, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==34
+    assert m.header_len==23
+    assert m.data_len==8
+    assert m._forward_buffer==MsgTimeResp
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+
+def test_msg_time_resp_autark(ConfigNoTsunInv1, MsgTimeResp):
+    ConfigNoTsunInv1
+    m = MemoryStream(MsgTimeResp, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==34
+    assert m.header_len==23
+    assert m.data_len==8
+    assert m._forward_buffer==b''
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+
+def test_msg_time_invalid(ConfigTsunInv1, MsgTimeInvalid):
+    ConfigTsunInv1
+    m = MemoryStream(MsgTimeInvalid, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==148
+    assert m.msg_id==34
+    assert m.header_len==23
+    assert m.data_len==0
+    assert m._forward_buffer==MsgTimeInvalid
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 1
+    m.close()
+
+def test_msg_time_invalid_autark(ConfigNoTsunInv1, MsgTimeInvalid):
+    ConfigNoTsunInv1
+    m = MemoryStream(MsgTimeInvalid, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==148
+    assert m.msg_id==34
+    assert m.header_len==23
+    assert m.data_len==0
+    assert m._forward_buffer==b''
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 1
+    m.close()
+
+def test_msg_cntrl_ind(ConfigTsunInv1, MsgControllerInd, MsgControllerAck):
+    ConfigTsunInv1
+    m = MemoryStream(MsgControllerInd, (0,))
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==113
+    assert m.header_len==23
+    assert m.data_len==284
+    assert m._forward_buffer==MsgControllerInd
+    assert m._send_buffer==MsgControllerAck
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+
+def test_msg_cntrl_ack(ConfigTsunInv1, MsgControllerAck):
+    ConfigTsunInv1
+    m = MemoryStream(MsgControllerAck, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==153
+    assert m.msg_id==113
+    assert m.header_len==23
+    assert m.data_len==1
+    assert m._forward_buffer==b''
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+
+def test_msg_cntrl_invalid(ConfigTsunInv1, MsgControllerInvalid):
+    ConfigTsunInv1
+    m = MemoryStream(MsgControllerInvalid, (0,))
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==146
+    assert m.msg_id==113
+    assert m.header_len==23
+    assert m.data_len==1
+    assert m._forward_buffer==MsgControllerInvalid
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 1
+    m.close()
+
+def test_msg_inv_ind(ConfigTsunInv1, MsgInverterInd, MsgInverterAck):
+    ConfigTsunInv1
+    tracer.setLevel(logging.DEBUG)
+    m = MemoryStream(MsgInverterInd, (0,))
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==4
+    assert m.header_len==23
+    assert m.data_len==120
+    assert m._forward_buffer==MsgInverterInd
+    assert m._send_buffer==MsgInverterAck
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+        
+def test_msg_inv_ack(ConfigTsunInv1, MsgInverterAck):
+    ConfigTsunInv1
+    tracer.setLevel(logging.ERROR)
+
+    m = MemoryStream(MsgInverterAck, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==153
+    assert m.msg_id==4
+    assert m.header_len==23
+    assert m.data_len==1
+    assert m._forward_buffer==b''
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    m.close()
+
+def test_msg_inv_invalid(ConfigTsunInv1, MsgInverterInvalid):
+    ConfigTsunInv1
+    m = MemoryStream(MsgInverterInvalid, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==146
+    assert m.msg_id==4
+    assert m.header_len==23
+    assert m.data_len==1
+    assert m._forward_buffer==MsgInverterInvalid
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 1
+    m.close()
+
+def test_msg_ota_req(ConfigTsunInv1, MsgOtaReq):
+    ConfigTsunInv1
+    m = MemoryStream(MsgOtaReq, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.db.stat['proxy']['OTA_Start_Msg'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==112
+    assert m.msg_id==19
+    assert m.header_len==23
+    assert m.data_len==259
+    assert m._forward_buffer==MsgOtaReq
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    assert m.db.stat['proxy']['OTA_Start_Msg'] == 1
+    m.close()
+
+def test_msg_ota_ack(ConfigTsunInv1, MsgOtaAck):
+    ConfigTsunInv1
+    tracer.setLevel(logging.ERROR)
+
+    m = MemoryStream(MsgOtaAck, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.db.stat['proxy']['OTA_Start_Msg'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==19
+    assert m.header_len==23
+    assert m.data_len==1
+    assert m._forward_buffer==MsgOtaAck
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+    assert m.db.stat['proxy']['OTA_Start_Msg'] == 0
+    m.close()
+
+def test_msg_ota_invalid(ConfigTsunInv1, MsgOtaInvalid):
+    ConfigTsunInv1
+    m = MemoryStream(MsgOtaInvalid, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.db.stat['proxy']['OTA_Start_Msg'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==153
+    assert m.msg_id==19
+    assert m.header_len==23
+    assert m.data_len==1
+    assert m._forward_buffer==MsgOtaInvalid
+    assert m._send_buffer==b''
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 1
+    assert m.db.stat['proxy']['OTA_Start_Msg'] == 0
+    m.close()
+
+def test_msg_unknown(ConfigTsunInv1, MsgUnknown):
+    ConfigTsunInv1
+    m = MemoryStream(MsgUnknown, (0,), False)
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.id_str == b"R170000000000001" 
+    assert m.unique_id == 'R170000000000001'
+    assert int(m.ctrl)==145
+    assert m.msg_id==23
+    assert m.header_len==23
+    assert m.data_len==4
+    assert m._forward_buffer==MsgUnknown
+    assert m._send_buffer==b''
+    assert 1 == m.db.stat['proxy']['Unknown_Msg']
+    m.close()
 
 def test_ctrl_byte():
     c = Control(0x91)
@@ -158,3 +699,38 @@ def test_ctrl_byte():
     assert c.is_resp()    
 
     
+def test_msg_iterator():
+    m1 = Message(server_side=True)
+    m2 = Message(server_side=True)
+    m3 = Message(server_side=True)
+    m3.close()
+    del m3
+    test1 = 0
+    test2 = 0
+    for key in Message:
+        if key == m1:
+            test1+=1
+        elif key == m2:
+            test2+=1
+        else:
+            assert False
+    assert test1 == 1
+    assert test2 == 1
+
+def test_proxy_counter():
+    m = Message(server_side=True)
+    assert m.new_data == {}
+    m.db.stat['proxy']['Unknown_Msg'] = 0
+    m.new_stat_data['proxy'] =  False
+
+    m.inc_counter('Unknown_Msg')
+    assert m.new_data == {}
+    assert m.new_stat_data == {'proxy': True}
+    assert 1 == m.db.stat['proxy']['Unknown_Msg']
+
+    m.new_stat_data['proxy'] =  False
+    m.dec_counter('Unknown_Msg')
+    assert m.new_data == {}
+    assert m.new_stat_data == {'proxy': True}
+    assert 0 == m.db.stat['proxy']['Unknown_Msg']
+    m.close()

docker-compose.yaml

@@ -52,6 +52,7 @@ services:
   mqtt:
     container_name: mqtt-broker
     image: eclipse-mosquitto:2
+    restart: unless-stopped
     expose:
       - 1883
     volumes:

system_tests/test_tcp_socket.py

@@ -0,0 +1,242 @@
+# test_with_pytest.py and scapy
+#
+import pytest, socket, time
+#from scapy.all import *
+#from scapy.layers.inet import IP, TCP, TCP_client
+
+def get_sn() -> bytes:
+    return b'R170000000000001'
+
+def get_inv_no() -> bytes:
+    return b'T170000000000001'
+
+def get_invalid_sn():
+    return b'R170000000000002'
+
+
+@pytest.fixture
+def MsgContactInfo(): # Contact Info message
+    return b'\x00\x00\x00\x2c\x10'+get_sn()+b'\x91\x00\x08solarhub\x0fsolarhub\x40123456'
+
+@pytest.fixture
+def MsgContactResp(): # Contact Response message
+    return b'\x00\x00\x00\x14\x10'+get_sn()+b'\x91\x00\x01'
+
+@pytest.fixture
+def MsgContactInfo2(): # Contact Info message
+    return b'\x00\x00\x00\x2c\x10'+get_invalid_sn()+b'\x91\x00\x08solarhub\x0fsolarhub\x40123456'
+
+@pytest.fixture
+def MsgContactResp2(): # Contact Response message
+    return b'\x00\x00\x00\x14\x10'+get_invalid_sn()+b'\x91\x00\x01'
+
+@pytest.fixture
+def MsgTimeStampReq(): # Get Time Request message
+    return b'\x00\x00\x00\x13\x10'+get_sn()+b'\x91\x22'           
+
+@pytest.fixture
+def MsgTimeStampResp(): # Get Time Resonse message
+    return b'\x00\x00\x00\x1b\x10'+get_sn()+b'\x99\x22\x00\x00\x01\x89\xc6\x63\x4d\x80'
+
+@pytest.fixture
+def MsgContollerInd(): # Data indication from the controller
+    msg  =  b'\x00\x00\x01\x2f\x10'+ get_sn() + b'\x91\x71\x0e\x10\x00\x00\x10'+get_sn()
+    msg +=  b'\x01\x00\x00\x01\x89\xc6\x63\x55\x50'
+    msg +=  b'\x00\x00\x00\x15\x00\x09\x2b\xa8\x54\x10\x52\x53\x57\x5f\x34\x30\x30\x5f\x56\x31\x2e\x30\x30\x2e\x30\x36\x00\x09\x27\xc0\x54\x06\x52\x61\x79\x6d\x6f'
+    msg +=  b'\x6e\x00\x09\x2f\x90\x54\x0b\x52\x53\x57\x2d\x31\x2d\x31\x30\x30\x30\x31\x00\x09\x5a\x88\x54\x0f\x74\x2e\x72\x61\x79\x6d\x6f\x6e\x69\x6f\x74\x2e\x63\x6f\x6d\x00\x09\x5a\xec\x54'
+    msg +=  b'\x1c\x6c\x6f\x67\x67\x65\x72\x2e\x74\x61\x6c\x65\x6e\x74\x2d\x6d\x6f\x6e\x69\x74\x6f\x72\x69\x6e\x67\x2e\x63\x6f\x6d\x00\x0d\x00\x20\x49\x00\x00\x00\x01\x00\x0c\x35\x00\x49\x00'
+    msg +=  b'\x00\x00\x64\x00\x0c\x96\xa8\x49\x00\x00\x00\x1d\x00\x0c\x7f\x38\x49\x00\x00\x00\x01\x00\x0c\xfc\x38\x49\x00\x00\x00\x01\x00\x0c\xf8\x50\x49\x00\x00\x01\x2c\x00\x0c\x63\xe0\x49'
+    msg +=  b'\x00\x00\x00\x00\x00\x0c\x67\xc8\x49\x00\x00\x00\x00\x00\x0c\x50\x58\x49\x00\x00\x00\x01\x00\x09\x5e\x70\x49\x00\x00\x13\x8d\x00\x09\x5e\xd4\x49\x00\x00\x13\x8d\x00\x09\x5b\x50'
+    msg +=  b'\x49\x00\x00\x00\x02\x00\x0d\x04\x08\x49\x00\x00\x00\x00\x00\x07\xa1\x84\x49\x00\x00\x00\x01\x00\x0c\x50\x59\x49\x00\x00\x00\x4c\x00\x0d\x1f\x60\x49\x00\x00\x00\x00'
+    return msg
+
+@pytest.fixture
+def MsgInvData(): # Data indication from the controller
+    msg  =  b'\x00\x00\x00\x8b\x10'+ get_sn() + b'\x91\x04\x01\x90\x00\x01\x10'+get_inv_no()
+    msg +=  b'\x01\x00\x00\x01\x89\xc6\x63\x61\x08'
+    msg +=  b'\x00\x00\x00\x06\x00\x00\x00\x0a\x54\x08\x4d\x69\x63\x72\x6f\x69\x6e\x76\x00\x00\x00\x14\x54\x04\x54\x53\x55\x4e\x00\x00\x00\x1E\x54\x07\x56\x35\x2e\x30\x2e\x31\x31\x00\x00\x00\x28'
+    msg +=  b'\x54\x10\x54\x31\x37\x45\x37\x33\x30\x37\x30\x32\x31\x44\x30\x30\x36\x41\x00\x00\x00\x32\x54\x0a\x54\x53\x4f\x4c\x2d\x4d\x53\x36\x30\x30\x00\x00\x00\x3c\x54\x05\x41\x2c\x42\x2c\x43'
+    return msg
+
+@pytest.fixture
+def MsgInverterInd(): # Data indication from the inverter
+    msg  = b'\x00\x00\x05\x02\x10'+ get_sn() + b'\x91\x04\x01\x90\x00\x01\x10'+get_inv_no()
+    msg +=  b'\x01\x00\x00\x01\x89\xc6\x63\x61\x08'
+    msg +=  b'\x00\x00\x00\xa3\x00\x00\x00\x64\x53\x00\x01\x00\x00\x00\xc8\x53\x00\x02\x00\x00\x01\x2c\x53\x00\x00\x00\x00\x01\x90\x49\x00\x00\x00\x00\x00\x00\x01\x91\x53\x00\x00'
+    msg +=  b'\x00\x00\x01\x92\x53\x00\x00\x00\x00\x01\x93\x53\x00\x00\x00\x00\x01\x94\x53\x00\x00\x00\x00\x01\x95\x53\x00\x00\x00\x00\x01\x96\x53\x00\x00\x00\x00\x01\x97\x53\x00'
+    msg +=  b'\x00\x00\x00\x01\x98\x53\x00\x00\x00\x00\x01\x99\x53\x00\x00\x00\x00\x01\x9a\x53\x00\x00\x00\x00\x01\x9b\x53\x00\x00\x00\x00\x01\x9c\x53\x00\x00\x00\x00\x01\x9d\x53'
+    msg +=  b'\x00\x00\x00\x00\x01\x9e\x53\x00\x00\x00\x00\x01\x9f\x53\x00\x00\x00\x00\x01\xa0\x53\x00\x00\x00\x00\x01\xf4\x49\x00\x00\x00\x00\x00\x00\x01\xf5\x53\x00\x00\x00\x00'
+    msg +=  b'\x01\xf6\x53\x00\x00\x00\x00\x01\xf7\x53\x00\x00\x00\x00\x01\xf8\x53\x00\x00\x00\x00\x01\xf9\x53\x00\x00\x00\x00\x01\xfa\x53\x00\x00\x00\x00\x01\xfb\x53\x00\x00\x00'
+    msg +=  b'\x00\x01\xfc\x53\x00\x00\x00\x00\x01\xfd\x53\x00\x00\x00\x00\x01\xfe\x53\x00\x00\x00\x00\x01\xff\x53\x00\x00\x00\x00\x02\x00\x53\x00\x00\x00\x00\x02\x01\x53\x00\x00'
+    msg +=  b'\x00\x00\x02\x02\x53\x00\x00\x00\x00\x02\x03\x53\x00\x00\x00\x00\x02\x04\x53\x00\x00\x00\x00\x02\x58\x49\x00\x00\x00\x00\x00\x00\x02\x59\x53\x00\x00\x00\x00\x02\x5a'
+    msg +=  b'\x53\x00\x00\x00\x00\x02\x5b\x53\x00\x00\x00\x00\x02\x5c\x53\x00\x00\x00\x00\x02\x5d\x53\x00\x00\x00\x00\x02\x5e\x53\x00\x00\x00\x00\x02\x5f\x53\x00\x00\x00\x00\x02'
+    msg +=  b'\x60\x53\x00\x00\x00\x00\x02\x61\x53\x00\x00\x00\x00\x02\x62\x53\x00\x00\x00\x00\x02\x63\x53\x00\x00\x00\x00\x02\x64\x53\x00\x00\x00\x00\x02\x65\x53\x00\x00\x00\x00'
+    msg +=  b'\x02\x66\x53\x00\x00\x00\x00\x02\x67\x53\x00\x00\x00\x00\x02\x68\x53\x00\x00\x00\x00\x02\xbc\x49\x00\x00\x00\x00\x00\x00\x02\xbd\x53\x00\x00\x00\x00\x02\xbe\x53\x00'
+    msg +=  b'\x00\x00\x00\x02\xbf\x53\x00\x00\x00\x00\x02\xc0\x53\x00\x00\x00\x00\x02\xc1\x53\x00\x00\x00\x00\x02\xc2\x53\x00\x00\x00\x00\x02\xc3\x53\x00\x00\x00\x00\x02\xc4\x53'
+    msg +=  b'\x00\x00\x00\x00\x02\xc5\x53\x00\x00\x00\x00\x02\xc6\x53\x00\x00\x00\x00\x02\xc7\x53\x00\x00\x00\x00\x02\xc8\x53\x00\x00\x00\x00\x02\xc9\x53\x00\x00\x00\x00\x02\xca'
+    msg +=  b'\x53\x00\x00\x00\x00\x02\xcb\x53\x00\x00\x00\x00\x02\xcc\x53\x00\x00\x00\x00\x03\x20\x53\x00\x00\x00\x00\x03\x84\x53\x50\x11\x00\x00\x03\xe8\x46\x43\x61\x66\x66\x00'
+    msg +=  b'\x00\x04\x4c\x46\x3e\xeb\x85\x1f\x00\x00\x04\xb0\x46\x42\x48\x14\x7b\x00\x00\x05\x14\x53\x00\x17\x00\x00\x05\x78\x53\x00\x00\x00\x00\x05\xdc\x53\x02\x58\x00\x00\x06'
+    msg +=  b'\x40\x46\x42\xd3\x66\x66\x00\x00\x06\xa4\x46\x42\x06\x66\x66\x00\x00\x07\x08\x46\x3f\xf4\x7a\xe1\x00\x00\x07\x6c\x46\x42\x81\x00\x00\x00\x00\x07\xd0\x46\x42\x06\x00'
+    msg +=  b'\x00\x00\x00\x08\x34\x46\x3f\xae\x14\x7b\x00\x00\x08\x98\x46\x42\x36\xcc\xcd\x00\x00\x08\xfc\x46\x00\x00\x00\x00\x00\x00\x09\x60\x46\x00\x00\x00\x00\x00\x00\x09\xc4'
+    msg +=  b'\x46\x00\x00\x00\x00\x00\x00\x0a\x28\x46\x00\x00\x00\x00\x00\x00\x0a\x8c\x46\x00\x00\x00\x00\x00\x00\x0a\xf0\x46\x00\x00\x00\x00\x00\x00\x0b\x54\x46\x3f\xd9\x99\x9a'
+    msg +=  b'\x00\x00\x0b\xb8\x46\x41\x8a\xe1\x48\x00\x00\x0c\x1c\x46\x3f\x8a\x3d\x71\x00\x00\x0c\x80\x46\x41\x1b\xd7\x0a\x00\x00\x0c\xe4\x46\x3f\x1e\xb8\x52\x00\x00\x0d\x48\x46'
+    msg +=  b'\x40\xf3\xd7\x0a\x00\x00\x0d\xac\x46\x00\x00\x00\x00\x00\x00\x0e\x10\x46\x00\x00\x00\x00\x00\x00\x0e\x74\x46\x00\x00\x00\x00\x00\x00\x0e\xd8\x46\x00\x00\x00\x00\x00'
+    msg +=  b'\x00\x0f\x3c\x53\x00\x00\x00\x00\x0f\xa0\x53\x00\x00\x00\x00\x10\x04\x53\x55\xaa\x00\x00\x10\x68\x53\x00\x00\x00\x00\x10\xcc\x53\x00\x00\x00\x00\x11\x30\x53\x00\x00'
+    msg +=  b'\x00\x00\x11\x94\x53\x00\x00\x00\x00\x11\xf8\x53\xff\xff\x00\x00\x12\x5c\x53\xff\xff\x00\x00\x12\xc0\x53\x00\x02\x00\x00\x13\x24\x53\xff\xff\x00\x00\x13\x88\x53\xff'
+    msg +=  b'\xff\x00\x00\x13\xec\x53\xff\xff\x00\x00\x14\x50\x53\xff\xff\x00\x00\x14\xb4\x53\xff\xff\x00\x00\x15\x18\x53\xff\xff\x00\x00\x15\x7c\x53\x00\x00\x00\x00\x27\x10\x53'
+    msg +=  b'\x00\x02\x00\x00\x27\x74\x53\x00\x3c\x00\x00\x27\xd8\x53\x00\x68\x00\x00\x28\x3c\x53\x05\x00\x00\x00\x28\xa0\x46\x43\x79\x00\x00\x00\x00\x29\x04\x46\x43\x48\x00\x00'
+    msg +=  b'\x00\x00\x29\x68\x46\x42\x48\x33\x33\x00\x00\x29\xcc\x46\x42\x3e\x3d\x71\x00\x00\x2a\x30\x53\x00\x01\x00\x00\x2a\x94\x46\x43\x37\x00\x00\x00\x00\x2a\xf8\x46\x42\xce'
+    msg +=  b'\x00\x00\x00\x00\x2b\x5c\x53\x00\x96\x00\x00\x2b\xc0\x53\x00\x10\x00\x00\x2c\x24\x46\x43\x90\x00\x00\x00\x00\x2c\x88\x46\x43\x95\x00\x00\x00\x00\x2c\xec\x53\x00\x06'
+    msg +=  b'\x00\x00\x2d\x50\x53\x00\x06\x00\x00\x2d\xb4\x46\x43\x7d\x00\x00\x00\x00\x2e\x18\x46\x42\x3d\xeb\x85\x00\x00\x2e\x7c\x46\x42\x3d\xeb\x85\x00\x00\x2e\xe0\x53\x00\x03'
+    msg +=  b'\x00\x00\x2f\x44\x53\x00\x03\x00\x00\x2f\xa8\x46\x42\x4d\xeb\x85\x00\x00\x30\x0c\x46\x42\x4d\xeb\x85\x00\x00\x30\x70\x53\x00\x03\x00\x00\x30\xd4\x53\x00\x03\x00\x00'
+    msg +=  b'\x31\x38\x46\x42\x08\x00\x00\x00\x00\x31\x9c\x53\x00\x05\x00\x00\x32\x00\x53\x04\x00\x00\x00\x32\x64\x53\x00\x01\x00\x00\x32\xc8\x53\x13\x9c\x00\x00\x33\x2c\x53\x0f'
+    msg +=  b'\xa0\x00\x00\x33\x90\x53\x00\x4f\x00\x00\x33\xf4\x53\x00\x66\x00\x00\x34\x58\x53\x03\xe8\x00\x00\x34\xbc\x53\x04\x00\x00\x00\x35\x20\x53\x00\x00\x00\x00\x35\x84\x53'
+    msg +=  b'\x00\x00\x00\x00\x35\xe8\x53\x00\x00\x00\x00\x36\x4c\x53\x00\x00\x00\x01\x38\x80\x53\x00\x02\x00\x01\x38\x81\x53\x00\x01\x00\x01\x38\x82\x53\x00\x01\x00\x01\x38\x83'
+    msg +=  b'\x53\x00\x00'     
+    return msg
+
+@pytest.fixture
+def MsgOtaUpdateReq(): # Over the air update request from talent cloud
+    msg  = b'\x00\x00\x01\x16\x10'+ get_sn() + b'\x70\x13\x01\x02\x76\x35'
+    msg += b'\x70\x68\x74\x74\x70'
+    msg += b'\x3a\x2f\x2f\x77\x77\x77\x2e\x74\x61\x6c\x65\x6e\x74\x2d\x6d\x6f'
+    msg += b'\x6e\x69\x74\x6f\x72\x69\x6e\x67\x2e\x63\x6f\x6d\x3a\x39\x30\x30'
+    msg += b'\x32\x2f\x70\x72\x6f\x64\x2d\x61\x70\x69\x2f\x72\x6f\x6d\x2f\x75'
+    msg += b'\x70\x64\x61\x74\x65\x2f\x64\x6f\x77\x6e\x6c\x6f\x61\x64\x3f\x76'
+    msg += b'\x65\x72\x3d\x56\x31\x2e\x30\x30\x2e\x31\x37\x26\x6e\x61\x6d\x65'
+    msg += b'\x3d\x47\x33\x2d\x57\x69\x46\x69\x2b\x2d\x56\x31\x2e\x30\x30\x2e'
+    msg += b'\x31\x37\x2d\x4f\x54\x41\x26\x65\x78\x74\x3d\x30\x60\x68\x74\x74'
+    msg += b'\x70\x3a\x2f\x2f\x77\x77\x77\x2e\x74\x61\x6c\x65\x6e\x74\x2d\x6d'
+    msg += b'\x6f\x6e\x69\x74\x6f\x72\x69\x6e\x67\x2e\x63\x6f\x6d\x3a\x39\x30'
+    msg += b'\x30\x32\x2f\x70\x72\x6f\x64\x2d\x61\x70\x69\x2f\x72\x6f\x6d\x2f'
+    msg += b'\x75\x70\x64\x61\x74\x65\x2f\x63\x61\x6c\x6c\x62\x61\x63\x6b\x3f'
+    msg += b'\x71\x69\x64\x3d\x31\x35\x30\x33\x36\x32\x26\x72\x69\x64\x3d\x32'
+    msg += b'\x32\x39\x26\x64\x69\x64\x3d\x31\x33\x34\x32\x32\x35\x20\x36\x35'
+    msg += b'\x66\x30\x64\x37\x34\x34\x62\x66\x33\x39\x61\x62\x38\x32\x34\x64'
+    msg += b'\x32\x38\x62\x38\x34\x64\x31\x39\x65\x64\x33\x31\x31\x63\x06\x34'
+    msg += b'\x36\x38\x36\x33\x33\x01\x31\x01\x30\x00'
+    return msg
+
+
+@pytest.fixture(scope="session")
+def ClientConnection():
+    #host = '172.16.30.7'
+    host = 'logger.talent-monitoring.com'
+    #host = '127.0.0.1'
+    port = 5005
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.connect((host, port))
+        s.settimeout(1)
+        yield s
+        s.close()
+
+def tempClientConnection():
+    #host = '172.16.30.7'
+    host = 'logger.talent-monitoring.com'
+    #host = '127.0.0.1'
+    port = 5005
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.connect((host, port))
+        s.settimeout(1)
+        yield s
+        s.close()
+
+def test_open_close():
+    try:
+        for s in tempClientConnection():
+            pass
+    except:
+        assert False
+    assert True
+
+def test_send_contact_info1(ClientConnection, MsgContactInfo, MsgContactResp):
+    s = ClientConnection
+    try:
+        s.sendall(MsgContactInfo)
+        data = s.recv(1024)
+    except TimeoutError:
+        pass
+    assert data == MsgContactResp
+
+
+def test_send_contact_info2(ClientConnection, MsgContactInfo2, MsgContactInfo, MsgContactResp):
+    s = ClientConnection  
+    try:
+        s.sendall(MsgContactInfo2)
+        data = s.recv(1024)
+    except TimeoutError:
+        assert True
+    else: 
+        assert False
+
+    try:
+        s.sendall(MsgContactInfo)
+        data = s.recv(1024)
+    except TimeoutError:
+        pass
+    assert data == MsgContactResp
+
+def test_send_contact_info3(ClientConnection, MsgContactInfo, MsgContactResp, MsgTimeStampReq):
+    s = ClientConnection
+    try:
+        s.sendall(MsgContactInfo)
+        data = s.recv(1024)
+    except TimeoutError:
+        pass
+    assert data == MsgContactResp
+    try:
+        s.sendall(MsgTimeStampReq)
+        data = s.recv(1024)
+    except TimeoutError:
+        pass
+ 
+
+def test_send_contact_resp(ClientConnection, MsgContactResp):
+    s = ClientConnection  
+    try:
+        s.sendall(MsgContactResp)
+        data = s.recv(1024)
+    except TimeoutError:
+        assert True
+    else:
+        assert data == b''
+
+def test_send_ctrl_data(ClientConnection, MsgTimeStampReq, MsgTimeStampResp, MsgContollerInd):
+    s = ClientConnection  
+    try:
+        s.sendall(MsgTimeStampReq)
+        data = s.recv(1024)
+    except TimeoutError:
+        pass
+  #  time.sleep(2.5)
+  #  assert data == MsgTimeStampResp
+    try:
+        s.sendall(MsgContollerInd)
+        data = s.recv(1024)
+    except TimeoutError:
+        pass
+
+def test_send_inv_data(ClientConnection, MsgTimeStampReq, MsgTimeStampResp, MsgInvData, MsgInverterInd):
+    s = ClientConnection  
+    try:
+        s.sendall(MsgTimeStampReq)
+        data = s.recv(1024)
+    except TimeoutError:
+        pass
+   # time.sleep(32.5)
+  #  assert data == MsgTimeStampResp
+    try:
+        s.sendall(MsgInvData)
+        data = s.recv(1024)
+        s.sendall(MsgInverterInd)
+        data = s.recv(1024)
+    except TimeoutError:
+        pass
+
+def test_ota_req(ClientConnection, MsgOtaUpdateReq):
+    s = ClientConnection  
+    try:
+        s.sendall(MsgOtaUpdateReq)
+        data = s.recv(1024)
+    except TimeoutError:
+        pass