SimData BITS do not mix int and bool.

Author: janiversen

examples/contrib/test_datastores.py

@@ -40,7 +40,7 @@ async def run_async(port, context, run_test):
 
     Log.info("### Create client object")
     client = modbusClient.AsyncModbusTcpClient(
-        "127.0.0.1",
+        NULLMODEM_HOST,
         port=5020,
         framer=FramerType.SOCKET,
     )
@@ -56,23 +56,24 @@ async def run_sequential(port) -> None:
     """Combine setup and run."""
     async def run_old_test(client):
         """Run test."""
+        Log.info("### read_coils")
         rr = await client.read_coils(32, count=1, device_id=1)
         assert rr.bits == [True] + [False] * 7
         rr = await client.read_coils(32, count=16, device_id=1)
         assert rr.bits == [True]*16
 
-
-    pymodbus_apply_logging_config("info")
     context = ModbusServerContext(devices=ModbusDeviceContext(
         co=ModbusSequentialDataBlock(0x00, [17] * 100),
         ),
         single=True
     )
+    Log.info("Run sequential test.")
     await run_async(port, context, run_old_test)
 
 
 async def run_all(port):
     """Run all tests."""
+    pymodbus_apply_logging_config("info")
     await run_sequential(port)
 
 if __name__ == "__main__":

pymodbus/simulator/simdata.py

@@ -143,8 +143,10 @@ def __check_parameters(self):
         x_values = self.values if isinstance(self.values, list) else [self.values]
         x_datatype, _x_struct, _x_len = SimUtils.DATATYPE_STRUCT[self.datatype]
         if self.datatype == DataType.BITS:
-            x_datatype = int if isinstance(x_values[0], int) else bool
+            x_datatype = bool if isinstance(x_values[0], bool) else int
         for x_value in x_values:
+            if self.datatype == DataType.BITS and x_datatype is int and isinstance(x_value, bool):
+                raise TypeError(f"values= {x_value} int and bool cannot be mixed")
             if not isinstance(x_value, x_datatype):
                 raise TypeError(f"values= {x_value} is not {x_datatype!s}")
             if x_datatype is str and not x_value:

test/simulator/test_simdata.py

@@ -80,6 +80,8 @@ def test_simdata_value_ok(self, value, value_type):
         ([11, 12.0], DataType.REGISTERS),
         (1.0, DataType.BITS),
         ([True, 1.0], DataType.BITS),
+        ([True, 1], DataType.BITS),
+        ([1, True], DataType.BITS),
         ])
     def test_simdata_value_not_ok(self, value, value_type):
         """Test simdata value."""
@@ -141,6 +143,7 @@ def test_simdata_build_string(self, value, code, expect):
 
     @pytest.mark.parametrize(("value", "regs"), [
         ([True, False, True], [True, False, True]),
+        ([True] + [False] * 14 + [True, False], [True] + [False] * 14 + [True, False]),
         (0x0100, [True] + [False]*15),
         ([256, 1], [True] +  [False]*23 + [True] + [False]*7),
         ])

test/simulator/test_simdevice.py

@@ -146,6 +146,9 @@ async def test_simdevice_bit_addressing(self):
         ([SimData(0, values=[0xffff, 0xffff], datatype=DataType.BITS)],
          (0, [65535, 65535, 0],
             [DataType.BITS, 0, DataType.INVALID])),
+        # ([SimData(0, values=[True] * 2 + [False]*6 + [True] + [False]*6 + [True], datatype=DataType.BITS)],
+        # (0, [129, 0],
+        #    [DataType.BITS, DataType.INVALID])),
         ([SimData(1, values=123, datatype=DataType.INT16),
             SimData(3, values=456, datatype=DataType.INT16)],
          (1, [123, 0, 456, 0],
@@ -212,8 +215,8 @@ def test_simdevice_build_blocks(self):
         assert lists == result
 
     @pytest.mark.parametrize(("block", "result", "addr"), [
-        #([SimData(0, values=123, datatype=DataType.BITS)], [0x007b, 0x0000], 0),
-        ([SimData(0, values=True, datatype=DataType.BITS)], [0x0001, 0x0000], 0),
+        ([SimData(0, values=123, datatype=DataType.BITS)], [0x007b, 0x0000], 0),
+        #([SimData(0, values=True, datatype=DataType.BITS)], [0x0001, 0x0000], 0),
         #([SimData(1, values=123, datatype=DataType.BITS)], [0x00F6, 0x0000, 0x0000], 0),
     ])
     def test_simdevice_build_bits(self, block, result, addr):
@@ -222,21 +225,10 @@ def test_simdevice_build_bits(self, block, result, addr):
 
         sd = SimDevice(id=1, simdata=(block, block, [sim123], [sim123]))
         result_block = cast(dict[str, SimRegs], sd.build_device())
-        assert result_block["c"][0] == addr
-        assert result_block["c"][1] == result
-        assert result_block["d"][0] == addr
-        assert result_block["d"][1] == result
-        assert result_block["h"][1] == [123, 0]
-        assert result_block["i"][1] == [123, 0]
-        assert len(result_block["c"][1]) == len(result)
-        #sd = SimDevice(id=1, simdata=(
-        #    [sim123,
-        #     SimData(17, values=True, datatype=DataType.BITS),
-        #     SimData(20, values=123, datatype=DataType.BITS)],
-        #    [sim123], [sim123], [sim123]
-        #))
-        #result_block = cast(dict[str, SimRegs], sd.build_device())
-        #assert result_block["c"][1] == [0x7b, 0x01d8, 0x03, 0x00]
+        assert result_block["c"][0:2] == (addr, result)
+        assert result_block["d"][0:2] == (addr, result)
+        assert result_block["h"][0:2] == (1, [123, 0])
+        assert result_block["i"][0:2] == (1, [123, 0])
 
     @pytest.mark.parametrize("count", range(1,4))
     @pytest.mark.parametrize("data_count", range(1,4))