1. Merge branch 'master' into async (#254 #246)

2. Fix/update unit tests

Author: dhoomakethu

.gitignore

@@ -7,7 +7,7 @@ pymodbus.egg-info/
 .vscode
 .idea
 .noseids
-
+*.db
 .idea/
 .tox/
 doc/api/epydoc/html/
@@ -35,3 +35,4 @@ test/__pycache__/
 /doc/sphinx/
 /doc/html/
 /doc/_build/
+.pytest_cache/

CHANGELOG.rst

@@ -4,12 +4,54 @@ Version 2.0.0rc1
 
 * Async client implementation based on Tornado, Twisted and asyncio
 
+Version 1.5.1
+------------------------------------------------------------
+* Fix device information selectors
+* Fixed behaviour of the MEI device information command as a server when an invalid object_id is provided by an external client.
+* Add support for repeated MEI device information Object IDs (client/server)
+* Added support for encoding device information when it requires more than one PDU to pack.
+* Added REPR statements for all syncchronous clients
+* Added `isError` method to exceptions, Any response received can be tested for success before proceeding.
+
+    ```
+    res = client.read_holding_registers(...)
+    if not res.isError():
+        # proceed
+    else:
+        # handle error or raise
+    ```
+* Add examples for MEI read device information request
+
+Version 1.5.0
+------------------------------------------------------------
+* Improve transaction speeds for sync clients (RTU/ASCII), now retry on empty happens only when retry_on_empty kwarg is passed to client during intialization
+
+`client = Client(..., retry_on_empty=True)`
+
+* Fix tcp servers (sync/async) not processing requests with transaction id > 255
+* Introduce new api to check if the received response is an error or not (response.isError())
+* Move timing logic to framers so that irrespective of client, correct timing logics are followed.
+* Move framers from transaction.py to respective modules
+* Fix modbus payload builder and decoder
+* Async servers can now have an option to defer `reactor.run()` when using `Start<Tcp/Serial/Udo>Server(...,defer_reactor_run=True)`
+* Fix UDP client issue while handling MEI messages (ReadDeviceInformationRequest)
+* Add expected response lengths for WriteMultipleCoilRequest and WriteMultipleRegisterRequest
+* Fix _rtu_byte_count_pos for GetCommEventLogResponse
+* Add support for repeated MEI device information Object IDs
+* Fix struct errors while decoding stray response
+* Modbus read retries works only when empty/no message is received
+* Change test runner from nosetest to pytest
+* Fix Misc examples
+>>>>>>> master
+
 Version 1.4.0
 ------------------------------------------------------------
 * Bug fix Modbus TCP client reading incomplete data
 * Check for slave unit id before processing the request for serial clients
 * Bug fix serial servers with Modbus Binary Framer
 * Bug fix header size for ModbusBinaryFramer
+* Bug fix payload decoder with endian Little
+* Payload builder and decoder can now deal with the wordorder as well of 32/64 bit data.
 * Support Database slave contexts (SqlStore and RedisStore)
 * Custom handlers could be passed to Modbus TCP servers
 * Asynchronous Server could now be stopped when running on a seperate thread (StopServer)

Makefile

@@ -39,8 +39,8 @@ check: install
 
 test: install
 	@pip install --quiet --requirement=requirements-tests.txt
-	@py.test
-	@coverage report --fail-under=85 -i
+	@py.test --cov=pymodbus/ --cov-report term-missing
+	@coverage report --fail-under=90
 
 tox: install
 	@pip install --quiet tox && tox
@@ -58,8 +58,8 @@ publish: install
 	$(MAKE) clean
 
 clean:
-	@rm -Rf *.egg .cache .coverage .tox build dist docs/build htmlcov
-	@find -depth -type d -name __pycache__ -exec rm -Rf {} \;
-	@find -type f -name '*.pyc' -delete
+	@rm -Rf *.egg .eggs *.egg-info *.db .cache .coverage .tox build dist docs/build htmlcov doc/_build test/.Python test/pip-selfcheck.json test/lib/ test/include/ test/bin/
+	@find . -depth -type d -name __pycache__ -exec rm -Rf {} \;
+	@find . -type f -name '*.pyc' -delete
 
 .PHONY: default install reset check test tox docs publish clean

README.rst

@@ -78,7 +78,7 @@ For those of you that just want to get started fast, here you go::
     client = ModbusTcpClient('127.0.0.1')
     client.write_coil(1, True)
     result = client.read_coils(1,1)
-    print result.bits[0]
+    print(result.bits[0])
     client.close()
 
 For more advanced examples, check out the examples included in the

doc/source/library/pymodbus.framer.rst

@@ -0,0 +1,47 @@
+pymodbus\.framer package
+========================
+
+Submodules
+----------
+
+pymodbus\.framer\.ascii_framer module
+-------------------------------------
+
+.. automodule:: pymodbus.framer.ascii_framer
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+pymodbus\.framer\.binary_framer module
+--------------------------------------
+
+.. automodule:: pymodbus.framer.binary_framer
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+pymodbus\.framer\.rtu_framer module
+-----------------------------------
+
+.. automodule:: pymodbus.framer.rtu_framer
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+pymodbus\.framer\.socket_framer module
+--------------------------------------
+
+.. automodule:: pymodbus.framer.socket_framer
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: pymodbus.framer
+    :members:
+    :undoc-members:
+    :show-inheritance:
+

doc/source/library/pymodbus.rst

@@ -13,9 +13,11 @@ Subpackages
 
     pymodbus.client
     pymodbus.datastore
+    pymodbus.framer
     pymodbus.internal
     pymodbus.server
 
+
 Submodules
 ----------
 

examples/common/async_twisted_client.py

@@ -9,6 +9,7 @@
 # --------------------------------------------------------------------------- #
 # import needed libraries
 # --------------------------------------------------------------------------- #
+
 from twisted.internet import reactor
 
 from pymodbus.client.async.tcp import AsyncModbusTCPClient
@@ -21,11 +22,20 @@
 
 #from pymodbus.client.async import ModbusUdpClientProtocol
 
+from twisted.internet import reactor, protocol
+from pymodbus.constants import Defaults
+
+# --------------------------------------------------------------------------- #
+# choose the requested modbus protocol
+# --------------------------------------------------------------------------- #
+
 # --------------------------------------------------------------------------- #
 # configure the client logging
 # --------------------------------------------------------------------------- #
 import logging
-logging.basicConfig()
+FORMAT = ('%(asctime)-15s %(threadName)-15s'
+          ' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
+logging.basicConfig(format=FORMAT)
 log = logging.getLogger()
 log.setLevel(logging.DEBUG)
 
@@ -40,7 +50,7 @@ def err(*args, **kwargs):
 
 def dassert(deferred, callback):
     def _assertor(value):
-        assert(value)
+        assert value
     deferred.addCallback(lambda r: _assertor(callback(r)))
     deferred.addErrback(err)
 
@@ -55,9 +65,20 @@ def _assertor(value):
 
 UNIT = 0x01
 
+def processResponse(result):
+    log.debug(result)
+
 
 def exampleRequests(client):
     rr = client.read_coils(1, 1, unit=0x02)
+    rr.addCallback(processResponse)
+    rr = client.read_holding_registers(1, 1, unit=0x02)
+    rr.addCallback(processResponse)
+    rr = client.read_discrete_inputs(1, 1, unit=0x02)
+    rr.addCallback(processResponse)
+    rr = client.read_input_registers(1, 1, unit=0x02)
+    rr.addCallback(processResponse)
+    stopAsynchronousTest(client)
 
 # --------------------------------------------------------------------------- #
 # example requests
@@ -70,31 +91,38 @@ def exampleRequests(client):
 # deferred assert helper(dassert).
 # --------------------------------------------------------------------------- #
 
+def stopAsynchronousTest(client):
+    # ----------------------------------------------------------------------- #
+    # close the client at some time later
+    # ----------------------------------------------------------------------- #
+    reactor.callLater(1, client.transport.loseConnection)
+    reactor.callLater(2, reactor.stop)
+
 
 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(rr, lambda r: r.bits == [True]*8)         # test the expected value
+    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(rr, lambda r: r.bits == [True]*8)         # test the expected value
+    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 = {
@@ -103,10 +131,11 @@ def beginAsynchronousTest(client):
         '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)
 
     # ----------------------------------------------------------------------- #
     # close the client at some time later
@@ -140,11 +169,9 @@ def beginAsynchronousTest(client):
 
 
 if __name__ == "__main__":
-
     protocol, deferred = AsyncModbusTCPClient(schedulers.REACTOR, port=5020)
     # protocol, deferred = AsyncModbusUDPClient(schedulers.REACTOR, port=5020)
                              # callback=beginAsynchronousTest,
                              # errback=err)
     deferred.addCallback(beginAsynchronousTest)
     deferred.addErrback(err)
-

examples/common/asynchronous_processor.py

@@ -26,15 +26,17 @@
 # configure the client logging
 # --------------------------------------------------------------------------- #
 import logging
-logging.basicConfig()
-log = logging.getLogger("pymodbus")
+FORMAT = ('%(asctime)-15s %(threadName)-15s'
+          ' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
+logging.basicConfig(format=FORMAT)
+log = logging.getLogger()
 log.setLevel(logging.DEBUG)
 
 # --------------------------------------------------------------------------- #
 # state a few constants
 # --------------------------------------------------------------------------- #
-SERIAL_PORT = "/tmp/ttyp0"
-# --------------------------------------------------------------------------- #
+
+SERIAL_PORT = "/dev/ptyp0"
 STATUS_REGS = (1, 2)
 STATUS_COILS = (1, 3)
 CLIENT_DELAY = 1
@@ -175,7 +177,7 @@ def write(self, response):
 
 def main():
     log.debug("Initializing the client")
-    framer = ModbusFramer(ClientDecoder())
+    framer = ModbusFramer(ClientDecoder(), client=None)
     reader = LoggingLineReader()
     factory = ExampleFactory(framer, reader)
     SerialModbusClient(factory, SERIAL_PORT, reactor)

examples/common/asynchronous_server.py

@@ -17,13 +17,17 @@
 from pymodbus.device import ModbusDeviceIdentification
 from pymodbus.datastore import ModbusSequentialDataBlock
 from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext
-from pymodbus.transaction import ModbusRtuFramer, ModbusAsciiFramer
+from pymodbus.transaction import (ModbusRtuFramer,
+                                  ModbusAsciiFramer,
+                                  ModbusBinaryFramer)
 
 # --------------------------------------------------------------------------- # 
 # configure the service logging
 # --------------------------------------------------------------------------- # 
 import logging
-logging.basicConfig()
+FORMAT = ('%(asctime)-15s %(threadName)-15s'
+          ' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
+logging.basicConfig(format=FORMAT)
 log = logging.getLogger()
 log.setLevel(logging.DEBUG)
 
@@ -101,18 +105,41 @@ def run_async_server():
     identity.VendorUrl = 'http://github.com/bashwork/pymodbus/'
     identity.ProductName = 'Pymodbus Server'
     identity.ModelName = 'Pymodbus Server'
-    identity.MajorMinorRevision = '1.0'
+    identity.MajorMinorRevision = '1.5'
 
     # ----------------------------------------------------------------------- # 
     # run the server you want
     # ----------------------------------------------------------------------- # 
-    
+
+    # TCP Server
+
     StartTcpServer(context, identity=identity, address=("localhost", 5020))
-    # StartUdpServer(context, identity=identity, address=("localhost", 502))
-    # StartSerialServer(context, identity=identity, 
-    #                   port='/dev/pts/3', framer=ModbusRtuFramer)
-    # StartSerialServer(context, identity=identity, 
-    #                   port='/dev/pts/3', framer=ModbusAsciiFramer)
+
+    # TCP Server with deferred reactor run
+
+    # from twisted.internet import reactor
+    # StartTcpServer(context, identity=identity, address=("localhost", 5020),
+    #                defer_reactor_run=True)
+    # reactor.run()
+
+    # Server with RTU framer
+    # StartTcpServer(context, identity=identity, address=("localhost", 5020),
+    #                framer=ModbusRtuFramer)
+
+    # UDP Server
+    # StartUdpServer(context, identity=identity, address=("127.0.0.1", 5020))
+
+    # RTU Server
+    # StartSerialServer(context, identity=identity,
+    #                   port='/dev/ttyp0', framer=ModbusRtuFramer)
+
+    # ASCII Server
+    # StartSerialServer(context, identity=identity,
+    #                   port='/dev/ttyp0', framer=ModbusAsciiFramer)
+
+    # Binary Server
+    # StartSerialServer(context, identity=identity,
+    #                   port='/dev/ttyp0', framer=ModbusBinaryFramer)
 
 
 if __name__ == "__main__":