Mostly operational pymodbus integration (ex. RS-485 multi-drop)

Author: pjkundert

.gitignore

@@ -26,3 +26,5 @@ dist/
 .cache/
 *.aux
 *.toc
+/ttyS[0-9]
+/ttyV[0-9]

bin/modbus_sim.py

@@ -502,8 +502,8 @@ def main( argv=None ):
             'stopbits':			1,
             'bytesize':			8,
             'parity':			serial.PARITY_NONE,
-            'baudrate':			4800,
-            'timeout':			0.5,
+            'baudrate':			9600,
+            'timeout':			0.05,
             'slaves':			None,
             'ignore_missing_slaves':	True,
         }

default.nix

@@ -70,16 +70,22 @@ in
     ];
   };
 
+  # Configure ~/.config/nixpkgs/config.nix to allow:
+  # {
+  #   allowUnfree = true;
+  #   permittedInsecurePackages = [
+  #     "python-2.7.18.8"
+  #   ];
+  # }
   py27 = stdenv.mkDerivation rec {
-    name = "python2-with-pytest";
+    name = "python27-with-pip";
 
     buildInputs = [
       cacert
       git
       gnumake
       openssh
       python27
-      python27Packages.pytest
       python27Packages.pip
     ];
   };

misc.py

@@ -764,9 +764,10 @@ 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|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.
+    """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:
@@ -780,29 +781,44 @@ def parse_ip_port( netloc, default=(None,None) ):
             addr	= ip( addr.hostname )
         except:
             pass
+        logging.info( "{addr!r}:{port!r} from {netloc!r}: found a Python actual or literal tuple".format(
+            addr=addr, port=port, netloc=netloc ))
     except Exception:
         try:
             # Raw IPv{4,6} address, eg "1.2.3.4", "::1"
             addr		= ip( netloc )
             port		= None
+            logging.info( "{addr!r}:{port!r} from {netloc!r}: found a bare IP address".format(
+                addr=addr, port=port, netloc=netloc ))
         except ValueError:
-            # IPv{4,6} address:port, eg "1.2.3.4:80", "[::1]:80" (raw IP only returned as an ip_address)
+            # IPv{4,6} address:port, eg "1.2.3.4:80", "[::1]:80" (raw IP only returned as an
+            # ip_address).  Retains case, if no port supplied (eg. for entities that are not hosts,
+            # such as "ttyS1".)
             try:
                 parsed		= urlparse( '//{}'.format( netloc ))
-                addr		= parsed.hostname
                 port		= parsed.port  # will be None or int
+                addr		= parsed.netloc if port is None else parsed.hostname
                 try:
                     addr	= ip( parsed.hostname )
                 except:
                     pass
+                logging.info( "{addr!r}:{port!r} from {netloc!r}: found a URL".format(
+                    addr=addr, port=port, netloc=netloc ))
             except:
-                # "<hostname>[:<port>]" or even the degenerate and non-deterministic "::1:12345"
-                # (anything other than a rew IP will be returned as a str)
+                # "<hostname>[:<port>]" or even the degenerate and non-deterministic "::1:12345" --
+                # use deterministic [<IPv6>]:<port> instead!  Anything other than a rew IP will be
+                # returned as a str.
                 addr_port	= netloc.rsplit( ':', 1 )
                 assert 1 <= len( addr_port ) <= 2 and not addr_port[0].endswith( ':' ), \
                     "Expected <host>[:<port>], found {netloc!r}".format( netloc=netloc )
                 addr		= addr_port[0]
+                try:
+                    addr	= ip( addr )
+                except:
+                    pass
                 port		= None if len( addr_port ) < 2 else addr_port[1]
+                logging.info( "{addr!r}:{port!r} from {netloc!r}: found a colon-separated string".format(
+                    addr=addr, port=port, netloc=netloc ))
 
     # An empty ip is overridden by a non-None default[0], but either could still be '', which is a
     # valid i'face designation.

misc_test.py

@@ -172,10 +172,12 @@ def test_parse_ip_port():
         "::192.168.0.1":		( ip("::c0a8:1"), 			None ),
         "2605:2700:0:3::4713:93e3":	( ip("2605:2700:0:3::4713:93e3"),	None ),
         "[2605:2700:0:3::4713:93e3]:80":( ip("2605:2700:0:3::4713:93e3"),	80),
-        "::1:12345":			( "::1",				12345 ),
-        "boogaloo.cash:443":		( "boogaloo.cash",			443 ),
+        "::1:12345":			( ip("::1"),				12345 ),
+        "Boogaloo.cash:443":		( "boogaloo.cash",			443 ),
+        "Boogaloo.cash":		( "Boogaloo.cash",			None),
         "('host', None)":		( "host",				None ),
         "('host', 443)":		( "host",				443 ),
+        "ttyS1":			( "ttyS1",				None ),
     }.items():
         r			= parse_ip_port( t )
         assert r == (a,p), \
@@ -189,10 +191,12 @@ def test_parse_ip_port():
         "::192.168.0.1":		( ip("::c0a8:1"), 			123 ),
         "2605:2700:0:3::4713:93e3":	( ip("2605:2700:0:3::4713:93e3"),	123 ),
         "[2605:2700:0:3::4713:93e3]:80":( ip("2605:2700:0:3::4713:93e3"),	80),
-        "::1:12345":			( "::1",				12345 ),
-        "boogaloo.cash:443":		( "boogaloo.cash",			443 ),
+        "::1:12345":			( ip("::1"),				12345 ),
+        "Boogaloo.cash:443":		( "boogaloo.cash",			443 ),
+        "Boogaloo.cash":		( "Boogaloo.cash",			123 ),
         "('host', None)":		( "host",				123 ),
         "('host', 443)":		( "host",				443 ),
+        "ttyS1":			( "ttyS1",				123 ),
     }.items():
         r			= parse_ip_port( t, default=(None,123) ) 
         assert r == (a,p), \

modbus_test.py

@@ -203,6 +203,11 @@ def start_modbus_simulator( *options ):
 
 
 def run_plc_modbus_polls( plc ):
+    """ Assumes:
+    coils     1 == 1,0,...
+    hregs 40001 == 1,2,3,4,5,6,7,8,9,0,...
+
+    """
     # Initial conditions (in case PLC is persistent between tests)
     plc.write(     1, 0 )
     plc.write( 40001, 0 )
@@ -217,18 +222,18 @@ def run_plc_modbus_polls( plc ):
     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( 40001 ) == 0  # Initial condition set above
 
     assert plc.read(     1 ) == None
     assert plc.read( 40002 ) == None
     success,elapsed		= waitfor( lambda: plc.read( 40002 ) is not None, "40002 polled", **wfkw )
     assert success
     assert elapsed < 1.0
-    assert plc.read( 40002 ) == 0
+    assert plc.read( 40002 ) == 2  # Default condition of simulator
     success,elapsed		= waitfor( lambda: plc.read(     1 ) is not None, "00001 polled", **wfkw )
     assert success
     assert elapsed < 1.0
-    assert plc.read(     1 ) == 0
+    assert plc.read(     1 ) == 0  # Initial condition set above
 
     # Now add a bunch of new stuff to poll, and ensure polling occurs.  As we add registers the
     # number of distinct poll ranges will increase, and then decrease as we in-fill and the

remote/plc_modbus.py

@@ -293,6 +293,7 @@ def _write( self, address, value, **kwargs ):
         value			= list( value ) if multi else [ value ]
         writer			= None
         unit			= kwargs.pop( 'unit', self.unit )
+        # The count is deduced from the size of .registers/.bits
         kwargs.update( dev_id=unit )
         if 400001 <= address <= 465536:
             # 400001-465536: Holding Registers
@@ -326,8 +327,8 @@ def _write( self, address, value, **kwargs ):
             pass
         if not writer:
             raise ParameterException( "Invalid Modbus address for write: %d" % ( address ))
-
-        result			= self.client.execute( no_response_expected=False, request=writer( **kwargs ))
+        request			= writer( **kwargs )
+        result			= self.client.execute( no_response_expected=False, request=request )
         if isinstance( result, ExceptionResponse ):
             raise ModbusException( str( result ))
         assert isinstance( result, ModbusResponse ), "Unexpected non-ModbusResponse: %r" % result
@@ -346,49 +347,71 @@ def _read( self, address, count=1, **kwargs ):
             raise PlcOffline( "Modbus Read  of PLC %s/%6d failed: Offline; Connect failure" % (
                     self.description, address ))
 
+        unit			= kwargs.pop( 'unit', self.unit )
+        kwargs.update( dev_id=unit, count=count )
+
         # Use address to deduce Holding/Input Register or Coil/Status.
         reader			= None
-        xformed			= address
         if 400001 <= address <= 465536:
             reader		= ReadHoldingRegistersRequest
-            xformed	       -= 400001
+            kwargs.update(
+                address		= address - 400001,
+            )
         elif 300001 <= address <= 365536:
             reader		= ReadInputRegistersRequest
-            xformed    	       -= 300001
+            kwargs.update(
+                address		= address - 300001,
+            )
         elif 100001 <= address <= 165536:
             reader		= ReadDiscreteInputsRequest
-            xformed    	       -= 100001
+            kwargs.update(
+                address		= address - 100001,
+            )
         elif 40001 <= address <= 99999:
             reader		= ReadHoldingRegistersRequest
-            xformed    	       -= 40001
+            kwargs.update(
+                address		= address - 40001,
+            )
         elif 30001 <= address <= 39999:
             reader		= ReadInputRegistersRequest
-            xformed    	       -= 30001
+            kwargs.update(
+                address		= address - 30001,
+            )
         elif 10001 <= address <= 19999:
             reader		= ReadDiscreteInputsRequest
-            xformed    	       -= 10001
+            kwargs.update(
+                address		= address - 10001,
+            )
         elif 1 <= address <= 9999:
             reader		= ReadCoilsRequest
-            xformed	       -= 1
+            kwargs.update(
+                address		= address - 1,
+            )
         else:
             # Invalid address
             pass
         if not reader:
             raise ParameterException( "Invalid Modbus address for read: %d" % ( address ))
 
-        unit			= kwargs.pop( 'unit', self.unit )
-        request			= reader( address=xformed, count=count, dev_id=unit, **kwargs )
+        request			= reader( **kwargs )
         log.debug( "%s/%6d-%6d transformed to %s", self.description, address, address + count - 1,
                    request )
 
         result 			= self.client.execute( no_response_expected=False, request=request )
+        log.debug( "%s/%6d-%6d responded w/:  %s", self.description, address, address + count - 1,
+                   result )
         if isinstance( result, ExceptionResponse ):
             # The remote PLC returned a response indicating it encountered an
             # error processing the request.  Convert it to raise a ModbusException.
             raise ModbusException( str( result ))
         assert isinstance( result, ModbusResponse ), "Unexpected non-ModbusResponse: %r" % result
 
-        # The result may contain .bits or .registers,  1 or more values
-        values			= result.bits if hasattr( result, 'bits' ) else result.registers
-        return values if len( values ) > 1 else values[0]
+        # The result may contain .bits or .registers, 1 or more values.  Unfortunately, pymodbus
+        # puts the data in .bits or .registers, and doesn't supply a method to know which, unless we
+        # decode the protocol here.  Truncate response to requested count, as bits is unpacked
+        # from bytes, and padded w/ undefined data.
+        values			= result.registers or result.bits
+        log.debug( "%s/%6d-%6d received:      %r", self.description, address, address + count - 1,
+                   values )
+        return values[:count] if count > 1 else values[0]