feat: Implemented time response for cloudless time synchronization

pysolarmanv5/pysolarmanv5.py

@@ -1,12 +1,13 @@
 """pysolarmanv5.py"""
 
+import time
 import errno
 import queue
 import struct
 import socket
 import logging
-import selectors
 import platform
+import selectors
 
 from threading import Thread, Event
 from multiprocessing import Queue
@@ -265,6 +266,26 @@ def _v5_frame_decoder(self, v5_frame):
 
         return modbus_frame
 
+    def _v5_heartbeat_response_frame(self, heartbeat_frame):
+        """
+        Creates response to 0x4710 (heartbeat frame)
+        """
+        response_frame = bytearray(
+            self.v5_start
+            + struct.pack("<H", 10)
+            + heartbeat_frame[3:7]
+            + self.v5_loggerserial
+            + struct.pack("<H", 0x0100)
+            + struct.pack("<I", int(time.time()))
+            + struct.pack("<I", 0)
+            + self.v5_checksum
+            + self.v5_end
+        )
+        response_frame[4] = response_frame[4] - 0x30
+        response_frame[5] = (response_frame[5] + 1) & 0xFF
+        response_frame[-2] = self._calculate_v5_frame_checksum(response_frame)
+        return response_frame
+
     def _send_receive_v5_frame(self, data_logging_stick_frame):
         """Send v5 frame to the data logger and receive response
 
@@ -299,18 +320,28 @@ def _send_receive_v5_frame(self, data_logging_stick_frame):
         return v5_response
 
     def _received_frame_is_valid(self, frame):
-        """Check that the frame is valid and that the serial number of the received
+        """
+        Check that the frame is valid and that the serial number of the received
         frame matches with the last sent one.
-        Ignore also any frames with control code 0x4710 (counter frame).
         """
         if not frame.startswith(self.v5_start):
             self.log.debug("[%s] V5_MISMATCH: %s", self.serial, frame.hex(" "))
             return False
         if frame[5] != self.sequence_number:
             self.log.debug("[%s] V5_SEQ_NO_MISMATCH: %s", self.serial, frame.hex(" "))
             return False
+        return True
+
+    def _handle_protocol_frame(self, frame):
+        """
+        Handles protocol frames with control code 0x4710 (heartbeat frame).
+        """
         if frame.startswith(self.v5_start + b"\x01\x00\x10\x47"):
-            self.log.debug("[%s] COUNTER: %s", self.serial, frame.hex(" "))
+            self.log.debug("[%s] V5_HEARTBEAT: %s", self.serial, frame.hex(" "))
+            response_frame = self._v5_heartbeat_response_frame(frame)
+            self.log.debug("[%s] V5_HEARTBEAT RESP: %s", self.serial, response_frame.hex(" "))
+            if self._reader_thr.is_alive():
+                self.sock.sendall(response_frame)
             return False
         return True
 
@@ -350,6 +381,8 @@ def _data_receiver(self):
                     return
                 if not self._received_frame_is_valid(data):
                     continue
+                if not self._handle_protocol_frame(data):
+                    continue
                 if self._data_wanted.is_set():
                     self._data_queue.put(data, timeout=self.socket_timeout)
                 else:

pysolarmanv5/pysolarmanv5_async.py

@@ -1,8 +1,9 @@
 """pysolarmanv5_async.py"""
 
+import time
 import errno
-import asyncio
 import struct
+import asyncio
 
 from multiprocessing import Event
 from umodbus.client.serial import rtu
@@ -160,6 +161,30 @@ def _send_data(self, data: bytes):
             self.data_queue.put_nowait(data)
             self.data_wanted_ev.clear()
 
+    async def _handle_protocol_frame(self, frame):
+        """
+        Handles protocol frames with control code 0x4710 (heartbeat frame).
+        """
+        if frame.startswith(self.v5_start + b"\x01\x00\x10\x47"):
+            self.log.debug("[%s] V5_HEARTBEAT: %s", self.serial, frame.hex(" "))
+            response_frame = self._v5_heartbeat_response_frame(frame)
+            self.log.debug("[%s] V5_HEARTBEAT RESP: %s", self.serial, response_frame.hex(" "))
+            try:
+                self.writer.write(response_frame)
+                await self.writer.drain()
+            except (AttributeError, NoSocketAvailableError, TimeoutError, OSError) as e:
+                if isinstance(e, AttributeError):
+                    e = NoSocketAvailableError("Connection already closed")
+                if isinstance(e, OSError) and e.errno == errno.EHOSTUNREACH:
+                    e = TimeoutError
+                self.log.debug(  # pylint: disable=logging-fstring-interpolation
+                    f"[{self.serial}] V5_HEARTBEAT error: {type(e).__name__}{f': {e}' if f'{e}' else ''}"
+                )
+            except Exception as e:
+                self.log.exception("[%s] Send/Receive error: %s", self.serial, e)
+            return False
+        return True
+
     async def _conn_keeper(self) -> None:
         """
         Socket reader loop with extra logic when auto-reconnect is enabled
@@ -185,6 +210,8 @@ async def _conn_keeper(self) -> None:
                 break
             if not self._received_frame_is_valid(data):
                 continue
+            if not await self._handle_protocol_frame(data):
+                continue
             if self.data_wanted_ev.is_set():
                 self._send_data(data)
             else: