#82 error response api (#262)

* easily to check for errors in stead of having to manually compare
response codes

Author: rahulraghu94

examples/common/asynchronous_client.py

@@ -6,30 +6,30 @@
 The following is an example of how to use the asynchronous modbus
 client implementation from pymodbus.
 """
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # import needed libraries
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 from twisted.internet import reactor, protocol
 from pymodbus.constants import Defaults
 
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # choose the requested modbus protocol
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 from pymodbus.client.async import ModbusClientProtocol
 from pymodbus.client.async import ModbusUdpClientProtocol
 from pymodbus.framer.rtu_framer import ModbusRtuFramer
 
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # configure the client logging
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 import logging
 FORMAT = ('%(asctime)-15s %(threadName)-15s'
           ' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
 logging.basicConfig(format=FORMAT)
 log = logging.getLogger()
 log.setLevel(logging.DEBUG)
 
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # helper method to test deferred callbacks
 # --------------------------------------------------------------------------- #
 
@@ -40,9 +40,9 @@ def _assertor(value):
     deferred.addCallback(lambda r: _assertor(callback(r)))
     deferred.addErrback(lambda _: _assertor(False))
 
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # specify slave to query
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # The slave to query is specified in an optional parameter for each
 # individual request. This can be done by specifying the `unit` parameter
 # which defaults to `0x00`
@@ -64,9 +64,9 @@ def exampleRequests(client):
     rr.addCallback(processResponse)
     stopAsynchronousTest(client)
 
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # example requests
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # simply call the methods that you would like to use. An example session
 # is displayed below along with some assert checks. Note that unlike the
 # synchronous version of the client, the asynchronous version returns
@@ -89,45 +89,45 @@ def stopAsynchronousTest(client):
 def beginAsynchronousTest(client):
     rq = client.write_coil(1, True, unit=UNIT)
     rr = client.read_coils(1, 1, unit=UNIT)
-    dassert(rq, lambda r: r.function_code < 0x80)     # test for no error
+    dassert(rq, lambda r: not r.isError())     # test for no error
     dassert(rr, lambda r: r.bits[0] == True)          # test the expected value
-    
+
     rq = client.write_coils(1, [True]*8, unit=UNIT)
     rr = client.read_coils(1, 8, unit=UNIT)
-    dassert(rq, lambda r: r.function_code < 0x80)     # test for no error
+    dassert(rq, lambda r: not r.isError())     # test for no error
     dassert(rr, lambda r: r.bits == [True]*8)        # test the expected value
-    
+
     rq = client.write_coils(1, [False]*8, unit=UNIT)
     rr = client.read_discrete_inputs(1, 8, unit=UNIT)
-    dassert(rq, lambda r: r.function_code < 0x80)     # test for no error
+    dassert(rq, lambda r: not r.isError())     # test for no error
     dassert(rr, lambda r: r.bits == [True]*8)        # test the expected value
-    
+
     rq = client.write_register(1, 10, unit=UNIT)
     rr = client.read_holding_registers(1, 1, unit=UNIT)
-    dassert(rq, lambda r: r.function_code < 0x80)     # test for no error
+    dassert(rq, lambda r: not r.isError())     # test for no error
     dassert(rr, lambda r: r.registers[0] == 10)       # test the expected value
-    
+
     rq = client.write_registers(1, [10]*8, unit=UNIT)
     rr = client.read_input_registers(1, 8, unit=UNIT)
-    dassert(rq, lambda r: r.function_code < 0x80)     # test for no error
+    dassert(rq, lambda r: not r.isError())     # test for no error
     dassert(rr, lambda r: r.registers == [17]*8)      # test the expected value
-    
+
     arguments = {
         'read_address':    1,
         'read_count':      8,
         'write_address':   1,
         'write_registers': [20]*8,
     }
-    rq = client.readwrite_registers(**arguments, unit=UNIT)
+    rq = client.readwrite_registers(arguments, unit=UNIT)
     rr = client.read_input_registers(1, 8, unit=UNIT)
     dassert(rq, lambda r: r.registers == [20]*8)      # test the expected value
     dassert(rr, lambda r: r.registers == [17]*8)      # test the expected value
     stopAsynchronousTest(client)
 
 
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # extra requests
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # If you are performing a request that is not available in the client
 # mixin, you have to perform the request like this instead::
 #
@@ -139,11 +139,11 @@ def beginAsynchronousTest(client):
 # if isinstance(response, ClearCountersResponse):
 #     ... do something with the response
 #
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # choose the client you want
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # make sure to start an implementation to hit against. For this
 # you can use an existing device, the reference implementation in the tools
 # directory, or start a pymodbus server.

examples/common/changing_framers.py

@@ -14,23 +14,23 @@
 tcp transport with an RTU framer). However, please let us know of any
 success cases that are not documented!
 """
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # import the modbus client and the framers
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 from pymodbus.client.sync import ModbusTcpClient as ModbusClient
 
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # 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
 
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # configure the client logging
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 import logging
 logging.basicConfig()
 log = logging.getLogger()
@@ -48,7 +48,7 @@
     # ----------------------------------------------------------------------- #
     rq = client.write_coil(1, True)
     rr = client.read_coils(1,1)
-    assert(rq.function_code < 0x80)     # 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

@@ -13,16 +13,16 @@
         result = client.read_coils(1,10)
         print result
 """
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # import the various server implementations
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 from pymodbus.client.sync import ModbusTcpClient as ModbusClient
 # from pymodbus.client.sync import ModbusUdpClient as ModbusClient
 # from pymodbus.client.sync import ModbusSerialClient as ModbusClient
 
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 # configure the client logging
-# --------------------------------------------------------------------------- # 
+# --------------------------------------------------------------------------- #
 import logging
 FORMAT = ('%(asctime)-15s %(threadName)-15s '
           '%(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
@@ -34,9 +34,9 @@
 
 
 def run_sync_client():
-    # ------------------------------------------------------------------------# 
+    # ------------------------------------------------------------------------#
     # choose the client you want
-    # ------------------------------------------------------------------------# 
+    # ------------------------------------------------------------------------#
     # make sure to start an implementation to hit against. For this
     # you can use an existing device, the reference implementation in the tools
     # directory, or start a pymodbus server.
@@ -60,7 +60,7 @@ def run_sync_client():
     # Here is an example of using these options::
     #
     #    client = ModbusClient('localhost', retries=3, retry_on_empty=True)
-    # ------------------------------------------------------------------------# 
+    # ------------------------------------------------------------------------#
     client = ModbusClient('localhost', port=5020)
     # from pymodbus.transaction import ModbusRtuFramer
     # client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer)
@@ -69,10 +69,10 @@ def run_sync_client():
     # client = ModbusClient(method='rtu', port='/dev/ptyp0', timeout=1,
     #                       baudrate=9600)
     client.connect()
-    
-    # ------------------------------------------------------------------------# 
+
+    # ------------------------------------------------------------------------#
     # specify slave to query
-    # ------------------------------------------------------------------------# 
+    # ------------------------------------------------------------------------#
     # The slave to query is specified in an optional parameter for each
     # individual request. This can be done by specifying the `unit` parameter
     # which defaults to `0x00`
@@ -97,49 +97,49 @@ 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.function_code < 0x80)     # 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.function_code < 0x80)     # 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.function_code < 0x80)     # 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,
     # the remaining bits in the final data byte will be padded with zeros
     # (toward the high order end of the byte).
-    
+
     resp.extend([False]*3)
     assert(rr.bits == resp)         # test the expected value
-    
+
     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.function_code < 0x80)     # 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.function_code < 0x80)     # 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.function_code < 0x80)     # 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.function_code < 0x80)     # 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.function_code < 0x80)     # test that we are not an error
-    
+    assert(not rq.isError())     # test that we are not an error
+
     arguments = {
         'read_address':    1,
         'read_count':      8,
@@ -149,10 +149,10 @@ 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.function_code < 0x80)     # 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
-    
+
     # ----------------------------------------------------------------------- #
     # close the client
     # ----------------------------------------------------------------------- #