v1.3.2

.gitignore

@@ -12,7 +12,7 @@ pymodbus.egg-info/
 .tox/
 doc/api/epydoc/html/
 .vscode/
-
+.venv
 __pycache__/
 pymodbus/__pycache__/
 pymodbus/client/__pycache__/

CHANGELOG.rst

@@ -1,4 +1,13 @@
 
+Version 1.3.2
+------------------------------------------------------------
+* ModbusSerialServer could now be stopped when running on a seperate thread.
+* Fix issue with server and client where in the frame buffer had values from previous unsuccesful transaction
+* Fix response length calculation for ModbusASCII protocol
+* Fix response length calculation ReportSlaveIdResponse, DiagnosticStatusResponse
+* Fix never ending transaction case when response is recieved without header and CRC
+* Fix tests
+
 Version 1.3.1
 ------------------------------------------------------------
 * Recall socket recv until get a complete response

README.rst

@@ -125,7 +125,6 @@ like your device tested, I accept devices via mail or by IP address.
 That said, the current work mainly involves polishing the library as
 I get time doing such tasks as:
 
-  * Add CI support
   * Make PEP-8 compatible and flake8 ready
   * Fixing bugs/feature requests
   * Architecture documentation
@@ -152,6 +151,10 @@ Use make to perform a range of activities
      make tox        run the tests on all Python versions
      make clean      cleanup all temporary files 
 
+------------------------------------------------------------
+Contributing
+------------------------------------------------------------
+Just fork the repo and raise your PR against `dev` branch.
 
 ------------------------------------------------------------
 License Information

examples/common/callback-server.py

@@ -16,6 +16,7 @@
 from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext
 from pymodbus.transaction import ModbusRtuFramer, ModbusAsciiFramer
 
+
 #---------------------------------------------------------------------------# 
 # import the python libraries we need
 #---------------------------------------------------------------------------# 
@@ -31,7 +32,8 @@
 
 #---------------------------------------------------------------------------# 
 # create your custom data block with callbacks
-#---------------------------------------------------------------------------# 
+#---------------------------------------------------------------------------#
+
 class CallbackDataBlock(ModbusSparseDataBlock):
     ''' A datablock that stores the new value in memory
     and passes the operation to a message queue for further
@@ -44,7 +46,7 @@ def __init__(self, devices, queue):
         self.devices = devices
         self.queue = queue
 
-        values = {k:0 for k in devices.iterkeys()}
+        values = {k:0 for k in devices.keys()}
         values[0xbeef] = len(values) # the number of devices
         super(CallbackDataBlock, self).__init__(values)
 

examples/common/device-mapping

@@ -0,0 +1,2 @@
+0x0001,/dev/ptyp0
+0x0002,/dev/ptyp1

examples/common/modbus-payload-server.py

@@ -35,10 +35,10 @@
 # build your payload
 #---------------------------------------------------------------------------# 
 builder = BinaryPayloadBuilder(endian=Endian.Little)
-builder.add_string('abcdefgh')
-builder.add_32bit_float(22.34)
-builder.add_16bit_uint(0x1234)
-builder.add_8bit_int(0x12)
+# builder.add_string('abcdefgh')
+# builder.add_32bit_float(22.34)
+# builder.add_16bit_uint(4660)
+# builder.add_8bit_int(18)
 builder.add_bits([0,1,0,1,1,0,1,0])
 
 #---------------------------------------------------------------------------# 

examples/common/modbus-payload.py

@@ -9,6 +9,7 @@
 from pymodbus.payload import BinaryPayloadDecoder
 from pymodbus.payload import BinaryPayloadBuilder
 from pymodbus.client.sync import ModbusTcpClient as ModbusClient
+from pymodbus.compat import iteritems
 
 #---------------------------------------------------------------------------# 
 # configure the client logging
@@ -34,13 +35,15 @@
 # - a 8 byte string 'abcdefgh'
 # - a 32 bit float 22.34
 # - a 16 bit unsigned int 0x1234
+# - another 16 bit unsigned int 0x5678
 # - an 8 bit int 0x12
 # - an 8 bit bitstring [0,1,0,1,1,0,1,0]
 #---------------------------------------------------------------------------# 
 builder = BinaryPayloadBuilder(endian=Endian.Big)
 builder.add_string('abcdefgh')
 builder.add_32bit_float(22.34)
 builder.add_16bit_uint(0x1234)
+builder.add_16bit_uint(0x5678)
 builder.add_8bit_int(0x12)
 builder.add_bits([0,1,0,1,1,0,1,0])
 payload = builder.build()
@@ -57,6 +60,7 @@
 # - a 8 byte string 'abcdefgh'
 # - a 32 bit float 22.34
 # - a 16 bit unsigned int 0x1234
+# - another 16 bit unsigned int which we will ignore
 # - an 8 bit int 0x12
 # - an 8 bit bitstring [0,1,0,1,1,0,1,0]
 #---------------------------------------------------------------------------# 
@@ -68,15 +72,16 @@
     'string': decoder.decode_string(8),
     'float': decoder.decode_32bit_float(),
     '16uint': decoder.decode_16bit_uint(),
+    'ignored': decoder.skip_bytes(2),
     '8int': decoder.decode_8bit_int(),
     'bits': decoder.decode_bits(),
 }
 
-print "-" * 60
-print "Decoded Data"
-print "-" * 60
-for name, value in decoded.iteritems():
-    print ("%s\t" % name), value
+print("-" * 60)
+print("Decoded Data")
+print("-" * 60)
+for name, value in iteritems(decoded):
+    print ("%s\t" % name, value)
 
 #---------------------------------------------------------------------------# 
 # close the client

examples/common/performance.py

@@ -13,7 +13,7 @@
 import logging, os
 from time import time
 from multiprocessing import log_to_stderr
-from pymodbus.client.sync import ModbusTcpClient
+# from pymodbus.client.sync import ModbusTcpClient
 from pymodbus.client.sync import ModbusSerialClient
 
 #---------------------------------------------------------------------------# 
@@ -61,9 +61,10 @@ def single_client_test(host, cycles):
         client = ModbusSerialClient(method="rtu", port="/dev/ttyp0", baudrate=9600)
         while count < cycles:
             with _thread_lock:
-                result = client.read_holding_registers(10, 1, unit=1).getRegister(0)
+                client.read_holding_registers(10, 1, unit=1).registers[0]
                 count += 1
-    except: logger.exception("failed to run test successfully")
+    except:
+        logger.exception("failed to run test successfully")
     logger.debug("finished worker: %d" % os.getpid())
 
 #---------------------------------------------------------------------------# 
@@ -73,6 +74,10 @@ def single_client_test(host, cycles):
 # threads that was specified. We then start all the threads and block on
 # them to finish. This may need to switch to another mechanism to signal
 # finished as the process/thread start up/shut down may skew the test a bit.
+
+# RTU 32 requests/second @9600
+# TCP 31430 requests/second
+
 #---------------------------------------------------------------------------# 
 args  = (host, int(cycles * 1.0 / workers))
 procs = [Worker(target=single_client_test, args=args) for _ in range(workers)]

pymodbus/client/sync.py

@@ -308,7 +308,10 @@ def __init__(self, method='ascii', **kwargs):
         self.timeout  = kwargs.get('timeout',  Defaults.Timeout)
         if self.method == "rtu":
             self._last_frame_end = 0.0
-            self._silent_interval = 3.5 * (1 + 8 + 2) / self.baudrate
+            if self.baudrate > 19200:
+                self._silent_interval = 1.75/1000  # ms
+            else:
+                self._silent_interval = 3.5 * (1 + 8 + 2) / self.baudrate
 
     @staticmethod
     def __implementation(method):

pymodbus/diag_message.py

@@ -74,7 +74,6 @@ def get_response_pdu_size(self):
         return 1 + 2 + 2 * len(self.message)
 
 
-
 class DiagnosticStatusResponse(ModbusResponse):
     '''
     This is a base class for all of the diagnostic response functions
@@ -118,7 +117,11 @@ def decode(self, data):
 
         :param data: The data to decode into the function code
         '''
-        self.sub_function_code, self.message = struct.unpack('>HH', data)
+        word_len = len(data)//2
+        if len(data) % 2:
+            word_len += 1
+        data = struct.unpack('>' + 'H'*word_len, data)
+        self.sub_function_code, self.message = data[0], data[1:]
 
 
 class DiagnosticStatusSimpleRequest(DiagnosticStatusRequest):
@@ -708,6 +711,23 @@ class GetClearModbusPlusRequest(DiagnosticStatusSimpleRequest):
     '''
     sub_function_code = 0x0015
 
+    def __init__(self, **kwargs):
+        super(GetClearModbusPlusRequest, self).__init__(**kwargs)
+
+    def get_response_pdu_size(self):
+        """
+        Returns a series of 54 16-bit words (108 bytes) in the data field of the response
+        (this function differs from the usual two-byte length of the data field). The data
+        contains the statistics for the Modbus Plus peer processor in the slave device.
+        Func_code (1 byte) + Sub function code (2 byte) + Operation (2 byte) + Data (108 bytes)
+        :return:
+        """
+        if self.message == ModbusPlusOperation.GetStatistics:
+            data = 2 + 108 # byte count(2) + data (54*2)
+        else:
+            data = 0
+        return 1 + 2 + 2 + 2+ data
+
     def execute(self, *args):
         ''' Execute the diagnostic request on the given device
 
@@ -716,9 +736,23 @@ def execute(self, *args):
         message = None # the clear operation does not return info
         if self.message == ModbusPlusOperation.ClearStatistics:
             _MCB.Plus.reset()
-        else: message = _MCB.Plus.encode()
+            message = self.message
+        else:
+            message = [self.message]
+            message += _MCB.Plus.encode()
         return GetClearModbusPlusResponse(message)
 
+    def encode(self):
+        '''
+        Base encoder for a diagnostic response
+        we encode the data set in self.message
+
+        :returns: The encoded packet
+        '''
+        packet = struct.pack('>H', self.sub_function_code)
+        packet += struct.pack('>H', self.message)
+        return packet
+
 
 class GetClearModbusPlusResponse(DiagnosticStatusSimpleResponse):
     '''

pymodbus/exceptions.py

@@ -78,19 +78,19 @@ def __init__(self, string=""):
         ModbusException.__init__(self, message)
 
 
-class InvalidResponseRecievedException(ModbusException):
+class InvalidMessageRecievedException(ModbusException):
     """
     Error resulting from invalid response received or decoded
     """
 
+    def __init__(self, string=""):
+        ''' Initialize the exception
 
-def __init__(self, string=""):
-    ''' Initialize the exception
+        :param string: The message to append to the error
+        '''
+        message = "[Invalid Message] %s" % string
+        ModbusException.__init__(self, message)
 
-    :param string: The message to append to the error
-    '''
-    message = "[Invalid Response] %s" % string
-    ModbusException.__init__(self, message)
 
 #---------------------------------------------------------------------------#
 # Exported symbols

pymodbus/other_message.py

@@ -403,7 +403,7 @@ def encode(self):
             status = ModbusStatus.SlaveOn
         else:
             status = ModbusStatus.SlaveOff
-        length  = len(self.identifier) + 2
+        length  = len(self.identifier) + 1
         packet  = int2byte(length)
         packet += self.identifier  # we assume it is already encoded
         packet += int2byte(status)

pymodbus/payload.py

@@ -349,6 +349,14 @@ def decode_string(self, size=1):
         self._pointer += size
         return self._payload[self._pointer - size:self._pointer]
 
+    def skip_bytes(self, nbytes):
+        ''' Skip n bytes in the buffer
+
+        :param nbytes: The number of bytes to skip
+        '''
+        self._pointer += nbytes
+        return None
+
 #---------------------------------------------------------------------------#
 # Exported Identifiers
 #---------------------------------------------------------------------------#