1. REPL Improvements

2. Support Intercharframe timeout for Modbus RTU

Author: dhoomakethu

.gitignore

@@ -36,4 +36,4 @@ test/__pycache__/
 /doc/html/
 /doc/_build/
 .pytest_cache/
-/.pymodhis
+**/.pymodhis

pymodbus/client/sync.py

@@ -124,6 +124,10 @@ def __exit__(self, klass, value, traceback):
         self.close()
 
     def idle_time(self):
+        """
+        Bus Idle Time to initiate next transaction
+        :return: time stamp
+        """
         if self.last_frame_end is None or self.silent_interval is None:
             return 0
         return self.last_frame_end + self.silent_interval
@@ -286,11 +290,11 @@ def __repr__(self):
             "port={self.port}, timeout={self.timeout}>"
         ).format(self.__class__.__name__, hex(id(self)), self=self)
 
-
-
 # --------------------------------------------------------------------------- #
 # Modbus UDP Client Transport Implementation
 # --------------------------------------------------------------------------- #
+
+
 class ModbusUdpClient(BaseModbusClient):
     """ Implementation of a modbus udp client
     """
@@ -386,10 +390,14 @@ def __repr__(self):
 # --------------------------------------------------------------------------- #
 # Modbus Serial Client Transport Implementation
 # --------------------------------------------------------------------------- #
+
+
 class ModbusSerialClient(BaseModbusClient):
     """ Implementation of a modbus serial client
     """
     state = ModbusTransactionState.IDLE
+    inter_char_timeout = 0
+    silent_interval = 0
 
     def __init__(self, method='ascii', **kwargs):
         """ Initialize a serial client instance
@@ -413,18 +421,21 @@ def __init__(self, method='ascii', **kwargs):
         BaseModbusClient.__init__(self, self.__implementation(method, self),
                                   **kwargs)
 
-        self.port = kwargs.get('port', 0)
-        self.stopbits = kwargs.get('stopbits', Defaults.Stopbits)
-        self.bytesize = kwargs.get('bytesize', Defaults.Bytesize)
-        self.parity = kwargs.get('parity',   Defaults.Parity)
-        self.baudrate = kwargs.get('baudrate', Defaults.Baudrate)
-        self.timeout = kwargs.get('timeout',  Defaults.Timeout)
-        self.last_frame_end = None
+        self._port = kwargs.get('port', 0)
+        self._stopbits = kwargs.get('stopbits', Defaults.Stopbits)
+        self._bytesize = kwargs.get('bytesize', Defaults.Bytesize)
+        self._parity = kwargs.get('parity', Defaults.Parity)
+        self._baudrate = kwargs.get('baudrate', Defaults.Baudrate)
+        self._timeout = kwargs.get('timeout', Defaults.Timeout)
+        self.last_frame_end = 0
         if self.method == "rtu":
-            if self.baudrate > 19200:
+            if self._baudrate > 19200:
+                self._t0 = self.inter_char_timeout = 750.0/1000000  #Micro
                 self.silent_interval = 1.75 / 1000  # ms
             else:
-                self.silent_interval = 3.5 * (1 + 8 + 2) / self.baudrate
+                self._t0 = float((1 + 8 + 2)) / self._baudrate
+                self.inter_char_timeout = 1.5 * self._t0
+                self.silent_interval = 3.5 * self._t0
             self.silent_interval = round(self.silent_interval, 6)
 
     @staticmethod
@@ -453,16 +464,17 @@ def connect(self):
         if self.socket:
             return True
         try:
-            self.socket = serial.Serial(port=self.port,
-                                        timeout=self.timeout,
-                                        bytesize=self.bytesize,
-                                        stopbits=self.stopbits,
-                                        baudrate=self.baudrate,
-                                        parity=self.parity)
+            self.socket = serial.Serial(port=self._port,
+                                        timeout=self._timeout,
+                                        bytesize=self._bytesize,
+                                        stopbits=self._stopbits,
+                                        baudrate=self._baudrate,
+                                        parity=self._parity)
         except serial.SerialException as msg:
             _logger.error(msg)
             self.close()
         if self.method == "rtu":
+            self.socket.interCharTimeout = self.inter_char_timeout
             self.last_frame_end = None
         return self.socket is not None
 
@@ -512,8 +524,8 @@ def _send(self, request):
         return 0
 
     def _wait_for_data(self):
-        if self.timeout is not None and self.timeout != 0:
-            condition = partial(lambda start, timeout: (time.time() - start) <= timeout, timeout=self.timeout)
+        if self._timeout is not None and self._timeout != 0:
+            condition = partial(lambda start, timeout: (time.time() - start) <= timeout, timeout=self._timeout)
         else:
             condition = partial(lambda dummy1, dummy2: True, dummy2=None)
         start = time.time()
@@ -550,7 +562,7 @@ def __str__(self):
 
         :returns: The string representation
         """
-        return "ModbusSerialClient(%s baud[%s])" % (self.method, self.baudrate)
+        return "ModbusSerialClient(%s baud[%s])" % (self.method, self._baudrate)
 
     def __repr__(self):
         return (

pymodbus/exceptions.py

@@ -26,12 +26,13 @@ def isError(self):
 class ModbusIOException(ModbusException):
     ''' Error resulting from data i/o '''
 
-    def __init__(self, string=""):
+    def __init__(self, string="", function_code=None):
         ''' Initialize the exception
         :param string: The message to append to the error
         '''
-        message = "[Input/Output] %s" % string
-        ModbusException.__init__(self, message)
+        self.fcode = function_code
+        self.message = "[Input/Output] %s" % string
+        ModbusException.__init__(self, self.message)
 
 
 class ParameterException(ModbusException):

pymodbus/framer/rtu_framer.py

@@ -243,9 +243,6 @@ def sendPacket(self, message):
         :param message: Message to be sent over the bus
         :return:
         """
-        # _logger.debug("Current transaction state - {}".format(
-        #     ModbusTransactionState.to_string(self.client.state))
-        # )
         while self.client.state != ModbusTransactionState.IDLE:
             if self.client.state == ModbusTransactionState.TRANSACTION_COMPLETE:
                 ts = round(time.time(), 6)
@@ -269,6 +266,7 @@ def sendPacket(self, message):
             else:
                 _logger.debug("Sleeping")
                 time.sleep(self.client.silent_interval)
+                self.client.state = ModbusTransactionState.IDLE
         size = self.client.send(message)
         # if size:
         #     _logger.debug("Changing transaction state from 'SENDING' "

pymodbus/pdu.py

@@ -103,9 +103,9 @@ def doException(self, exception):
         :param exception: The exception to return
         :raises: An exception response
         """
-        _logger.error("Exception Response F(%d) E(%d)" %
-                (self.function_code, exception))
-        return ExceptionResponse(self.function_code, exception)
+        exc = ExceptionResponse(self.function_code, exception)
+        _logger.error(exc)
+        return exc
 
 
 class ModbusResponse(ModbusPDU):