WEB simulator, first version. (#1226)

Author: janiversen

pymodbus/__init__.py

@@ -19,13 +19,13 @@
 __logging.getLogger(__name__).addHandler(__null())
 
 
-def pymodbus_apply_logging_config():
+def pymodbus_apply_logging_config(level=__logging.WARNING):
     """Apply basic logging configuration used by default by Pymodbus maintainers.
 
     Please call this function to format logging appropriately when opening issues.
     """
     __logging.basicConfig(
         format="%(asctime)s %(levelname)-5s %(module)s:%(lineno)s %(message)s",
         datefmt="%H:%M:%S",
-        level=__logging.WARNING,
+        level=level,
     )

pymodbus/datastore/simulator.py

@@ -18,7 +18,7 @@
 CELL_TYPE_FLOAT32 = "F"
 CELL_TYPE_STRING = "S"
 CELL_TYPE_NEXT = "n"
-CELL_TYPE_ILLEGAL = "X"
+CELL_TYPE_INVALID = "X"
 
 WORD_SIZE = 16
 
@@ -30,7 +30,9 @@ class Cell:
     type: int = CELL_TYPE_NONE
     access: bool = False
     value: int = 0
-    action: Callable = None
+    action: int = 0
+    count_read: int = 0
+    count_write: int = 0
 
 
 @dataclasses.dataclass
@@ -42,6 +44,7 @@ class Label:  # pylint: disable=too-many-instance-attributes
 
     action: str = "action"
     addr: str = "addr"
+    any: str = "any"
     co_size: str = "co size"
     defaults: str = "defaults"
     di_size: str = "di size"
@@ -52,6 +55,7 @@ class Label:  # pylint: disable=too-many-instance-attributes
     method: str = "method"
     next: str = "next"
     random: str = "random"
+    register: str = "register"
     repeat: str = "repeat"
     reset: str = "reset"
     setup: str = "setup"
@@ -231,7 +235,7 @@ def handle_type_string(self, registers, reg_count, start, stop, value, action):
             registers[inx].value = int.from_bytes(
                 bytes(value[i * 2 : (i + 1) * 2], "UTF-8"), "big"
             )
-            registers[inx].type = CELL_TYPE_STRING
+            registers[inx].type = CELL_TYPE_STRING if not i else CELL_TYPE_NEXT
             registers[start].action = action
 
     def handle_setup_section(self, config, actions):
@@ -300,7 +304,7 @@ def handle_invalid_address(self, registers, reg_count, config):
                 if registers[i].type != CELL_TYPE_NONE:
                     txt = f'ERROR Configuration invalid in section "invalid" register {i} already defined'
                     raise RuntimeError(txt)
-                registers[i].type = CELL_TYPE_ILLEGAL
+                registers[i].type = CELL_TYPE_INVALID
 
     def handle_write_allowed(self, registers, reg_count, config):
         """Handle write allowed"""
@@ -312,6 +316,9 @@ def handle_write_allowed(self, registers, reg_count, config):
                     raise RuntimeError(
                         f'Error section "{Label.write}" addr {entry} out of range'
                     )
+                if registers[i].type in (CELL_TYPE_NONE, CELL_TYPE_INVALID):
+                    txt = f'ERROR Configuration invalid in section "write" register {i} not defined'
+                    raise RuntimeError(txt)
                 registers[i].access = True
 
     def handle_types(self, registers, actions, reg_count, config):
@@ -351,25 +358,20 @@ def handle_repeat(self, registers, reg_count, config):
                     )
                 registers[inx] = dataclasses.replace(registers[copy_inx])
 
-    def setup(self, config, actions, custom_actions) -> None:
+    def setup(self, config, actions) -> None:
         """Load layout from dict with json structure.
 
         :meta private:
         """
-        actions[""] = None
-        actions[None] = None
-        if custom_actions:
-            actions.update(custom_actions)
-
         registers, offset, typ_exc = self.handle_setup_section(config, actions)
         reg_count = len(registers)
         self.handle_invalid_address(registers, reg_count, config)
-        self.handle_write_allowed(registers, reg_count, config)
         self.handle_types(registers, actions, reg_count, config)
+        self.handle_write_allowed(registers, reg_count, config)
         self.handle_repeat(registers, reg_count, config)
         for i in range(reg_count):
             if registers[i].type == CELL_TYPE_NONE:
-                registers[i].type = CELL_TYPE_ILLEGAL
+                registers[i].type = CELL_TYPE_INVALID
 
         return (registers, offset, typ_exc, reg_count)
 
@@ -468,16 +470,42 @@ class ModbusSimulatorContext:
     # --------------------------------------------
     start_time = int(datetime.now().timestamp())
 
-    def __init__(self, config: Dict[str, any], actions: Dict[str, Callable]) -> None:
+    def __init__(
+        self, config: Dict[str, any], custom_actions: Dict[str, Callable]
+    ) -> None:
         """Initialize."""
-        builtin_actions = {
+        self.action_names = {
             Label.increment: self.action_increment,
+            Label.register: self.action_register,
             Label.random: self.action_random,
             Label.reset: self.action_reset,
             Label.timestamp: self.action_timestamp,
             Label.uptime: self.action_uptime,
         }
-        res = Setup().setup(config, builtin_actions, actions)
+        if custom_actions:
+            self.action_names.update(custom_actions)
+        j = len(self.action_names) + 1
+        self.action_inx_to_name = ["None"] * j
+        self.action_methods = [None] * j
+        j = 1
+        for key, method in self.action_names.items():
+            self.action_inx_to_name[j] = key
+            self.action_methods[j] = method
+            self.action_names[key] = j
+            j += 1
+        self.action_names[None] = 0
+        self.type_names = {
+            Label.type_none: CELL_TYPE_NONE,
+            Label.type_bits: CELL_TYPE_BIT,
+            Label.type_uint16: CELL_TYPE_UINT16,
+            Label.type_uint32: CELL_TYPE_UINT32,
+            Label.type_float32: CELL_TYPE_FLOAT32,
+            Label.type_string: CELL_TYPE_STRING,
+            Label.next: CELL_TYPE_NEXT,
+            Label.invalid: CELL_TYPE_INVALID,
+            Label.any: None,
+        }
+        res = Setup().setup(config, self.action_names)
         self.registers = res[0]
         self.offset = res[1]
         self.type_exception = res[2]
@@ -506,7 +534,7 @@ def validate(self, func_code, address, count=1):
         fx_write = func_code in self._write_func_code
         for i in range(real_address, real_address + count):
             reg = self.registers[i]
-            if reg.type == CELL_TYPE_ILLEGAL:
+            if reg.type == CELL_TYPE_INVALID:
                 return False
             if fx_write and not reg.access:
                 return False
@@ -525,7 +553,8 @@ def getValues(self, func_code, address, count=1):  # pylint: disable=invalid-nam
             for i in range(real_address, real_address + count):
                 reg = self.registers[i]
                 if reg.action:
-                    reg.action(self.registers, i, reg)
+                    self.action_methods[reg.action](self.registers, i, reg)
+                self.registers[i].count_read += 1
                 result.append(reg.value)
         else:
             # bit access
@@ -535,7 +564,8 @@ def getValues(self, func_code, address, count=1):  # pylint: disable=invalid-nam
             for i in range(real_address, real_address + reg_count):
                 reg = self.registers[i]
                 if reg.action:
-                    reg.action(i, reg)
+                    self.action_methods[reg.action](i, reg)
+                self.registers[i].count_read += 1
                 while count and bit_index < 16:
                     result.append(bool(reg.value & (2**bit_index)))
                     count -= 1
@@ -552,6 +582,7 @@ def setValues(self, func_code, address, values):  # pylint: disable=invalid-name
             real_address = self.offset[func_code] + address
             for value in values:
                 self.registers[real_address].value = value
+                self.registers[real_address].count_write += 1
                 real_address += 1
             return
 
@@ -564,6 +595,7 @@ def setValues(self, func_code, address, values):  # pylint: disable=invalid-name
                 self.registers[real_address].value |= bit_mask
             else:
                 self.registers[real_address].value &= ~bit_mask
+            self.registers[real_address].count_write += 1
             bit_index += 1
             if bit_index == 16:
                 bit_index = 0
@@ -574,6 +606,25 @@ def setValues(self, func_code, address, values):  # pylint: disable=invalid-name
     # Internal action methods
     # --------------------------------------------
 
+    @classmethod
+    def action_register(cls, registers, inx, cell):
+        """Update with register number.
+
+        :meta private:
+        """
+        if cell.type == CELL_TYPE_BIT:
+            registers[inx].value = inx
+        elif cell.type == CELL_TYPE_FLOAT32:
+            regs = cls.build_registers_from_value(float(inx), False)
+            registers[inx].value = regs[0]
+            registers[inx + 1].value = regs[1]
+        elif cell.type == CELL_TYPE_UINT16:
+            registers[inx].value = inx
+        elif cell.type == CELL_TYPE_UINT32:
+            regs = cls.build_registers_from_value(inx, True)
+            registers[inx].value = regs[0]
+            registers[inx + 1].value = regs[1]
+
     @classmethod
     def action_random(cls, registers, inx, cell):
         """Update with random value.
@@ -583,13 +634,15 @@ def action_random(cls, registers, inx, cell):
         if cell.type == CELL_TYPE_BIT:
             registers[inx].value = random.randint(0, 65536)
         elif cell.type == CELL_TYPE_FLOAT32:
-            regs = cls.build_registers_from_value(random.uniform(0.0, 100.0), False)
+            regs = cls.build_registers_from_value(random.uniform(0.0, 65000.0), False)
             registers[inx].value = regs[0]
             registers[inx + 1].value = regs[1]
         elif cell.type == CELL_TYPE_UINT16:
             registers[inx].value = random.randint(0, 65536)
         elif cell.type == CELL_TYPE_UINT32:
-            regs = cls.build_registers_from_value(random.uniform(0.0, 100.0), True)
+            regs = cls.build_registers_from_value(
+                int(random.uniform(0.0, 65000.0)), True
+            )
             registers[inx].value = regs[0]
             registers[inx + 1].value = regs[1]
 

pymodbus/server/__init__.py

@@ -3,6 +3,10 @@
 import external classes, to make them easier to use:
 """
 from pymodbus.server.async_io import (
+    ModbusSerialServer,
+    ModbusTcpServer,
+    ModbusTlsServer,
+    ModbusUdpServer,
     ServerAsyncStop,
     ServerStop,
     StartAsyncSerialServer,
@@ -14,18 +18,24 @@
     StartTlsServer,
     StartUdpServer,
 )
+from pymodbus.server.simulator.http_server import ModbusSimulatorServer
 
 
 # ---------------------------------------------------------------------------#
 #  Exported symbols
 # ---------------------------------------------------------------------------#
 __all__ = [
+    "ModbusSerialServer",
+    "ModbusSimulatorServer",
+    "ModbusTcpServer",
+    "ModbusTlsServer",
+    "ModbusUdpServer",
     "ServerAsyncStop",
     "ServerStop",
+    "StartAsyncSerialServer",
     "StartAsyncTcpServer",
     "StartAsyncTlsServer",
     "StartAsyncUdpServer",
-    "StartAsyncSerialServer",
     "StartSerialServer",
     "StartTcpServer",
     "StartTlsServer",