Parameterize string encoding in convert_to_registers and convert_from_registers (#2558)

Author: Breina

pymodbus/client/mixin.py

@@ -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:

test/client/test_client.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)