Progess toward pymodbus 3.7 support

Author: pjkundert

.gitignore

@@ -24,3 +24,5 @@ dist/
 .vagrant
 .pytest_cache/
 .cache/
+*.aux
+*.toc

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
@@ -336,6 +333,13 @@ class StartAsyncServer( object ):
     :param address: An optional (interface, port) to bind to.
     :param slaves: An optional single (or list of) Slave IDs to serve
 
+    Assumes that the self.server_async asyncio program will identify failure
+    conditions (ie. cannot connect), and signal itself to stop.  The
+    modbus_server_...  implementations do this by monitoring the success of
+    .listen/.connect and schedule themselves an async .shutdown on failure.
+
+    Otherwise, they print the successfully bound i'face:port or serial device.
+
     '''
     def __init__( self, *args, registers=None, slaves=None, **kwds ):
         global context
@@ -459,7 +463,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=args.address )
         starter			= StartTcpServerLogging
         framer			= FramerType.SOCKET
         address			= cpppo.parse_ip_port( args.address, default=(None,Defaults.Port) )
@@ -494,7 +499,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 +540,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 +581,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

@@ -764,14 +764,17 @@ def network( a ):
     return ip_network( unicode( a ))
 
 def parse_ip_port( netloc, default=(None,None) ):
-    """Parse an <interface>[:<port>] with the supplied defaults, returning <host>,<port>.  A Truthy host
-    portion is required (ie. non-empty); port is optional.  Returns ip as an ip_address (if
-    possible), otherwise as a str; either form can be converted to str, if desired.
+    """Parse an <interface>[:<port>] with the supplied defaults, returning <host>,<port|None>.  A
+    Truthy host portion is required (ie. non-empty); port is optional.  Returns ip as an ip_address
+    (if possible), otherwise as a str; either form can be converted to str, if desired.
 
     """
     try:
-        # "('hostname', port)" tuple
-        addr,port	= ast.literal_eval( netloc )
+        # A literal "('hostname', port)" tuple or an actual tuple pair
+        if isinstance( netloc, type_str_base ):
+            addr,port	= ast.literal_eval( netloc )
+        else:
+            addr,port	= netloc
         assert isinstance( addr, type_str_base ) and isinstance( port, (int, type(None)) )
         try:
             addr	= ip( addr.hostname )
@@ -787,7 +790,7 @@ def parse_ip_port( netloc, default=(None,None) ):
             try:
                 parsed		= urlparse( '//{}'.format( netloc ))
                 addr		= parsed.hostname
-                port		= parsed.port
+                port		= parsed.port  # will be None or int
                 try:
                     addr	= ip( parsed.hostname )
                 except:

abplus.png

@@ -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:
@@ -186,8 +186,8 @@ def start_simulator( simulator, *options, **kwds ):
 
     assert control.address, "Failed to harvest Simulator IP address"
 
-    logging.normal( "Simulator started after %7.3fs on %r:%d",
-                    misc.timer() - begun, control.address[0], control.address[1] )
+    logging.normal( "Simulator started after %7.3fs on %s",
+                    misc.timer() - begun, ':'.join( map( repr, control.address )))
     return command,control.address
 
 
@@ -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