Merge branch 'master_sin'

Author: janiversen

Diff for: AUTHORS.rst

@@ -24,6 +24,7 @@ Thanks to
 - andrew-harness
 - banana-sun
 - Blaise Thompson
+- Breina
 - CapraTheBest
 - cgernert
 - corollaries
@@ -77,6 +78,7 @@ Thanks to
 - peufeu2
 - Philip Couling
 - Philip Jones
+- Robin Trabert
 - Qi Li
 - Sebastian Machuca
 - Sefa Keleş

Diff for: CHANGELOG.rst

@@ -7,6 +7,19 @@ helps make pymodbus a better product.
 
 :ref:`Authors`: contains a complete list of volunteers have contributed to each major version.
 
+Version 3.8.4
+-------------
+* Parameterize string encoding in convert_to_registers and convert_from_registers (#2558)
+* Fix client modbus function calls in remote by adding count as keyword argument (#2563)
+* Fix exception text in ModbusPDU.validateAddress (#2551)
+* Typo arround `no_response_expected` (#2550)
+* Trace new connection in server. (#2549)
+* Add trace to server.
+* Update misleading DATATYPE text. (#2547)
+* Fix pylint.
+* Clarify server usage.
+* Solve instable transaction testing. (#2538)
+
 Version 3.8.3
 -------------
 * Remove deprecate from payload. (#2532)

Diff for: MAKE_RELEASE.rst

@@ -15,8 +15,8 @@ Prepare/make release on dev.
    * Control / Update API_changes.rst
    * Update CHANGELOG.rst
       * Add commits from last release, but selectively !
-        git log --oneline v3.8.3..HEAD > commit.log
-        git log --pretty="%an" v3.8.3..HEAD | sort -uf > authors.log
+        git log --oneline v3.8.4..HEAD > commit.log
+        git log --pretty="%an" v3.8.4..HEAD | sort -uf > authors.log
         update AUTHORS.rst and CHANGELOG.rst
         cd doc; ./build_html
    * rm -rf build/* dist/*

Diff for: README.rst

@@ -26,7 +26,7 @@ Upgrade examples:
 - 3.7.1 -> 3.8.0: Smaller changes to the pymodbus calls might be needed
 - 2.5.4 -> 3.0.0: Major changes in the application might be needed
 
-Current release is `3.8.3 <https://github.com/pymodbus-dev/pymodbus/releases/tag/v3.8.3>`_.
+Current release is `3.8.4 <https://github.com/pymodbus-dev/pymodbus/releases/tag/v3.8.4>`_.
 
 Bleeding edge (not released) is `dev <https://github.com/pymodbus-dev/pymodbus/tree/dev>`_.
 

Diff for: doc/source/_static/examples.tgz

@@ -199,12 +199,12 @@ The logical devices represented by the device is addressed with the :mod:`slave=
 With **Serial**, the comm port is defined when creating the object.
 The physical devices are addressed with the :mod:`slave=` parameter.
 
-:mod:`slave=0` is defined as broadcast in the modbus standard, but pymodbus treats is a normal device.
+:mod:`slave=0` is defined as broadcast in the modbus standard, but pymodbus treats it as a normal device.
 
 If an application is expecting multiple responses to a broadcast request, it must call :mod:`client.execute` and deal with the responses.
 
 If no response is expected to a request, the :mod:`no_response_expected=True` argument can be used
-in the normal API calls, this will cause the call to return imidiatble with :mod:`None`
+in the normal API calls, this will cause the call to return immediately with :mod:`None`.
 
 
 Client response handling
@@ -224,7 +224,7 @@ The application should evaluate the result generically::
         raise ModbusException(txt)
 
 :mod:`except ModbusException as exc:` happens generally when pymodbus experiences an internal error.
-There are a few situation where a unexpected response from a device can cause an exception.
+There are a few situation where an unexpected response from a device can cause an exception.
 
 :mod:`rr.isError()` is set whenever the device reports a problem.
 
@@ -257,7 +257,7 @@ There are a client class for each type of communication and for asynchronous/syn
 
 Client common
 ^^^^^^^^^^^^^
-Some methods are common to all client:
+Some methods are common to all clients:
 
 .. autoclass:: pymodbus.client.base.ModbusBaseClient
     :members:
@@ -323,7 +323,7 @@ Modbus calls
 
 Pymodbus makes all standard modbus requests/responses available as simple calls.
 
-Using Modbus<transport>Client.register() custom messagees can be added to pymodbus,
+Using Modbus<transport>Client.register() custom messages can be added to pymodbus,
 and handled automatically.
 
 .. autoclass:: pymodbus.client.mixin.ModbusClientMixin

Diff for: doc/source/_static/examples.zip

@@ -15,7 +15,7 @@ It is the community that decides how pymodbus evolves NOT the maintainers !
 
 The following bullet points are what the maintainers focus on:
 
-- 3.8.4 bug fix release, with:
+- 3.8.5 bug fix release, with:
     - Currently not planned
 - 3.9.0, with:
     - All of branch wait_next_api

Diff for: doc/source/client.rst

@@ -18,6 +18,7 @@ communication in 2 versions:
 synchronous servers are just an interface layer allowing synchronous
 applications to use the server as if it was synchronous.
 
+*Warning* The current framer implementation does not support running the server on a shared rs485 line (multipoint).
 
 .. automodule:: pymodbus.server
     :members:

Diff for: doc/source/roadmap.rst

@@ -18,5 +18,5 @@
 from pymodbus.pdu import ExceptionResponse
 
 
-__version__ = "3.8.3"
+__version__ = "3.8.4"
 __version_full__ = f"[pymodbus, version {__version__}]"

Diff for: doc/source/server.rst

@@ -37,10 +37,10 @@ class ModbusClientMixin(Generic[T]):  # pylint: disable=too-many-public-methods
     Advanced modbus message call::
 
         request = ReadCoilsRequest(1,10)
-        response = client.execute(request)
+        response = client.execute(False, request)
         # or
         request = ReadCoilsRequest(1,10)
-        response = await client.execute(request)
+        response = await client.execute(False, request)
 
     .. tip::
         All methods can be used directly (synchronous) or
@@ -51,7 +51,7 @@ def __init__(self):
         """Initialize."""
 
     @abstractmethod
-    def execute(self,  no_response_expected: bool, request: ModbusPDU,) -> T:
+    def execute(self, no_response_expected: bool, request: ModbusPDU) -> T:
         """Execute request."""
 
     def read_coils(self, address: int, *, count: int = 1, slave: int = 1, no_response_expected: bool = False) -> T:
@@ -680,7 +680,7 @@ def read_device_information(self, *, read_code: int | None = None,
     # ------------------
 
     class DATATYPE(Enum):
-        """Datatype enum (name and number of bytes), used for convert_* calls."""
+        """Datatype enum (name and internal data), used for convert_* calls."""
 
         INT16 = ("h", 1)
         UINT16 = ("H", 1)
@@ -695,15 +695,17 @@ class DATATYPE(Enum):
 
     @classmethod
     def convert_from_registers(
-        cls, registers: list[int], data_type: DATATYPE, word_order: Literal["big", "little"] = "big"
+        cls, registers: list[int], data_type: DATATYPE, word_order: Literal["big", "little"] = "big", string_encoding: str = "utf-8"
     ) -> int | float | str | list[bool] | list[int] | list[float]:
         """Convert registers to int/float/str.
 
         :param registers: list of registers received from e.g. read_holding_registers()
         :param data_type: data type to convert to
         :param word_order: "big"/"little" order of words/registers
+        :param string_encoding: The encoding with which to decode the bytearray, only used when data_type=DATATYPE.STRING
         :returns: scalar or array of "data_type"
         :raises ModbusException: when size of registers is not a multiple of data_type
+        :raises ParameterException: when the specified string encoding is not supported
         """
         if not (data_len := data_type.value[1]):
             byte_list = bytearray()
@@ -716,7 +718,7 @@ def convert_from_registers(
                 while trailing_nulls_begin > 0 and not byte_list[trailing_nulls_begin - 1]:
                     trailing_nulls_begin -= 1
                 byte_list = byte_list[:trailing_nulls_begin]
-                return byte_list.decode("utf-8")
+                return byte_list.decode(string_encoding)
             return unpack_bitstring(byte_list)
         if (reg_len := len(registers)) % data_len:
             raise ModbusException(
@@ -736,15 +738,17 @@ def convert_from_registers(
 
     @classmethod
     def convert_to_registers(
-        cls, value: int | float | str | list[bool] | list[int] | list[float] , data_type: DATATYPE, word_order: Literal["big", "little"] = "big"
+        cls, value: int | float | str | list[bool] | list[int] | list[float], data_type: DATATYPE, word_order: Literal["big", "little"] = "big", string_encoding: str = "utf-8"
     ) -> list[int]:
         """Convert int/float/str to registers (16/32/64 bit).
 
         :param value: value to be converted
         :param data_type: data type to convert from
         :param word_order: "big"/"little" order of words/registers
+        :param string_encoding: The encoding with which to encode the bytearray, only used when data_type=DATATYPE.STRING
         :returns: List of registers, can be used directly in e.g. write_registers()
         :raises TypeError: when there is a mismatch between data_type and value
+        :raises ParameterException: when the specified string encoding is not supported
         """
         if data_type == cls.DATATYPE.BITS:
             if not isinstance(value, list):
@@ -755,7 +759,7 @@ def convert_to_registers(
         elif data_type == cls.DATATYPE.STRING:
             if not isinstance(value, str):
                 raise TypeError(f"Value should be string but is {type(value)}.")
-            byte_list = value.encode()
+            byte_list = value.encode(string_encoding)
             if len(byte_list) % 2:
                 byte_list += b"\x00"
         else:

Diff for: pymodbus/__init__.py

@@ -74,16 +74,16 @@ def __build_mapping(self):
             params["slave"] = self.slave
         self.__get_callbacks = {
             "d": lambda a, c: self._client.read_discrete_inputs(
-                a, c, **params
+                a, count=c, **params
             ),
             "c": lambda a, c: self._client.read_coils(
-                a, c, **params
+                a, count=c, **params
             ),
             "h": lambda a, c: self._client.read_holding_registers(
-                a, c, **params
+                a, count=c, **params
             ),
             "i": lambda a, c: self._client.read_input_registers(
-                a, c, **params
+                a, count=c, **params
             ),
         }
         self.__set_callbacks = {

Diff for: pymodbus/client/mixin.py

@@ -73,6 +73,9 @@ class FramerRTU(FramerBase):
         ------------------------------------------------------------------
         1 Byte = start + 8 bits + parity + stop = 11 bits
         (1/Baud)(bits) = delay seconds
+
+    .. Danger:: Current framerRTU does not support running the server on a multipoint rs485 line.
+
     """
 
     MIN_SIZE = 4  # <slave id><function code><crc 2 bytes>

Diff for: pymodbus/datastore/remote.py

@@ -53,7 +53,7 @@ def validateAddress(self, address: int = -1) -> None:
         if address == -1:
             address = self.address
         if not 0 <= address <= 65535:
-            raise ValueError(f"9 < address {address} < 65535 !")
+            raise ValueError(f"0 < address {address} < 65535 !")
 
     def __str__(self) -> str:
         """Build a representation of an exception response."""

Diff for: pymodbus/framer/rtu.py

@@ -1,7 +1,4 @@
-"""Server.
-
-import external classes, to make them easier to use:
-"""
+"""**Server classes**."""
 
 __all__ = [
     "ModbusSerialServer",

Diff for: pymodbus/pdu/pdu.py

@@ -60,7 +60,14 @@ def __init__(  # pylint: disable=too-many-arguments
 
     def callback_new_connection(self):
         """Handle incoming connect."""
-        return ServerRequestHandler(self)
+        if self.trace_connect:
+            self.trace_connect(True)
+        return ServerRequestHandler(
+            self,
+            self.trace_packet,
+            self.trace_pdu,
+            self.trace_connect
+        )
 
     async def shutdown(self):
         """Close server."""

Diff for: pymodbus/server/__init__.py

@@ -14,7 +14,7 @@
 class ServerRequestHandler(TransactionManager):
     """Handle client connection."""
 
-    def __init__(self, owner):
+    def __init__(self, owner, trace_packet, trace_pdu, trace_connect):
         """Initialize."""
         params = CommParams(
             comm_name="server",
@@ -34,9 +34,9 @@ def __init__(self, owner):
             self.framer,
             0,
             True,
-            None,
-            None,
-            None,
+            trace_packet,
+            trace_pdu,
+            trace_connect,
         )
 
     def callback_new_connection(self) -> ModbusProtocol:

Diff for: pymodbus/server/base.py

@@ -97,73 +97,85 @@ def fake_execute(_self, _no_response_expected, request):
 
     @pytest.mark.parametrize(("word_order"), ["big", "little", None])
     @pytest.mark.parametrize(
-        ("datatype", "value", "registers"),
+        ("datatype", "value", "registers", "string_encoding"),
         [
-            (ModbusClientMixin.DATATYPE.STRING, "abcd", [0x6162, 0x6364]),
-            (ModbusClientMixin.DATATYPE.STRING, "a", [0x6100]),
-            (ModbusClientMixin.DATATYPE.UINT16, 27123, [0x69F3]),
-            (ModbusClientMixin.DATATYPE.INT16, -27123, [0x960D]),
-            (ModbusClientMixin.DATATYPE.UINT32, 27123, [0x0000, 0x69F3]),
-            (ModbusClientMixin.DATATYPE.UINT32, 32145678, [0x01EA, 0x810E]),
-            (ModbusClientMixin.DATATYPE.INT32, -32145678, [0xFE15, 0x7EF2]),
+            (ModbusClientMixin.DATATYPE.STRING, "abcdÇ", [0x6162, 0x6364, 0xc387], "utf-8"),
+            (ModbusClientMixin.DATATYPE.STRING, "abcdÇ", [0x6162, 0x6364, 0xc387], None),
+            (ModbusClientMixin.DATATYPE.STRING, "abcdÇ", [0x6162, 0x6364, 0x8000], "cp437"),
+            (ModbusClientMixin.DATATYPE.STRING, "a", [0x6100], None),
+            (ModbusClientMixin.DATATYPE.UINT16, 27123, [0x69F3], None),
+            (ModbusClientMixin.DATATYPE.INT16, -27123, [0x960D], None),
+            (ModbusClientMixin.DATATYPE.UINT32, 27123, [0x0000, 0x69F3], None),
+            (ModbusClientMixin.DATATYPE.UINT32, 32145678, [0x01EA, 0x810E], None),
+            (ModbusClientMixin.DATATYPE.INT32, -32145678, [0xFE15, 0x7EF2], None),
             (
                 ModbusClientMixin.DATATYPE.UINT64,
                 1234567890123456789,
                 [0x1122, 0x10F4, 0x7DE9, 0x8115],
+                None,
             ),
             (
                 ModbusClientMixin.DATATYPE.INT64,
                 -1234567890123456789,
                 [0xEEDD, 0xEF0B, 0x8216, 0x7EEB],
+                None,
             ),
-            (ModbusClientMixin.DATATYPE.FLOAT32, 27123.5, [0x46D3, 0xE700]),
-            (ModbusClientMixin.DATATYPE.FLOAT32, 3.141592, [0x4049, 0x0FD8]),
-            (ModbusClientMixin.DATATYPE.FLOAT32, -3.141592, [0xC049, 0x0FD8]),
-            (ModbusClientMixin.DATATYPE.FLOAT64, 27123.5, [0x40DA, 0x7CE0, 0x0000, 0x0000]),
+            (ModbusClientMixin.DATATYPE.FLOAT32, 27123.5, [0x46D3, 0xE700], None),
+            (ModbusClientMixin.DATATYPE.FLOAT32, 3.141592, [0x4049, 0x0FD8], None),
+            (ModbusClientMixin.DATATYPE.FLOAT32, -3.141592, [0xC049, 0x0FD8], None),
+            (ModbusClientMixin.DATATYPE.FLOAT64, 27123.5, [0x40DA, 0x7CE0, 0x0000, 0x0000], None),
             (
                 ModbusClientMixin.DATATYPE.FLOAT64,
                 3.14159265358979,
                 [0x4009, 0x21FB, 0x5444, 0x2D11],
+                None,
             ),
             (
                 ModbusClientMixin.DATATYPE.FLOAT64,
                 -3.14159265358979,
                 [0xC009, 0x21FB, 0x5444, 0x2D11],
+                None,
             ),
             (
                 ModbusClientMixin.DATATYPE.BITS,
                 [True],
                 [256],
+                None,
             ),
             (
                 ModbusClientMixin.DATATYPE.BITS,
                 [True, False, True],
                 [1280],
+                None,
             ),
             (
                 ModbusClientMixin.DATATYPE.BITS,
                 [True, False, True] + [False] * 5 + [True],
                 [1281],
+                None,
             ),
             (
                 ModbusClientMixin.DATATYPE.BITS,
                 [True, False, True] + [False] * 5 + [True] + [False] * 6 + [True],
                 [1409],
+                None,
             ),
             (
                 ModbusClientMixin.DATATYPE.BITS,
                 [True, False, True] + [False] * 5 + [True] + [False] * 6 + [True] * 2,
                 [1409, 256],
+                None,
             ),
         ],
     )
-    def test_client_mixin_convert(self, datatype, word_order, registers, value):
+    def test_client_mixin_convert(self, datatype, word_order, registers, value, string_encoding):
         """Test converter methods."""
         if word_order == "little":
-            x = registers.copy()
-            x.reverse()
-            registers = x
-        kwargs = {"word_order": word_order} if word_order else {}
+            registers = list(reversed(registers))
+
+        kwargs = {**({"word_order": word_order} if word_order else {}),
+                  **({"string_encoding": string_encoding} if string_encoding else {})}
+
         regs = ModbusClientMixin.convert_to_registers(value, datatype, **kwargs)
         assert regs == registers
         result = ModbusClientMixin.convert_from_registers(registers, datatype, **kwargs)