Minor updates to examples

Author: dhoomakethu

examples/common/changing_framers.py

@@ -23,8 +23,8 @@
 # Import the modbus framer that you want
 # --------------------------------------------------------------------------- #
 # --------------------------------------------------------------------------- #
-#from pymodbus.transaction import ModbusSocketFramer as ModbusFramer
-from pymodbus.transaction import ModbusRtuFramer as ModbusFramer
+from pymodbus.transaction import ModbusSocketFramer as ModbusFramer
+# from pymodbus.transaction import ModbusRtuFramer as ModbusFramer
 #from pymodbus.transaction import ModbusBinaryFramer as ModbusFramer
 #from pymodbus.transaction import ModbusAsciiFramer as ModbusFramer
 
@@ -48,7 +48,7 @@
     # ----------------------------------------------------------------------- #
     rq = client.write_coil(1, True)
     rr = client.read_coils(1,1)
-    assert(rq.isError() is False)     # test that we are not an error
+    assert(not rq.isError())     # test that we are not an error
     assert(rr.bits[0] == True)          # test the expected value
 
     # ----------------------------------------------------------------------- #

examples/common/modbus_payload.py

@@ -21,7 +21,7 @@
           ' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
 logging.basicConfig(format=FORMAT)
 log = logging.getLogger()
-log.setLevel(logging.DEBUG)
+log.setLevel(logging.INFO)
 
 
 def run_binary_payload_ex():

examples/common/synchronous_client.py

@@ -78,7 +78,6 @@ def run_sync_client():
     # which defaults to `0x00`
     # ----------------------------------------------------------------------- #
     log.debug("Reading Coils")
-
     rr = client.read_coils(1, 1, unit=UNIT)
     log.debug(rr)
 
@@ -98,14 +97,14 @@ def run_sync_client():
     log.debug("Write to a Coil and read back")
     rq = client.write_coil(0, True, unit=UNIT)
     rr = client.read_coils(0, 1, unit=UNIT)
-    assert(rq.isError() is False)     # test that we are not an error
+    assert(not rq.isError())     # test that we are not an error
     assert(rr.bits[0] == True)          # test the expected value
 
     log.debug("Write to multiple coils and read back- test 1")
     rq = client.write_coils(1, [True]*8, unit=UNIT)
-    assert(rq.isError() is False)     # test that we are not an error
+    assert(not rq.isError())     # test that we are not an error
     rr = client.read_coils(1, 21, unit=UNIT)
-    assert(rr.isError() is False)     # test that we are not an error
+    assert(not rr.isError())     # test that we are not an error
     resp = [True]*21
 
     # If the returned output quantity is not a multiple of eight,
@@ -118,28 +117,28 @@ def run_sync_client():
     log.debug("Write to multiple coils and read back - test 2")
     rq = client.write_coils(1, [False]*8, unit=UNIT)
     rr = client.read_coils(1, 8, unit=UNIT)
-    assert(rq.isError() is False)     # test that we are not an error
+    assert(not rq.isError())     # test that we are not an error
     assert(rr.bits == [False]*8)         # test the expected value
 
     log.debug("Read discrete inputs")
     rr = client.read_discrete_inputs(0, 8, unit=UNIT)
-    assert(rq.isError() is False)     # test that we are not an error
+    assert(not rq.isError())     # test that we are not an error
 
     log.debug("Write to a holding register and read back")
     rq = client.write_register(1, 10, unit=UNIT)
     rr = client.read_holding_registers(1, 1, unit=UNIT)
-    assert(rq.isError() is False)     # test that we are not an error
+    assert(not rq.isError())     # test that we are not an error
     assert(rr.registers[0] == 10)       # test the expected value
 
     log.debug("Write to multiple holding registers and read back")
     rq = client.write_registers(1, [10]*8, unit=UNIT)
     rr = client.read_holding_registers(1, 8, unit=UNIT)
-    assert(rq.isError() is False)     # test that we are not an error
+    assert(not rq.isError())     # test that we are not an error
     assert(rr.registers == [10]*8)      # test the expected value
 
     log.debug("Read input registers")
     rr = client.read_input_registers(1, 8, unit=UNIT)
-    assert(rq.isError() is False)     # test that we are not an error
+    assert(not rq.isError())     # test that we are not an error
 
     arguments = {
         'read_address':    1,
@@ -150,7 +149,7 @@ def run_sync_client():
     log.debug("Read write registeres simulataneously")
     rq = client.readwrite_registers(unit=UNIT, **arguments)
     rr = client.read_holding_registers(1, 8, unit=UNIT)
-    assert(rq.isError() is False)     # test that we are not an error
+    assert(not rq.isError())     # test that we are not an error
     assert(rq.registers == [20]*8)      # test the expected value
     assert(rr.registers == [20]*8)      # test the expected value
 

examples/common/synchronous_client_ext.py

@@ -16,7 +16,6 @@
 
 
 # --------------------------------------------------------------------------- # 
-
 # import the extended messages to perform
 # --------------------------------------------------------------------------- #
 from pymodbus.diag_message import *
@@ -47,7 +46,6 @@ def execute_extended_requests():
     #
     # It should be noted that you can supply an ipv4 or an ipv6 host address
     # for both the UDP and TCP clients.
-
     # ------------------------------------------------------------------------# 
     client = ModbusClient(method='rtu', port="/dev/ptyp0")
     # client = ModbusClient(method='ascii', port="/dev/ptyp0")
@@ -84,7 +82,7 @@ def execute_extended_requests():
     rr = client.execute(rq)
     log.debug(rr)
     # assert(rr == None)              # not supported by reference
-    # assert (rr.isError() is False)  # test that we are not an error
+    # assert (not rr.isError())  # test that we are not an error
     # assert (rr.information[0] == b'Pymodbus')  # test the vendor name
     # assert (rr.information[1] == b'PM')  # test the product code
     # assert (rr.information[2] == b'1.0')  # test the code revision
@@ -94,7 +92,7 @@ def execute_extended_requests():
     rr = client.execute(rq)
     log.debug(rr)
     # assert(rr == None)                        # not supported by reference
-    # assert(rr.isError() is False)           # test that we are not an error
+    # assert(not rr.isError())           # test that we are not an error
     # assert(rr.identifier  == 0x00)            # test the slave identifier
     # assert(rr.status  == 0x00)                # test that the status is ok
 
@@ -103,15 +101,15 @@ def execute_extended_requests():
     rr = client.execute(rq)
     log.debug(rr)
     # assert(rr == None)                        # not supported by reference
-    # assert(rr.isError() is False)           # test that we are not an error
+    # assert(not rr.isError())           # test that we are not an error
     # assert(rr.status == 0x55)                 # test the status code
 
     log.debug("Running GetCommEventCounterRequest")
     rq = GetCommEventCounterRequest(unit=UNIT)
     rr = client.execute(rq)
     log.debug(rr)
     # assert(rr == None)                       # not supported by reference
-    # assert(rr.isError() is False)          # test that we are not an error
+    # assert(not rr.isError())          # test that we are not an error
     # assert(rr.status == True)                # test the status code
     # assert(rr.count == 0x00)                 # test the status code
 
@@ -120,7 +118,7 @@ def execute_extended_requests():
     rr = client.execute(rq)
     log.debug(rr)
     # assert(rr == None)                       # not supported by reference
-    # assert(rr.isError() is False)          # test that we are not an error
+    # assert(not rr.isError())          # test that we are not an error
     # assert(rr.status == True)                # test the status code
     # assert(rr.event_count == 0x00)           # test the number of events
     # assert(rr.message_count == 0x00)         # test the number of messages

examples/contrib/remote_server_context.py

@@ -113,7 +113,7 @@ def __extract_result(self, fx, result):
         :param fx: The function to call
         :param result: The resulting data
         """
-        if result.isError() is False:
+        if not result.isError():
             if fx in ['d', 'c']:
                 return result.bits
             if fx in ['h', 'i']:

examples/contrib/serial_forwarder.py

@@ -29,14 +29,14 @@ def run_serial_forwarder():
     # ----------------------------------------------------------------------- #
     # initialize the datastore(serial client)
     # ----------------------------------------------------------------------- #
-    client = ModbusClient(method='ascii', port='/dev/pts/14')
+    client = ModbusClient(method='rtu', port='/dev/ptyp0')
     store = RemoteSlaveContext(client)
     context = ModbusServerContext(slaves=store, single=True)
 
     # ----------------------------------------------------------------------- #
     # run the server you want
     # ----------------------------------------------------------------------- #
-    StartServer(context)
+    StartServer(context, address=("localhost", 5020))
 
 
 if __name__ == "__main__":

pymodbus/datastore/remote.py

@@ -99,7 +99,7 @@ def __extract_result(self, fx, result):
         ''' A helper method to extract the values out of
         a response.  TODO make this consistent (values?)
         '''
-        if result.isError() is False:
+        if not result.isError():
             if fx in ['d', 'c']: return result.bits
             if fx in ['h', 'i']: return result.registers
         else: return result

pymodbus/transaction.py

@@ -430,7 +430,6 @@ def delTransaction(self, tid):
 
 
 # --------------------------------------------------------------------------- #
-
 # Exported symbols
 # --------------------------------------------------------------------------- #
 __all__ = [

tox.ini

@@ -8,7 +8,7 @@ envlist = py27, py34, py35, py36, pypy
 
 [testenv]
 deps = -requirements-tests.txt
-commands = nostests {posargs}
+commands = py.test {posargs}
 
 [flake8]
 exclude = .tox