fix formatting, add debug logs, add client_connect todo

Author: GimmickNG

umodbus/asynchronous/serial.py

@@ -144,6 +144,7 @@ async def _send(self,
                     slave_addr: int) -> None:
         """@see CommonRTUFunctions._send"""
 
+        print("async RTU: _send() called")
         post_send_actions = super()._send(device=self,
                                           modbus_pdu=modbus_pdu,
                                           slave_addr=slave_addr)
@@ -158,6 +159,7 @@ async def _post_send(self, sleep_time_us: float) -> None:
         @see CommonRTUFunctions._post_send
         """
 
+        print("async RTU: _post_send() called")
         await hybrid_sleep(sleep_time_us)
         if self._ctrlPin:
             self._ctrlPin.off()
@@ -242,13 +244,15 @@ async def send_response(self,
         :type       request:     AsyncRequest, optional
         """
 
+        print("async RTU: calling send_response()")
         task = super().send_response(slave_addr=slave_addr,
                                      function_code=function_code,
                                      request_register_addr=request_register_addr,  # noqa: E501
                                      request_register_qty=request_register_qty,
                                      request_data=request_data,
                                      values=values,
                                      signed=signed)
+        print("async RTU: send_response() called, task is:", task)
         if task is not None:
             await task
 
@@ -267,9 +271,11 @@ async def send_exception_response(self,
         :type       request:     AsyncRequest, optional
         """
 
+        print("async RTU: calling send_exception_response()")
         task = super().send_exception_response(slave_addr=slave_addr,
                                                function_code=function_code,
                                                exception_code=exception_code)
+        print("async RTU: called send_exception_response(), task is:", task)
         if task is not None:
             await task
 

umodbus/asynchronous/tcp.py

@@ -179,11 +179,11 @@ async def _send(self,
         size = len(modbus_pdu)
         fmt = 'B' * size
         adu = struct.pack('>HHHB' + fmt,
-                   req_tid,
-                   0,
-                   size + 1,
-                   slave_addr,
-                   *modbus_pdu)
+                          req_tid,
+                          0,
+                          size + 1,
+                          slave_addr,
+                          *modbus_pdu)
         writer.write(adu)
         await writer.drain()
 
@@ -248,6 +248,9 @@ async def _accept_request(self,
 
         try:
             header_len = Const.MBAP_HDR_LENGTH - 1
+            # TODO add "on_client_connected" and
+            # "on_client_disconnected" callbacks for TCP
+            # dest_addr = writer.get_extra_info('peername')
 
             while True:
                 task = reader.read(128)
@@ -259,7 +262,7 @@ async def _accept_request(self,
 
                 req_header_no_uid = req[:header_len]
                 req_tid, req_pid, req_len = struct.unpack('>HHH',
-                                                   req_header_no_uid)
+                                                          req_header_no_uid)
                 req_uid_and_pdu = req[header_len:header_len + req_len]
                 if (req_pid != 0):
                     raise ValueError(

umodbus/modbus.py

@@ -74,7 +74,7 @@ def process(self, request: Optional[Request] = None) -> Optional[Awaitable]:
         if request is None:
             request = self._itf.get_request(unit_addr_list=self._addr_list,
                                             timeout=0)
-        # if get_request is async or none, hands it off to the async subclass
+        # if get_request is an async generator or None, hands it off to the async subclass
         if not isinstance(request, Request):
             return request