pyModbusTCP 0.2.0__tar.gz → 0.2.2__tar.gz

{pyModbusTCP-0.2.0 → pyModbusTCP-0.2.2}/CHANGES

@@ -1,6 +1,18 @@
-
 Revision history for pyModbusTCP
 
+0.2.2 2024-07-31
+
+    - fix ModbusServer: wrong check of discrete inputs length in DataBank (thanks to OTnetproj).
+    - updated compatibility test (python versions): remove 3.7, add 3.12.
+
+0.2.1 2023-11-21
+
+    - fix ModbusServer: wrong check of input registers length in DataBank (thanks to monsieurvor).
+    - improve hostname validation in utils (thanks to MCXIV and schmocker).
+    - experimental add of read_device_identification() (over modbus encapsulated interface) to client and server.
+    - experimental add of write_read_multiple_registers() function (code 0x17) to client and server (thanks to tanj).
+    - updated compatibility test (python versions): remove 3.5/3.6, add 3.11.
+
 0.2.0 2022-06-05
 
     - ModbusClient: parameters are now properties instead of methods (more intuitive).

pyModbusTCP-0.2.0/README.rst → pyModbusTCP-0.2.2/PKG-INFO

@@ -1,3 +1,14 @@
+Metadata-Version: 2.1
+Name: pyModbusTCP
+Version: 0.2.2
+Summary: A simple Modbus/TCP library for Python
+Home-page: https://github.com/sourceperl/pyModbusTCP
+Author: Loic Lefebvre
+Author-email: loic.celine@free.fr
+License: MIT
+Platform: any
+License-File: LICENSE
+
 .. |badge_tests| image:: https://github.com/sourceperl/pyModbusTCP/actions/workflows/tests.yml/badge.svg?branch=master
                 :target: https://github.com/sourceperl/pyModbusTCP/actions/workflows/tests.yml
 
@@ -10,12 +21,12 @@ pyModbusTCP |badge_tests| |badge_docs|
 A simple Modbus/TCP client library for Python.
 pyModbusTCP is pure Python code without any extension or external module dependency.
 
-Since version 0.1.0, a server is also available for test purpose only (don't use in project).
+Since version 0.1.0, a server is also available.
 
 Tests
 -----
 
-The module is currently test on Python 3.5, 3.6, 3.7, 3.8, 3.9 and 3.10.
+The module is currently test on Python 3.8, 3.9, 3.10, 3.11 and 3.12.
 
 For Linux, Mac OS and Windows.
 
@@ -107,22 +118,3 @@ Write value 44 and 55 to registers at modbus address 10 :
         print("write ok")
     else:
         print("write error")
-
-Know issue with older Python version on Windows
------------------------------------------------
-
-On windows OS with older Python version (<3), win_inet_pton module is require. This avoid exception "AttributeError:
-'module' object has no attribute 'inet_pton'".
-
-install win_inet_pton:
-
-.. code-block:: bash
-
-    sudo pip install win_inet_pton
-
-import win_inet_pton at beginning of your code:
-
-.. code-block:: python
-
-    import win_inet_pton
-    from pyModbusTCP.client import ModbusClient

pyModbusTCP-0.2.2/README.rst

@@ -0,0 +1,109 @@
+.. |badge_tests| image:: https://github.com/sourceperl/pyModbusTCP/actions/workflows/tests.yml/badge.svg?branch=master
+                :target: https://github.com/sourceperl/pyModbusTCP/actions/workflows/tests.yml
+
+.. |badge_docs| image:: https://readthedocs.org/projects/pymodbustcp/badge/?version=latest
+               :target: http://pymodbustcp.readthedocs.io/
+
+pyModbusTCP |badge_tests| |badge_docs|
+======================================
+
+A simple Modbus/TCP client library for Python.
+pyModbusTCP is pure Python code without any extension or external module dependency.
+
+Since version 0.1.0, a server is also available.
+
+Tests
+-----
+
+The module is currently test on Python 3.8, 3.9, 3.10, 3.11 and 3.12.
+
+For Linux, Mac OS and Windows.
+
+Documentation
+-------------
+
+Documentation of the last release is available online at https://pymodbustcp.readthedocs.io/.
+
+Setup
+-----
+
+You can install this package from:
+
+PyPI, the easy way:
+
+.. code-block:: bash
+
+    # install the last available release (stable)
+    sudo pip install pyModbusTCP
+
+.. code-block:: bash
+
+    # install a specific version (here release v0.1.10)
+    sudo pip install pyModbusTCP==v0.1.10
+
+From GitHub:
+
+.. code-block:: bash
+
+    # install a specific version (here release v0.1.10) directly from github servers
+    sudo pip install git+https://github.com/sourceperl/pyModbusTCP.git@v0.1.10
+
+Note on the use of versions:
+
+Over time, some things can change. So, it's a good practice that you always use a specific version of a package for
+your project, instead of just relying on the default behavior. Without precision, the installation tools will always
+install the latest version available for a package, this may have some drawbacks. For example, in pyModbusTCP, the TCP
+automatic open mode will be active by default from version 0.2.0. It is not the case with previous versions and it just
+doesn't exist before the 0.0.12. This can lead to some strange behaviour of your application if you are not aware of
+the change. Look at `CHANGES <https://github.com/sourceperl/pyModbusTCP/blob/master/CHANGES>`_ for details on versions
+available.
+
+Usage example
+-------------
+
+See examples/ for full scripts.
+
+include (for all samples)
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    from pyModbusTCP.client import ModbusClient
+
+module init (TCP always open)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    # TCP auto connect on first modbus request
+    c = ModbusClient(host="localhost", port=502, unit_id=1, auto_open=True)
+
+module init (TCP open/close for each request)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    # TCP auto connect on modbus request, close after it
+    c = ModbusClient(host="127.0.0.1", auto_open=True, auto_close=True)
+
+Read 2x 16 bits registers at modbus address 0 :
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    regs = c.read_holding_registers(0, 2)
+
+    if regs:
+        print(regs)
+    else:
+        print("read error")
+
+Write value 44 and 55 to registers at modbus address 10 :
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    if c.write_multiple_registers(10, [44,55]):
+        print("write ok")
+    else:
+        print("write error")

{pyModbusTCP-0.2.0 → pyModbusTCP-0.2.2}/pyModbusTCP/__init__.py

@@ -1,15 +1,10 @@
-# -*- coding: utf-8 -*-
-
 # Python package: Client and Server for ModBus/TCP
-#        Version: 0.2.0
 #        Website: https://github.com/sourceperl/pyModbusTCP
-#           Date: 2022-06-05
 #        License: MIT (http://http://opensource.org/licenses/mit-license.php)
 #    Description: Client/Server ModBus/TCP
 #                 Support functions 3 and 16 (class 0)
 #                 1,2,4,5,6 (Class 1)
-#                 15
-#        Charset: utf-8
+#                 15,23,43
 
 from .constants import VERSION
 

{pyModbusTCP-0.2.0 → pyModbusTCP-0.2.2}/pyModbusTCP/client.py

@@ -1,19 +1,68 @@
 """ pyModbusTCP Client """
 
+from dataclasses import dataclass, field
 from .constants import READ_COILS, READ_DISCRETE_INPUTS, READ_HOLDING_REGISTERS, READ_INPUT_REGISTERS, \
     WRITE_MULTIPLE_COILS, WRITE_MULTIPLE_REGISTERS, WRITE_SINGLE_COIL, WRITE_SINGLE_REGISTER, \
-    EXP_TXT, EXP_DETAILS, EXP_NONE, \
+    WRITE_READ_MULTIPLE_REGISTERS, ENCAPSULATED_INTERFACE_TRANSPORT, MEI_TYPE_READ_DEVICE_ID, \
     MB_ERR_TXT, MB_NO_ERR, MB_SEND_ERR, MB_RECV_ERR, MB_TIMEOUT_ERR, MB_EXCEPT_ERR, MB_CONNECT_ERR, \
-    MB_SOCK_CLOSE_ERR, VERSION
+    EXP_TXT, EXP_DETAILS, EXP_NONE, MB_SOCK_CLOSE_ERR, VERSION
 from .utils import byte_length, set_bit, valid_host
+import random
 import socket
 from socket import AF_UNSPEC, SOCK_STREAM
 import struct
-import random
+from typing import Dict
+
+
+@dataclass
+class DeviceIdentificationResponse:
+    """Modbus TCP client function read_device_identification() response struct.
+    
+    :param conformity_level: this represents supported access and object type
+    :type conformity_level: int
+    :param more_follows: for stream request can be set to 0xff if other objects are available (0x00 in other cases)
+    :type more_follows: int
+    :param next_object_id: the next object id to be asked by following transaction
+    :type next_object_id: int
+    :param objects_by_id: a dictionary with requested object (dict keys are object id as int)
+    :type objects_by_id: dict
+    """
+    conformity_level: int = 0
+    more_follows: int = 0
+    next_object_id: int = 0
+    objects_by_id: Dict[int, bytes] = field(default_factory=lambda: {})
+
+    @property
+    def vendor_name(self):
+        return self.objects_by_id.get(0x00)
+
+    @property
+    def product_code(self):
+        return self.objects_by_id.get(0x01)
+
+    @property
+    def major_minor_revision(self):
+        return self.objects_by_id.get(0x02)
+
+    @property
+    def vendor_url(self):
+        return self.objects_by_id.get(0x03)
+
+    @property
+    def product_name(self):
+        return self.objects_by_id.get(0x04)
+
+    @property
+    def model_name(self):
+        return self.objects_by_id.get(0x05)
+
+    @property
+    def user_application_name(self):
+        return self.objects_by_id.get(0x06)
 
 
-class ModbusClient(object):
-    """Modbus TCP client"""
+class ModbusClient:
+    """Modbus TCP client."""
 
     class _InternalError(Exception):
         pass
@@ -57,7 +106,7 @@ class ModbusClient(object):
         self._debug = None
         self._auto_open = None
         self._auto_close = None
-        self._sock = None  # socket
+        self._sock = socket.socket()
         self._transaction_id = 0  # MBAP transaction ID
         self._version = VERSION  # this package version number
         self._last_error = MB_NO_ERR  # last error code
@@ -232,10 +281,7 @@ class ModbusClient(object):
     @property
     def is_open(self):
         """Get current status of the TCP connection (True = open)."""
-        if self._sock:
-            return self._sock.fileno() > 0
-        else:
-            return False
+        return self._sock.fileno() > 0
 
     def open(self):
         """Connect to modbus server (open TCP connection).
@@ -279,8 +325,7 @@ class ModbusClient(object):
 
     def close(self):
         """Close current TCP connection."""
-        if self._sock:
-            self._sock.close()
+        self._sock.close()
 
     def custom_request(self, pdu):
         """Send a custom modbus request.
@@ -458,6 +503,59 @@ class ModbusClient(object):
             self._req_except_handler(e)
             return None
 
+    def read_device_identification(self, read_code=1, object_id=0):
+        """Modbus function Read Device Identification (0x2B/0x0E).
+
+        :param read_code: read device id code, 1 to 3 for respectively: basic, regular and extended stream access,
+            4 for one specific identification object individual access (default is 1)
+        :type read_code: int
+        :param object_id: object id of the first object to obtain (default is 0)
+        :type object_id: int
+        :returns: a DeviceIdentificationResponse instance with the data or None if the requests fails
+        :rtype: DeviceIdentificationResponse or None
+        """
+        # check params
+        if not 1 <= int(read_code) <= 4:
+            raise ValueError('read_code out of range (valid from 1 to 4)')
+        if not 0 <= int(object_id) <= 0xff:
+            raise ValueError('object_id out of range (valid from 0 to 255)')
+        # make request
+        try:
+            tx_pdu = struct.pack('BBBB', ENCAPSULATED_INTERFACE_TRANSPORT, MEI_TYPE_READ_DEVICE_ID, read_code, object_id)
+            rx_pdu = self._req_pdu(tx_pdu=tx_pdu, rx_min_len=7)
+            # init response object for populate it
+            response = DeviceIdentificationResponse()
+            # extract fields
+            # field "conformity level"
+            response.conformity_level = rx_pdu[3]
+            # field "more follows"
+            response.more_follows = rx_pdu[4]
+            # field "next object id"
+            response.next_object_id = rx_pdu[5]
+            # field "number of objects"
+            nb_of_objs = rx_pdu[6]
+            # decode [[obj_id, obj_len, obj_value],...]
+            pdu_offset = 7
+            for _ in range(nb_of_objs):
+                # parse object PDU bytes
+                try:
+                    obj_id = rx_pdu[pdu_offset]
+                    obj_len = rx_pdu[pdu_offset+1]
+                    obj_value = rx_pdu[pdu_offset+2:pdu_offset+2+obj_len]
+                except IndexError:
+                    raise ModbusClient._NetworkError(MB_RECV_ERR, 'rx byte count mismatch')
+                if obj_len != len(obj_value):
+                    raise ModbusClient._NetworkError(MB_RECV_ERR, 'rx byte count mismatch')
+                # set offset to next object
+                pdu_offset += 2 + obj_len
+                # add result to request list
+                response.objects_by_id[obj_id] = obj_value
+            return response
+        # handle error during request
+        except ModbusClient._InternalError as e:
+            self._req_except_handler(e)
+            return None
+
     def write_single_coil(self, bit_addr, bit_value):
         """Modbus function WRITE_SINGLE_COIL (0x05).
 
@@ -607,6 +705,68 @@ class ModbusClient(object):
             self._req_except_handler(e)
             return False
 
+    def write_read_multiple_registers(self, write_addr, write_values, read_addr, read_nb=1):
+        """Modbus function WRITE_READ_MULTIPLE_REGISTERS (0x17).
+
+        :param write_addr: write registers address (0 to 65535)
+        :type write_addr: int
+        :param write_values: registers values to write
+        :type write_values: list
+        :param read_addr: read register address (0 to 65535)
+        :type read_addr: int
+        :param read_nb: number of registers to read (1 to 125)
+        :type read_nb: int
+        :returns: registers list or None if fail
+        :rtype: list of int or None
+        """
+        # check params
+        check_l = [(not 0 <= int(write_addr) <= 0xffff, 'write_addr out of range (valid from 0 to 65535)'),
+                   (not 1 <= len(write_values) <= 121, 'number of registers out of range (valid from 1 to 121)'),
+                   (int(write_addr) + len(write_values) > 0x10000, 'write after end of modbus address space'),
+                   (not 0 <= int(read_addr) <= 0xffff, 'read_addr out of range (valid from 0 to 65535)'),
+                   (not 1 <= int(read_nb) <= 125, 'read_nb out of range (valid from 1 to 125)'),
+                   (int(read_addr) + int(read_nb) > 0x10000, 'read after end of modbus address space'), ]
+        for err, msg in check_l:
+            if err:
+                raise ValueError(msg)
+        # make request
+        try:
+            # init PDU registers part
+            pdu_regs_part = b''
+            # populate it with register values
+            for reg in write_values:
+                # check current register value
+                if not 0 <= int(reg) <= 0xffff:
+                    raise ValueError('write_values list contains out of range values')
+                # pack register for build frame
+                pdu_regs_part += struct.pack('>H', reg)
+            bytes_nb = len(pdu_regs_part)
+            # concatenate PDU parts
+            tx_pdu = struct.pack('>BHHHHB', WRITE_READ_MULTIPLE_REGISTERS, read_addr, read_nb,
+                                 write_addr, len(write_values), bytes_nb)
+            tx_pdu += pdu_regs_part
+            # make a request
+            rx_pdu = self._req_pdu(tx_pdu=tx_pdu, rx_min_len=4)
+            # response decode
+            # extract field "byte count"
+            byte_count = rx_pdu[1]
+            # frame with regs value
+            f_regs = rx_pdu[2:]
+            # check rx_byte_count: buffer size must be consistent and have at least the requested number of registers
+            if byte_count < 2 * read_nb or byte_count != len(f_regs):
+                raise ModbusClient._NetworkError(MB_RECV_ERR, 'rx byte count mismatch')
+            # allocate a reg_nb size list
+            registers = [0] * read_nb
+            # fill registers list with register items
+            for i in range(read_nb):
+                registers[i] = struct.unpack('>H', f_regs[i * 2:i * 2 + 2])[0]
+            # return registers list
+            return registers
+        # handle error during request
+        except ModbusClient._InternalError as e:
+            self._req_except_handler(e)
+            return
+
     def _send(self, frame):
         """Send frame over current socket.
 

{pyModbusTCP-0.2.0 → pyModbusTCP-0.2.2}/pyModbusTCP/constants.py

@@ -1,7 +1,7 @@
 """ pyModbusTCP package constants definition """
 
 # Package version
-VERSION = '0.2.0'
+VERSION = '0.2.2'
 # Modbus/TCP
 MODBUS_PORT = 502
 # Modbus function code
@@ -13,9 +13,13 @@ WRITE_SINGLE_COIL = 0x05
 WRITE_SINGLE_REGISTER = 0x06
 WRITE_MULTIPLE_COILS = 0x0F
 WRITE_MULTIPLE_REGISTERS = 0x10
-MODBUS_ENCAPSULATED_INTERFACE = 0x2B
+WRITE_READ_MULTIPLE_REGISTERS = 0x17
+ENCAPSULATED_INTERFACE_TRANSPORT = 0x2B
 SUPPORTED_FUNCTION_CODES = (READ_COILS, READ_DISCRETE_INPUTS, READ_HOLDING_REGISTERS, READ_INPUT_REGISTERS,
-                            WRITE_SINGLE_COIL, WRITE_SINGLE_REGISTER, WRITE_MULTIPLE_COILS, WRITE_MULTIPLE_REGISTERS)
+                            WRITE_SINGLE_COIL, WRITE_SINGLE_REGISTER, WRITE_MULTIPLE_COILS, WRITE_MULTIPLE_REGISTERS,
+                            WRITE_READ_MULTIPLE_REGISTERS, ENCAPSULATED_INTERFACE_TRANSPORT)
+# MEI type
+MEI_TYPE_READ_DEVICE_ID = 0x0E
 # Modbus except code
 EXP_NONE = 0x00
 EXP_ILLEGAL_FUNCTION = 0x01
@@ -85,3 +89,5 @@ MB_ERR_TXT = {
     MB_CRC_ERR: 'bad CRC on receive frame',
     MB_SOCK_CLOSE_ERR: 'socket is closed'
 }
+# Misc
+MAX_PDU_SIZE = 253

{pyModbusTCP-0.2.0 → pyModbusTCP-0.2.2}/pyModbusTCP/server.py

@@ -2,7 +2,8 @@
 
 from .constants import READ_COILS, READ_DISCRETE_INPUTS, READ_HOLDING_REGISTERS, READ_INPUT_REGISTERS, \
     WRITE_MULTIPLE_COILS, WRITE_MULTIPLE_REGISTERS, WRITE_SINGLE_COIL, WRITE_SINGLE_REGISTER, \
-    EXP_NONE, EXP_ILLEGAL_FUNCTION, EXP_DATA_ADDRESS, EXP_DATA_VALUE
+    EXP_NONE, EXP_ILLEGAL_FUNCTION, EXP_DATA_ADDRESS, EXP_DATA_VALUE, WRITE_READ_MULTIPLE_REGISTERS, \
+    ENCAPSULATED_INTERFACE_TRANSPORT, MEI_TYPE_READ_DEVICE_ID, MAX_PDU_SIZE
 from .utils import test_bit, set_bit
 import logging
 import socket
@@ -170,7 +171,7 @@ class DataBank:
         """
         # secure extract of data from list used by server thread
         with self._d_inputs_lock:
-            if (address >= 0) and (address + number <= len(self._coils)):
+            if (address >= 0) and (address + number <= len(self._d_inputs)):
                 return self._d_inputs[address: number + address]
             else:
                 return None
@@ -190,7 +191,7 @@ class DataBank:
         bit_list = [bool(b) for b in bit_list]
         # ensure atomic update of internal data
         with self._d_inputs_lock:
-            if (address >= 0) and (address + len(bit_list) <= len(self._coils)):
+            if (address >= 0) and (address + len(bit_list) <= len(self._d_inputs)):
                 for offset, b_value in enumerate(bit_list):
                     self._d_inputs[address + offset] = b_value
             else:
@@ -264,7 +265,7 @@ class DataBank:
         """
         # secure extract of data from list used by server thread
         with self._i_regs_lock:
-            if (address >= 0) and (address + number <= len(self._h_regs)):
+            if (address >= 0) and (address + number <= len(self._i_regs)):
                 return self._i_regs[address: number + address]
             else:
                 return None
@@ -284,7 +285,7 @@ class DataBank:
         word_list = [int(w) & 0xffff for w in word_list]
         # ensure atomic update of internal data
         with self._i_regs_lock:
-            if (address >= 0) and (address + len(word_list) <= len(self._h_regs)):
+            if (address >= 0) and (address + len(word_list) <= len(self._i_regs)):
                 for offset, c_value in enumerate(word_list):
                     c_address = address + offset
                     if self._i_regs[c_address] != c_value:
@@ -351,7 +352,7 @@ class DataHandler:
         """
         # check data_bank type
         if data_bank and not isinstance(data_bank, DataBank):
-            raise ValueError('data_bank arg is invalid')
+            raise TypeError('data_bank arg is invalid')
         # public
         self.data_bank = data_bank or DataBank()
 
@@ -473,6 +474,158 @@ class DataHandler:
             return DataHandler.Return(exp_code=EXP_DATA_ADDRESS)
 
 
+class DeviceIdentification:
+    """ Container class for device identification objects (MEI type 0x0E) return by function 0x2B. """
+
+    def __init__(self, vendor_name=b'', product_code=b'', major_minor_revision=b'', vendor_url=b'',
+                 product_name=b'', model_name=b'', user_application_name=b'', objects_id=None):
+        """
+        Constructor
+
+        :param vendor_name: VendorName mandatory object
+        :type vendor_name: bytes
+        :param product_code: ProductCode mandatory object
+        :type product_code: bytes
+        :param major_minor_revision: MajorMinorRevision mandatory object
+        :type major_minor_revision: bytes
+        :param vendor_url: VendorUrl regular object
+        :type vendor_url: bytes
+        :param product_name: ProductName regular object
+        :type product_name: bytes
+        :param model_name: ModelName regular object
+        :type model_name: bytes
+        :param user_application_name: UserApplicationName regular object
+        :type user_application_name: bytes
+        :param objects_id: Objects values by id as dict example: {42:b'value'} (optional)
+        :type objects_id: dict
+        """
+        # private
+        self._objs_d = {}
+        self._objs_lock = Lock()
+        # default values
+        self.vendor_name = vendor_name
+        self.product_code = product_code
+        self.major_minor_revision = major_minor_revision
+        self.vendor_url = vendor_url
+        self.product_name = product_name
+        self.model_name = model_name
+        self.user_application_name = user_application_name
+        # process objects_id dict (populate no name objects)
+        if isinstance(objects_id, dict):
+            for key, value in objects_id.items():
+                self[key] = value
+
+    def __getitem__(self, key):
+        if not isinstance(key, int):
+            raise TypeError('key must be an int')
+        with self._objs_lock:
+            return self._objs_d[key]
+
+    def __setitem__(self, key, value):
+        if not isinstance(key, int):
+            raise TypeError('key must be an int')
+        if 0xff >= key >= 0x00:
+            if not isinstance(value, bytes):
+                raise TypeError('this object is of type bytes only')
+            with self._objs_lock:
+                self._objs_d[key] = value
+        else:
+            raise ValueError('key not in valid range (0 to 255)')
+
+    def __repr__(self):
+        named_params = ''
+        # add named parameters
+        for prop_name in ('vendor_name', 'product_code', 'major_minor_revision', 'vendor_url',
+                          'product_name', 'model_name', 'user_application_name'):
+            prop_value = getattr(self, prop_name)
+            if prop_value:
+                if named_params:
+                    named_params += ', '
+                named_params += '%s=%r' % (prop_name, getattr(self, prop_name))
+        # add parameters without shortcut name
+        objs_id_d_str = ''
+        for _id in range(0x07, 0x100):
+            try:
+                obj_id_item = '%r: %r' % (_id, self[_id])
+                if objs_id_d_str:
+                    objs_id_d_str += ', '
+                objs_id_d_str += obj_id_item
+            except KeyError:
+                pass
+        # format str: classname(params_name=value, ..., objects_id={42: 'value'})
+        class_args = named_params
+        if objs_id_d_str:
+            if class_args:
+                class_args += ', '
+            class_args += 'objects_id={%s}' % objs_id_d_str
+        return '%s(%s)' % (self.__class__.__name__, class_args)
+
+    @property
+    def vendor_name(self):
+        return self[0]
+
+    @vendor_name.setter
+    def vendor_name(self, value):
+        self[0] = value
+
+    @property
+    def product_code(self):
+        return self[1]
+
+    @product_code.setter
+    def product_code(self, value):
+        self[1] = value
+
+    @property
+    def major_minor_revision(self):
+        return self[2]
+
+    @major_minor_revision.setter
+    def major_minor_revision(self, value):
+        self[2] = value
+
+    @property
+    def vendor_url(self):
+        return self[3]
+
+    @vendor_url.setter
+    def vendor_url(self, value):
+        self[3] = value
+
+    @property
+    def product_name(self):
+        return self[4]
+
+    @product_name.setter
+    def product_name(self, value):
+        self[4] = value
+
+    @property
+    def model_name(self):
+        return self[5]
+
+    @model_name.setter
+    def model_name(self, value):
+        self[5] = value
+
+    @property
+    def user_application_name(self):
+        return self[6]
+
+    @user_application_name.setter
+    def user_application_name(self, value):
+        self[6] = value
+
+    def items(self, start=0x00, end=0xff):
+        items_l = []
+        for obj_id in range(start, end + 1):
+            try:
+                items_l.append((obj_id, self[obj_id]))
+            except KeyError:
+                pass
+        return items_l
+
+
 class ModbusServer:
     """ Modbus TCP server """
 
@@ -695,7 +848,7 @@ class ModbusServer:
                 self.request.close()
 
     def __init__(self, host='localhost', port=502, no_block=False, ipv6=False,
-                 data_bank=None, data_hdl=None, ext_engine=None):
+                 data_bank=None, data_hdl=None, ext_engine=None, device_id=None):
         """Constructor
 
         Modbus server constructor.
@@ -714,31 +867,36 @@ class ModbusServer:
         :type data_hdl: DataHandler
         :param ext_engine: an external engine reference (ref to ext_engine(session_data)) (optional)
         :type ext_engine: callable
+        :param device_id: instance of DeviceIdentification class for read device identification request (optional)
+        :type device_id: DeviceIdentification
         """
+        # check data_bank
+        if data_bank and not isinstance(data_bank, DataBank):
+            raise TypeError('data_bank is not a DataBank instance')
+        # check data_hdl
+        if data_hdl and not isinstance(data_hdl, DataHandler):
+            raise TypeError('data_hdl is not a DataHandler instance')
+        # data_hdl and data_bank can't be set at same time
+        if data_hdl and data_bank:
+            raise ValueError('when data_hdl is set, you must define data_bank in it')
+        # check ext_engine
+        if ext_engine and not callable(ext_engine):
+            raise TypeError('ext_engine must be callable')
+        # check device_id
+        if device_id and not isinstance(device_id, DeviceIdentification):
+            raise TypeError('device_id is not a DeviceIdentification instance')
         # public
         self.host = host
         self.port = port
         self.no_block = no_block
         self.ipv6 = ipv6
         self.ext_engine = ext_engine
-        self.data_hdl = None
-        self.data_bank = None
-        # if external engine is defined, ignore data_hdl and data_bank
-        if ext_engine:
-            if not callable(self.ext_engine):
-                raise ValueError('ext_engine must be callable')
-        else:
-            # default data handler is ModbusServerDataHandler or a child of it
-            if data_hdl is None:
-                self.data_hdl = DataHandler(data_bank=data_bank)
-            elif isinstance(data_hdl, DataHandler):
-                self.data_hdl = data_hdl
-                if data_bank:
-                    raise ValueError('when data_hdl is set, you must define data_bank in it')
-            else:
-                raise ValueError('data_hdl is not a ModbusServerDataHandler (or child of it) instance')
-            # data bank shortcut
-            self.data_bank = self.data_hdl.data_bank
+        # First, internal data_bank will be linked to an external data handler if defined.
+        # If not, an external or internal DataBank will be used instead.
+        # "virtual mode" will be set for save memory if an external engine is in use.
+        self.data_bank = data_hdl.data_bank if data_hdl else data_bank or DataBank(virtual_mode=bool(ext_engine))
+        self.data_hdl = data_hdl or DataHandler(data_bank=self.data_bank)
+        self.device_id = device_id
         # private
         self._evt_running = Event()
         self._service = None
@@ -751,7 +909,9 @@ class ModbusServer:
                           WRITE_SINGLE_COIL: self._write_single_coil,
                           WRITE_SINGLE_REGISTER: self._write_single_register,
                           WRITE_MULTIPLE_COILS: self._write_multiple_coils,
-                          WRITE_MULTIPLE_REGISTERS: self._write_multiple_registers}
+                          WRITE_MULTIPLE_REGISTERS: self._write_multiple_registers,
+                          WRITE_READ_MULTIPLE_REGISTERS: self._write_read_multiple_registers,
+                          ENCAPSULATED_INTERFACE_TRANSPORT: self._encapsulated_interface_transport}
 
     def __repr__(self):
         r_str = 'ModbusServer(host=\'%s\', port=%d, no_block=%s, ipv6=%s, data_bank=%s, data_hdl=%s, ext_engine=%s)'
@@ -782,10 +942,10 @@ class ModbusServer:
             func = self._func_map[session_data.request.pdu.func_code]
             # check function found is callable
             if not callable(func):
-                raise ValueError
+                raise TypeError
             # call ad-hoc func
             func(session_data)
-        except (ValueError, KeyError):
+        except (TypeError, KeyError):
             session_data.response.pdu.build_except(session_data.request.pdu.func_code, EXP_ILLEGAL_FUNCTION)
 
     def _read_bits(self, session_data):
@@ -964,6 +1124,124 @@ class ModbusServer:
         else:
             send_pdu.build_except(recv_pdu.func_code, EXP_DATA_VALUE)
 
+    def _write_read_multiple_registers(self, session_data):
+        """
+        Function Write Read Multiple Registers (0x17).
+
+        :param session_data: server engine data
+        :type session_data: ModbusServer.SessionData
+        """
+        # pdu alias
+        recv_pdu = session_data.request.pdu
+        send_pdu = session_data.response.pdu
+        # decode pdu
+        (read_start_addr,
+         read_quantity_regs,
+         write_start_addr,
+         write_quantity_regs,
+         byte_count) = recv_pdu.unpack('>HHHHB', from_byte=1, to_byte=10)
+        # ok flags: some tests on pdu fields
+        write_qty_regs_ok = 0x0001 <= write_quantity_regs <= 0x007B
+        write_b_count_ok = byte_count == write_quantity_regs * 2
+        write_pdu_len_ok = len(recv_pdu.raw[10:]) >= byte_count
+        read_qty_regs_ok = 0x0001 <= read_quantity_regs <= 0x007B
+        # test ok flags
+        if write_qty_regs_ok and write_b_count_ok and write_pdu_len_ok and read_qty_regs_ok:
+            # allocate words list
+            regs_l = [0] * write_quantity_regs
+            # populate words list with words from rx frame
+            for i, _ in enumerate(regs_l):
+                offset = i * 2 + 10
+                regs_l[i] = recv_pdu.unpack('>H', from_byte=offset, to_byte=offset + 2)[0]
+            # data handler update request
+            ret_hdl = self.data_hdl.write_h_regs(write_start_addr, regs_l, session_data.srv_info)
+            # format regular or except response
+            if ret_hdl.ok:
+                ret_hdl = self.data_hdl.read_h_regs(read_start_addr, read_quantity_regs, session_data.srv_info)
+                if ret_hdl.ok:
+                    # build pdu
+                    send_pdu.add_pack('BB', recv_pdu.func_code, read_quantity_regs * 2)
+                    # add_pack requested words
+                    send_pdu.add_pack('>%dH' % len(ret_hdl.data), *ret_hdl.data)
+                else:
+                    send_pdu.build_except(recv_pdu.func_code, ret_hdl.exp_code)
+            else:
+                send_pdu.build_except(recv_pdu.func_code, ret_hdl.exp_code)
+        else:
+            send_pdu.build_except(recv_pdu.func_code, EXP_DATA_VALUE)
+
+    def _encapsulated_interface_transport(self, session_data):
+        """
+        Modbus Encapsulated Interface transport (MEI) endpoint (0x2B).
+
+        :param session_data: server engine data
+        :type session_data: ModbusServer.SessionData
+        """
+        # pdu alias
+        recv_pdu = session_data.request.pdu
+        send_pdu = session_data.response.pdu
+        # decode pdu
+        (mei_type,) = recv_pdu.unpack('B', from_byte=1, to_byte=2)
+        # MEI type: read device identification
+        if mei_type == MEI_TYPE_READ_DEVICE_ID:
+            # check device_id property is set (default is None)
+            if not self.device_id:
+                # return except 2 if unset
+                send_pdu.build_except(recv_pdu.func_code, EXP_DATA_ADDRESS)
+                return
+            # list of requested objects
+            req_objects_l = list()
+            (device_id_code, object_id) = recv_pdu.unpack('BB', from_byte=2, to_byte=4)
+            # get basic device id (object id from 0x00 to 0x02)
+            if device_id_code == 1:
+                start_id = object_id
+                req_objects_l.extend(self.device_id.items(start=start_id, end=0x2))
+            # get regular device id (object id 0x03 to 0x7f)
+            elif device_id_code == 2:
+                start_id = max(object_id, 0x03)
+                req_objects_l.extend(self.device_id.items(start=start_id, end=0x7f))
+            # get extended device id (object id 0x80 to 0xff)
+            elif device_id_code == 3:
+                start_id = max(object_id, 0x80)
+                req_objects_l.extend(self.device_id.items(start=start_id, end=0xff))
+            # get specific id object
+            elif device_id_code == 4:
+                start_id = object_id
+                req_objects_l.extend(self.device_id.items(start=start_id, end=start_id))
+            else:
+                # return except 3 for unknown device id code
+                send_pdu.build_except(recv_pdu.func_code, EXP_DATA_VALUE)
+                return
+            # init variables for response PDU build
+            conformity_level = 0x83
+            more_follow = 0
+            next_obj_id = 0
+            number_of_objs = 0
+            fmt_pdu_head = 'BBBBBBB'
+            # format objects data part = [[obj id, obj len, obj val], ...]
+            obj_data_part = b''
+            for req_obj_id, req_obj_value in req_objects_l:
+                fmt_obj_blk = 'BB%ss' % len(req_obj_value)
+                # skip if the next add to data part will exceed max PDU size of modbus frame
+                if struct.calcsize(fmt_pdu_head) + len(obj_data_part) + struct.calcsize(fmt_obj_blk) > MAX_PDU_SIZE:
+                    # turn on "more follow" field and set "next object id" field with next object id to ask
+                    more_follow = 0xff
+                    next_obj_id = req_obj_id
+                    break
+                # ensure bytes type for object value
+                if isinstance(req_obj_value, str):
+                    req_obj_value = req_obj_value.encode()
+                # add current object to data part
+                obj_data_part += struct.pack(fmt_obj_blk, req_obj_id, len(req_obj_value), req_obj_value)
+                number_of_objs += 1
+            # full PDU response = [PDU header] + [objects data part]
+            send_pdu.add_pack(fmt_pdu_head, recv_pdu.func_code, mei_type, device_id_code,
+                              conformity_level, more_follow, next_obj_id, number_of_objs)
+            send_pdu.raw += obj_data_part
+        else:
+            # return except 2 for an unknown MEI type
+            send_pdu.build_except(recv_pdu.func_code, EXP_DATA_ADDRESS)
+
     def start(self):
         """Start the server.
 

{pyModbusTCP-0.2.0 → pyModbusTCP-0.2.2}/pyModbusTCP/utils.py

@@ -313,7 +313,11 @@ def valid_host(host_str):
     except socket.error:
         pass
     # valid hostname ?
-    if re.match(r'^[a-z][a-z0-9.\-]+$', host_str):
-        return True
-    # on invalid host
-    return False
+    if len(host_str) > 255:
+        return False
+    # strip final dot, if present
+    if host_str[-1] == '.':
+        host_str = host_str[:-1]
+    # validate each part of the hostname (part_1.part_2.part_3)
+    re_part_ok = re.compile('(?!-)[a-z0-9-_]{1,63}(?<!-)$', re.IGNORECASE)
+    return all(re_part_ok.match(part) for part in host_str.split('.'))

pyModbusTCP-0.2.2/pyModbusTCP.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.1
+Name: pyModbusTCP
+Version: 0.2.2
+Summary: A simple Modbus/TCP library for Python
+Home-page: https://github.com/sourceperl/pyModbusTCP
+Author: Loic Lefebvre
+Author-email: loic.celine@free.fr
+License: MIT
+Platform: any
+License-File: LICENSE
+
+.. |badge_tests| image:: https://github.com/sourceperl/pyModbusTCP/actions/workflows/tests.yml/badge.svg?branch=master
+                :target: https://github.com/sourceperl/pyModbusTCP/actions/workflows/tests.yml
+
+.. |badge_docs| image:: https://readthedocs.org/projects/pymodbustcp/badge/?version=latest
+               :target: http://pymodbustcp.readthedocs.io/
+
+pyModbusTCP |badge_tests| |badge_docs|
+======================================
+
+A simple Modbus/TCP client library for Python.
+pyModbusTCP is pure Python code without any extension or external module dependency.
+
+Since version 0.1.0, a server is also available.
+
+Tests
+-----
+
+The module is currently test on Python 3.8, 3.9, 3.10, 3.11 and 3.12.
+
+For Linux, Mac OS and Windows.
+
+Documentation
+-------------
+
+Documentation of the last release is available online at https://pymodbustcp.readthedocs.io/.
+
+Setup
+-----
+
+You can install this package from:
+
+PyPI, the easy way:
+
+.. code-block:: bash
+
+    # install the last available release (stable)
+    sudo pip install pyModbusTCP
+
+.. code-block:: bash
+
+    # install a specific version (here release v0.1.10)
+    sudo pip install pyModbusTCP==v0.1.10
+
+From GitHub:
+
+.. code-block:: bash
+
+    # install a specific version (here release v0.1.10) directly from github servers
+    sudo pip install git+https://github.com/sourceperl/pyModbusTCP.git@v0.1.10
+
+Note on the use of versions:
+
+Over time, some things can change. So, it's a good practice that you always use a specific version of a package for
+your project, instead of just relying on the default behavior. Without precision, the installation tools will always
+install the latest version available for a package, this may have some drawbacks. For example, in pyModbusTCP, the TCP
+automatic open mode will be active by default from version 0.2.0. It is not the case with previous versions and it just
+doesn't exist before the 0.0.12. This can lead to some strange behaviour of your application if you are not aware of
+the change. Look at `CHANGES <https://github.com/sourceperl/pyModbusTCP/blob/master/CHANGES>`_ for details on versions
+available.
+
+Usage example
+-------------
+
+See examples/ for full scripts.
+
+include (for all samples)
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    from pyModbusTCP.client import ModbusClient
+
+module init (TCP always open)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    # TCP auto connect on first modbus request
+    c = ModbusClient(host="localhost", port=502, unit_id=1, auto_open=True)
+
+module init (TCP open/close for each request)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    # TCP auto connect on modbus request, close after it
+    c = ModbusClient(host="127.0.0.1", auto_open=True, auto_close=True)
+
+Read 2x 16 bits registers at modbus address 0 :
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    regs = c.read_holding_registers(0, 2)
+
+    if regs:
+        print(regs)
+    else:
+        print("read error")
+
+Write value 44 and 55 to registers at modbus address 10 :
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    if c.write_multiple_registers(10, [44,55]):
+        print("write ok")
+    else:
+        print("write error")

pyModbusTCP-0.2.0/PKG-INFO

@@ -1,138 +0,0 @@
-Metadata-Version: 1.0
-Name: pyModbusTCP
-Version: 0.2.0
-Summary: A simple Modbus/TCP library for Python
-Home-page: https://github.com/sourceperl/pyModbusTCP
-Author: Loic Lefebvre
-Author-email: loic.celine@free.fr
-License: MIT
-Description: .. |badge_tests| image:: https://github.com/sourceperl/pyModbusTCP/actions/workflows/tests.yml/badge.svg?branch=master
-                        :target: https://github.com/sourceperl/pyModbusTCP/actions/workflows/tests.yml
-        
-        .. |badge_docs| image:: https://readthedocs.org/projects/pymodbustcp/badge/?version=latest
-                       :target: http://pymodbustcp.readthedocs.io/
-        
-        pyModbusTCP |badge_tests| |badge_docs|
-        ======================================
-        
-        A simple Modbus/TCP client library for Python.
-        pyModbusTCP is pure Python code without any extension or external module dependency.
-        
-        Since version 0.1.0, a server is also available for test purpose only (don't use in project).
-        
-        Tests
-        -----
-        
-        The module is currently test on Python 3.5, 3.6, 3.7, 3.8, 3.9 and 3.10.
-        
-        For Linux, Mac OS and Windows.
-        
-        Documentation
-        -------------
-        
-        Documentation of the last release is available online at https://pymodbustcp.readthedocs.io/.
-        
-        Setup
-        -----
-        
-        You can install this package from:
-        
-        PyPI, the easy way:
-        
-        .. code-block:: bash
-        
-            # install the last available release (stable)
-            sudo pip install pyModbusTCP
-        
-        .. code-block:: bash
-        
-            # install a specific version (here release v0.1.10)
-            sudo pip install pyModbusTCP==v0.1.10
-        
-        From GitHub:
-        
-        .. code-block:: bash
-        
-            # install a specific version (here release v0.1.10) directly from github servers
-            sudo pip install git+https://github.com/sourceperl/pyModbusTCP.git@v0.1.10
-        
-        Note on the use of versions:
-        
-        Over time, some things can change. So, it's a good practice that you always use a specific version of a package for
-        your project, instead of just relying on the default behavior. Without precision, the installation tools will always
-        install the latest version available for a package, this may have some drawbacks. For example, in pyModbusTCP, the TCP
-        automatic open mode will be active by default from version 0.2.0. It is not the case with previous versions and it just
-        doesn't exist before the 0.0.12. This can lead to some strange behaviour of your application if you are not aware of
-        the change. Look at `CHANGES <https://github.com/sourceperl/pyModbusTCP/blob/master/CHANGES>`_ for details on versions
-        available.
-        
-        Usage example
-        -------------
-        
-        See examples/ for full scripts.
-        
-        include (for all samples)
-        ~~~~~~~~~~~~~~~~~~~~~~~~~
-        
-        .. code-block:: python
-        
-            from pyModbusTCP.client import ModbusClient
-        
-        module init (TCP always open)
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        
-        .. code-block:: python
-        
-            # TCP auto connect on first modbus request
-            c = ModbusClient(host="localhost", port=502, unit_id=1, auto_open=True)
-        
-        module init (TCP open/close for each request)
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        
-        .. code-block:: python
-        
-            # TCP auto connect on modbus request, close after it
-            c = ModbusClient(host="127.0.0.1", auto_open=True, auto_close=True)
-        
-        Read 2x 16 bits registers at modbus address 0 :
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        
-        .. code-block:: python
-        
-            regs = c.read_holding_registers(0, 2)
-        
-            if regs:
-                print(regs)
-            else:
-                print("read error")
-        
-        Write value 44 and 55 to registers at modbus address 10 :
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        
-        .. code-block:: python
-        
-            if c.write_multiple_registers(10, [44,55]):
-                print("write ok")
-            else:
-                print("write error")
-        
-        Know issue with older Python version on Windows
-        -----------------------------------------------
-        
-        On windows OS with older Python version (<3), win_inet_pton module is require. This avoid exception "AttributeError:
-        'module' object has no attribute 'inet_pton'".
-        
-        install win_inet_pton:
-        
-        .. code-block:: bash
-        
-            sudo pip install win_inet_pton
-        
-        import win_inet_pton at beginning of your code:
-        
-        .. code-block:: python
-        
-            import win_inet_pton
-            from pyModbusTCP.client import ModbusClient
-        
-Platform: any

pyModbusTCP-0.2.0/pyModbusTCP.egg-info/PKG-INFO

@@ -1,138 +0,0 @@
-Metadata-Version: 1.0
-Name: pyModbusTCP
-Version: 0.2.0
-Summary: A simple Modbus/TCP library for Python
-Home-page: https://github.com/sourceperl/pyModbusTCP
-Author: Loic Lefebvre
-Author-email: loic.celine@free.fr
-License: MIT
-Description: .. |badge_tests| image:: https://github.com/sourceperl/pyModbusTCP/actions/workflows/tests.yml/badge.svg?branch=master
-                        :target: https://github.com/sourceperl/pyModbusTCP/actions/workflows/tests.yml
-        
-        .. |badge_docs| image:: https://readthedocs.org/projects/pymodbustcp/badge/?version=latest
-                       :target: http://pymodbustcp.readthedocs.io/
-        
-        pyModbusTCP |badge_tests| |badge_docs|
-        ======================================
-        
-        A simple Modbus/TCP client library for Python.
-        pyModbusTCP is pure Python code without any extension or external module dependency.
-        
-        Since version 0.1.0, a server is also available for test purpose only (don't use in project).
-        
-        Tests
-        -----
-        
-        The module is currently test on Python 3.5, 3.6, 3.7, 3.8, 3.9 and 3.10.
-        
-        For Linux, Mac OS and Windows.
-        
-        Documentation
-        -------------
-        
-        Documentation of the last release is available online at https://pymodbustcp.readthedocs.io/.
-        
-        Setup
-        -----
-        
-        You can install this package from:
-        
-        PyPI, the easy way:
-        
-        .. code-block:: bash
-        
-            # install the last available release (stable)
-            sudo pip install pyModbusTCP
-        
-        .. code-block:: bash
-        
-            # install a specific version (here release v0.1.10)
-            sudo pip install pyModbusTCP==v0.1.10
-        
-        From GitHub:
-        
-        .. code-block:: bash
-        
-            # install a specific version (here release v0.1.10) directly from github servers
-            sudo pip install git+https://github.com/sourceperl/pyModbusTCP.git@v0.1.10
-        
-        Note on the use of versions:
-        
-        Over time, some things can change. So, it's a good practice that you always use a specific version of a package for
-        your project, instead of just relying on the default behavior. Without precision, the installation tools will always
-        install the latest version available for a package, this may have some drawbacks. For example, in pyModbusTCP, the TCP
-        automatic open mode will be active by default from version 0.2.0. It is not the case with previous versions and it just
-        doesn't exist before the 0.0.12. This can lead to some strange behaviour of your application if you are not aware of
-        the change. Look at `CHANGES <https://github.com/sourceperl/pyModbusTCP/blob/master/CHANGES>`_ for details on versions
-        available.
-        
-        Usage example
-        -------------
-        
-        See examples/ for full scripts.
-        
-        include (for all samples)
-        ~~~~~~~~~~~~~~~~~~~~~~~~~
-        
-        .. code-block:: python
-        
-            from pyModbusTCP.client import ModbusClient
-        
-        module init (TCP always open)
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        
-        .. code-block:: python
-        
-            # TCP auto connect on first modbus request
-            c = ModbusClient(host="localhost", port=502, unit_id=1, auto_open=True)
-        
-        module init (TCP open/close for each request)
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        
-        .. code-block:: python
-        
-            # TCP auto connect on modbus request, close after it
-            c = ModbusClient(host="127.0.0.1", auto_open=True, auto_close=True)
-        
-        Read 2x 16 bits registers at modbus address 0 :
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        
-        .. code-block:: python
-        
-            regs = c.read_holding_registers(0, 2)
-        
-            if regs:
-                print(regs)
-            else:
-                print("read error")
-        
-        Write value 44 and 55 to registers at modbus address 10 :
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        
-        .. code-block:: python
-        
-            if c.write_multiple_registers(10, [44,55]):
-                print("write ok")
-            else:
-                print("write error")
-        
-        Know issue with older Python version on Windows
-        -----------------------------------------------
-        
-        On windows OS with older Python version (<3), win_inet_pton module is require. This avoid exception "AttributeError:
-        'module' object has no attribute 'inet_pton'".
-        
-        install win_inet_pton:
-        
-        .. code-block:: bash
-        
-            sudo pip install win_inet_pton
-        
-        import win_inet_pton at beginning of your code:
-        
-        .. code-block:: python
-        
-            import win_inet_pton
-            from pyModbusTCP.client import ModbusClient
-        
-Platform: any