code cleanup and bug fix of return without resetting timeout

Author: Tianshu Wei

can/interfaces/usr_canet.py

@@ -42,7 +42,7 @@ def __init__(self,
                 self.connected = True
             except socket.error as e:
                 self.connected = False
-                logging.error(f"Could not reconnect: {e}. Retrying...")
+                logging.error(f"Could not connect: {e}. Retrying...")
                 self.s.close()
                 sleep(reconnect_delay)
 
@@ -65,42 +65,46 @@ def send(self, msg: Message, timeout: Optional[float] = None) -> None:
         struct.pack_into('>L', frame_id, 0, int(msg.arbitration_id))    # Next 4 bytes contain CAN ID
 
         frame_data = bytearray(8)
-        frame_data[0:0 + len(msg.data)] = msg.data                      # Following 8 bytes contain CAN data
+        frame_data[0:len(msg.data)] = msg.data                      # Following 8 bytes contain CAN data
 
         raw_message = frame_information + frame_id + frame_data         # Combine to make full message
 
         # Set timeout for sending
         if timeout is not None:
             self.s.settimeout(timeout)
-
         try:
             self.s.send(raw_message)
         except TimeoutError:
-            self.s.settimeout(None)
-            return(None, False)
+            # Timeout
+            msg = None
+            pass
         except socket.error as e:
             self.connected = False
             logging.error(f"Socket error: {e}")
             if self.reconnect:
-                while not self.connected:
-                    try:
-                        logging.error("Reconnecting...")
-                        self.s.close()
-                        self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                        self.s.connect((self.host, self.port))
-                        self.connected = True
-                        logging.error("Reconnected.")
-                    except Exception as e:
-                        logging.error(f"Could not reconnect: {e}. Retrying...")
-                        sleep(self.reconnect_delay)
+                self.do_reconnect()
             else:
-                return(None, False)
+                msg = None
+        finally:
+            # Reset timeout
+            if timeout is not None:
+                self.s.settimeout(None)
 
-        # Reset timeout
-        if timeout is not None:
-            self.s.settimeout(None)
         return (msg, False)
 
+    def do_reconnect(self):
+        while not self.connected:
+            try:
+                logging.error("Reconnecting...")
+                self.s.close()
+                self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                self.s.connect((self.host, self.port))
+                self.connected = True
+                logging.error("Reconnected.")
+            except Exception as e:
+                logging.error(f"Could not reconnect: {e}. Retrying...")
+                sleep(self.reconnect_delay)
+
     def _recv_internal(self, timeout: Optional[float]) -> Tuple[Optional[Message], bool]:
         """Expect a message to receive from the socket
         :param timeout: timeout (in seconds) to wait for expected data to come in.
@@ -115,6 +119,9 @@ def _recv_internal(self, timeout: Optional[float]) -> Tuple[Optional[Message], b
         flag_success = False
         while not flag_success:
             try:
+                # The USR-CANET will always return 13 bytes per CAN packet
+                # But sometimes will return TCP packets with 2 CAN packets sandwiched together
+                # This will seperate the sandwich.
                 data = self.s.recv(13)
                 flag_success = True
             except TimeoutError:
@@ -124,25 +131,22 @@ def _recv_internal(self, timeout: Optional[float]) -> Tuple[Optional[Message], b
                 self.connected = False
                 logging.error(f"Socket error: {e}")
                 if self.reconnect:
-                    while not self.connected:
-                        try:
-                            logging.error("Reconnecting...")
-                            self.s.close()
-                            self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                            self.s.connect((self.host, self.port))
-                            self.connected = True
-                            logging.error("Reconnected.")
-                        except Exception as e:
-                            logging.error(f"Could not reconnect: {e}. Retrying...")
-                            sleep(self.reconnect_delay)
+                    self.do_reconnect()
                 else:
-                    return (None, False)
+                    self.s.settimeout(None)
+                    return(None, False)
+
 
         # Check received length
         if len(data) == 0:
+            self.s.settimeout(None)
             return (None, False)
 
         # Decode CAN frame
+        # CAN frame from USR-CANET200 looks like:
+        #  --------------------- ------------------ --------------------
+        # | frame_info (1 byte) | can_id (4 bytes) | can_data (8 bytes) |
+        #  --------------------- ------------------ --------------------
         CAN_FRAME = struct.Struct('>BI8s')
         frame_info, can_id, can_data = CAN_FRAME.unpack_from(data)
         dlc = frame_info & 0x0F                 # Last 4 bits indicate data length