Progess toward pymodbus 3.7 support

Author: pjkundert

README.org

@@ -2296,14 +2296,6 @@ val, = via.write( operations )
      input buffer which (in concert with our proper serial read
      =modbus_rtu_read=) allows us to implement correct Modbus/RTU framing.
 
-**** =modbus_sparse_data_block=
-
-     The provided =ModbusSparseDataBlock= incorrectly deduces the base address,
-     and is wildly inefficient for large data blocks.  We correctly deduce the
-     base register address.  The provided =.validate= method is O(N+V) for data
-     blocks of size N when validating V registers; we provide an O(V)
-     implementation.
-
 * Deterministic Finite Automata
 
   A cpppo.dfa will consume symbols from its source iterable, and yield
@@ -2327,6 +2319,9 @@ val, = via.write( operations )
                                   +-------+
    #+END_SRC
 
+   #+RESULTS:
+   [[file:abplus.png]]
+
    This machine is easily created like this:
 
    #+LATEX: {\scriptsize
@@ -2364,6 +2359,9 @@ val, = via.write( operations )
        +----------------------------------------+
    #+END_SRC
 
+   #+RESULTS:
+   [[file:abplus_csv.png]]
+
    This is implemented:
 
    #+LATEX: {\scriptsize
@@ -2407,6 +2405,9 @@ val, = via.write( operations )
        None          None          None          None
    #+END_SRC
 
+   #+RESULTS:
+   [[file:abplus_regex.png]]
+
    The =True= transition out of each state ensures that the =cpppo.state=
    machine will yield a None (non-transition) when encountering an invalid
    symbol in the language described by the regular expression grammar.  Only if

README.pdf

@@ -89,9 +89,8 @@
 # import the various server implementations
 #---------------------------------------------------------------------------#
 from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext
-from pymodbus.pdu.register_read_message import ReadRegistersResponseBase
-from pymodbus.pdu.register_write_message import WriteSingleRegisterResponse, WriteMultipleRegistersResponse
-from pymodbus.framer import FramerType, FRAMER_NAME_TO_CLASS
+from pymodbus.pdu.register_message import ReadHoldingRegistersResponse, WriteSingleRegisterResponse, WriteMultipleRegistersResponse
+from pymodbus.framer import FRAMER_NAME_TO_CLASS, FramerType
 from pymodbus.exceptions import NotImplementedException
 from pymodbus.datastore.store import ModbusSparseDataBlock
 
@@ -109,9 +108,7 @@
     sys.path.insert( 0, os.path.dirname( os.path.dirname( os.path.dirname( os.path.abspath( __file__ )))))
     import cpppo
 
-from cpppo.remote.pymodbus_fixes import (
-    modbus_sparse_data_block, modbus_server_rtu_printing, modbus_server_tcp_printing, Defaults
-)
+from cpppo.remote.pymodbus_fixes import modbus_server_rtu_printing, modbus_server_tcp_printing, Defaults
 
 
 #---------------------------------------------------------------------------#
@@ -190,7 +187,7 @@ def register_decode( txt, default=None ):
 
 def register_definitions( registers, default=None ):
     """Parse the register ranges, as: registers[, registers ...], and produce a keywords dictionary
-    suitable for construction of modbus_sparse_data_block instances for a ModbusSlaveContext, for
+    suitable for construction of ModbusSparseDataBlock instances for a ModbusSlaveContext, for
     'hr' (Holding Registers), 'co' (Coils), etc.:
 
         40001=999
@@ -459,7 +456,8 @@ def main( argv=None ):
     starter_kwds		= {}
     try:
         # See if it's an <interface>[:<port>].  If it has '/' in it, assume its a device
-        assert '/' not in address
+        assert '/' not in args.address and not os.path.exists( args.address ), \
+            "appears to be a file: {address}".format( address=address )
         starter			= StartTcpServerLogging
         framer			= FramerType.SOCKET
         address			= cpppo.parse_ip_port( args.address, default=(None,Defaults.Port) )
@@ -494,7 +492,6 @@ def main( argv=None ):
         assert args.range == 1, \
             "A range of serial ports is unsupported"
 
-    logging.info( "Modbus Framer: {framer}".format( framer=framer ))
     framer			= FRAMER_NAME_TO_CLASS[framer]
 
     #---------------------------------------------------------------------------#
@@ -536,7 +533,7 @@ def buildFrame(self, message):
                 delay		= self.delay
                 if isinstance( delay, (list,tuple) ):
                     delay	= random.uniform( *delay )
-                time.sleep( delay )
+                time.sleep( delay )  # blocks the entire asyncio program!  No other I/O occurs.
 
                 return packet
 
@@ -577,7 +574,7 @@ def buildFrame(self, message):
                         packet	= super( EvilFramerCorruptResponse, self ).buildFrame( message )
                         message.transaction_id ^= 0xFFFF
                     elif self.what == "registers":
-                        if isinstance( message, ReadRegistersResponseBase ):
+                        if isinstance( message, ReadHoldingRegistersResponse ):
                             # These have '.registers' attribute, which is a list.
                             # Add/remove some
                             saveregs		= message.registers

README.txt

@@ -32,7 +32,7 @@
 from .tools.waits import waitfor
 
 RTU_WAIT			= 2.0  # How long to wait for the simulator
-RTU_LATENCY			= 0.05 # poll for command-line I/O response 
+RTU_LATENCY			= 0.05 # poll for command-line I/O response
 
 class nonblocking_command( object ):
     """Set up a non-blocking command producing output.  Read the output using:
@@ -196,7 +196,7 @@ def start_modbus_simulator( *options ):
     here.
 
     """
-    return start_simulator( 
+    return start_simulator(
         os.path.join( os.path.dirname( os.path.abspath( __file__ )), 'bin', 'modbus_sim.py' ),
         *options
     )
@@ -213,12 +213,12 @@ def run_plc_modbus_polls( plc ):
     wfkw			= dict( timeout=timeout, intervals=intervals )
 
     plc.poll( 40001, rate=rate )
-    
+
     success,elapsed		= waitfor( lambda: plc.read( 40001 ) is not None, "40001 polled", **wfkw )
     assert success
     assert elapsed < 1.0
     assert plc.read( 40001 ) == 0
-    
+
     assert plc.read(     1 ) == None
     assert plc.read( 40002 ) == None
     success,elapsed		= waitfor( lambda: plc.read( 40002 ) is not None, "40002 polled", **wfkw )
@@ -234,11 +234,11 @@ def run_plc_modbus_polls( plc ):
     # number of distinct poll ranges will increase, and then decrease as we in-fill and the
     # inter-register range drops below the merge reach 10, allowing the polling to merge ranges.
     # Thus, keep track of the number of registers added, and allow
-    # 
-    # avg. 
+    #
+    # avg.
     # poll
     # time
-    #  
+    #
     #   |
     #   |
     # 4s|         ..
@@ -252,7 +252,7 @@ def run_plc_modbus_polls( plc ):
     # need to more than double the Nyquist-rate timeout
     wfkw['timeout']	       *= 2.5
     wfkw['intervals']	       *= 2.5
-    
+
     regs			= {}
     extent			= 100 # how many each of coil/holding registers
     total			= extent*2 # total registers in play

bin/modbus_sim.py

@@ -41,10 +41,8 @@
 
 
 from pymodbus.exceptions import ModbusException, ParameterException
-from pymodbus.pdu.bit_read_message import ReadDiscreteInputsRequest, ReadCoilsRequest
-from pymodbus.pdu.bit_write_message import WriteSingleCoilRequest, WriteMultipleCoilsRequest
-from pymodbus.pdu.register_read_message import ReadHoldingRegistersRequest, ReadInputRegistersRequest
-from pymodbus.pdu.register_write_message import WriteSingleRegisterRequest, WriteMultipleRegistersRequest
+from pymodbus.pdu.bit_message import ReadDiscreteInputsRequest, ReadCoilsRequest, WriteSingleCoilRequest, WriteMultipleCoilsRequest
+from pymodbus.pdu.register_message import ReadHoldingRegistersRequest, ReadInputRegistersRequest, WriteSingleRegisterRequest, WriteMultipleRegistersRequest
 from pymodbus.pdu import ExceptionResponse, ModbusPDU as ModbusResponse
 
 log				= logging.getLogger( __package__ )

modbus_test.py

@@ -70,15 +70,12 @@ def _eintr_retry(func, *args):
 
 from pymodbus import __version__ as pymodbus_version
 from pymodbus.server import ModbusTcpServer, ModbusSerialServer
-#from pymodbus.transaction import ModbusSocketFramer, ModbusRtuFramer
-
 from pymodbus.client import ModbusTcpClient, ModbusSerialClient
-#from pymodbus.factory import ClientDecoder
 from pymodbus.exceptions import ConnectionException
 from pymodbus.pdu import ExceptionResponse
-#from pymodbus.utilities import checkCRC
 from pymodbus.datastore.store import ModbusSparseDataBlock
 
+
 # Historically part of pymodbus to contain global defaults; now hosted here
 @dataclass
 class Defaults:
@@ -87,30 +84,6 @@ class Defaults:
     Timeout	= 1.0
 
 
-# Correct an invalid default; ensure our *ModbusDataStore always correctly bases
-# requests from 0 (the human-readable addresses, eg. 1, 10001, 40001) have been
-# parsed and converted to zero-based addresses by the client, before the request
-# is sent).  We will always convert standard Modbus typed addresses (eg. 40001
-# for Holding Registers) from 1-base to 0-base before making the appropriate
-# pymodbus register I/O requests.  Pymodbus shouldn't be doing this for us.
-
-#Defaults.ZeroMode		= True
-
-class modbus_sparse_data_block( ModbusSparseDataBlock ):
-    """Implement a ModbusSparseDataBlock that isn't spectacularly inefficient, and also correctly
-    deduces the lowest address.
-
-    """
-    def __init__( self, values ):
-        super( modbus_sparse_data_block, self ).__init__( values )
-        self.address		= min( self.values )
-
-    # def validate( self, address, count=1 ):
-    #     logging.debug( "checking %5d-%5d", address, address + count - 1 )
-    #     if count == 0: return False
-    #     return all( r in self.values for r in range( address, address + count ))
-
-
 class modbus_communication_monitor( object ):
     """Outfit a pymodbus asyncio ModbusXxxServer to report communication_failed when a connect or
     listen is attempted, but does not succeed.  This is necessary in order to abort a ...Server if a
@@ -152,7 +125,7 @@ class modbus_server_tcp( modbus_communication_monitor, ModbusTcpServer ):
     """An asyncio.BaseProtocol based Modbus TCP server. """
     pass
 
-                         
+
 class modbus_server_tcp_printing( modbus_server_tcp ):
 
     def callback_communication( self, established ):

remote/plc_modbus.py

@@ -48,7 +48,7 @@
     from .remote.plc_modbus import poller_modbus, merge, shatter
     from .remote.pymodbus_fixes import modbus_client_tcp, modbus_server_tcp, Defaults
     has_pymodbus		= True
-except ImportError:
+except ImportError as exc:
     logging.warning( "Failed to import pymodbus module; skipping Modbus/TCP related tests; run 'pip install pymodbus': {exc}".format( exc=exc ))
 
 

remote/pymodbus_fixes.py

@@ -1,2 +1,2 @@
-minimalmodbus	>=2.1,
-pymodbus	>=3.7,	<4.0
+minimalmodbus	>=2.1,	<3
+pymodbus	>=3.7,	<4

remote_test.py

@@ -34,7 +34,7 @@
 
 import pytest
 
-# 
+#
 # We require *explicit* access to the /dev/ttys[012] serial ports to perform this test -- we must
 # not assume that can safely use the serial port(s), or that they are configured for us to run our
 # tests!  Therefore, we will run these tests ONLY if "serial" tests are explicitly called for
@@ -43,12 +43,12 @@
 # They must be configured as RS485, in the following multi-drop pattern:
 #
 #     - master -      - slaves -----------------
-#     ttyS0(COM1) --> ttys1(COM2) --> ttys2(COM3)
-# 
+#     ttyS0(COM1) --> ttyS1(COM2) --> ttyS2(COM3)
+#
 # The Modbus Master will be on ttyS0, and two Modbus slave-ids (unit numbers) will be simulated on
 # each of ttyS1 and ttyS2.  Since they each must ignore requests to slave-ids they do not simulate,
 # pymodbus >= 1.3.0 is required.
-# 
+#
 PORT_MASTER			= "ttyS0"
 PORT_SLAVES			= {
     "ttyS1": [1,3],
@@ -68,7 +68,7 @@
     has_pyserial		= True
 except ImportError:
     logging.warning( "Failed to import pyserial module; skipping Modbus/RTU related tests; run 'pip install pyserial'" )
-    
+
 has_minimalmodbus		= False
 try:
     # Configure minimalmodbus to use the specified port serial framing
@@ -135,7 +135,6 @@ def test_pymodbus_rs485_sync():
         # handle_local_echo=False,
     )
 
-    # Start the server on 
     import asyncio
     from contextlib import suppress
 
@@ -193,14 +192,14 @@ async def server_start( port, unit ):
             **serial_args,
         )
         client.connect()
-    
-        rr1			= client.read_coils( 1, 1, slave=1 )
-        rr2			= client.read_coils( 2, 1, slave=2 )
+
+        rr1			= client.read_coils( 1, count=1, slave=1 )
+        rr2			= client.read_coils( 2, count=1, slave=2 )
         assert (( not rr2.isError() and rr2.bits[0] == True ) or
-                ( not rr1.isError() and rr.bits[0] == False ))
-        rr3			= client.read_coils( 2, 1, slave=3 )
+                ( not rr1.isError() and rr1.bits[0] == False ))
+        rr3			= client.read_coils( 2, count=1, slave=3 )
         assert rr3.isError()
-    
+
         client.close()
         del client
 
@@ -217,7 +216,7 @@ def reader():
             with client:
                 unit		= 1+a%len(SERVER_ttyS)
                 expect		= not bool( a%2 )
-                rr		= client.read_coils( 1, a, slave=unit )
+                rr		= client.read_coils( a, count=1, slave=unit )
                 if rr.isError() or rr.bits[0] != expect:
                     logging.warning( "Expected unit {unit} coil {a} == {expect}, got {val}".format(
                         unit=unit, a=a, expect=expect, val=( rr if rr.isError() else rr.bits[0] )))
@@ -238,7 +237,6 @@ def reader():
         asyncio.run_coroutine_threadsafe( s.shutdown(), l )
     for u in servers:
         servers[u].join()
-        
 
 
 RTU_TIMEOUT			= 0.1  # latency while simulated slave awaits next incoming byte
@@ -275,7 +273,7 @@ def simulated_modbus_rtu( tty ):
 
 @pytest.fixture( scope="module" )
 def simulated_modbus_rtu_ttyS1( request ):
-    command,address		= simulated_modbus_rtu( "ttyS1" )
+     command,address		= simulated_modbus_rtu( "ttyS1" )
     request.addfinalizer( command.kill )
     return command,address
 
@@ -342,7 +340,7 @@ def test_rs485_poll( simulated_modbus_rtu_ttyS1 ):
         assert success
         assert elapsed < 1.0
         assert plc.read( 40001 ) == 0
-    
+
         assert plc.read(     1 ) == None
         assert plc.read( 40002 ) == None
         success,elapsed		= waitfor( lambda: plc.read( 40002 ) is not None, "40002 polled", **wfkw )
@@ -358,7 +356,7 @@ def test_rs485_poll( simulated_modbus_rtu_ttyS1 ):
         success,elapsed		= waitfor( lambda: plc.read( 40001 ) == 99, "40001 polled", **wfkw )
         assert success
         assert elapsed < 1.0
-        
+
         # See if we converge on our target poll time
         count			= plc.counter
         while plc.counter < count + 20: