MTPPy2.0 0.1.7__tar.gz → 0.2.0__tar.gz

{mtppy2_0-0.1.7/src/MTPPy2.0.egg-info → mtppy2_0-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MTPPy2.0
-Version: 0.1.7
+Version: 0.2.0
 Summary: Open-source modular automation with MTP 2.0
 Author: Dresden University of Technology, Process-to-Order Group
 Author-email: Julius Lorenz <julius.lorenz@tu-dresden.de>, Leon Urbas <leon.urbas@tu-dresden.de>

{mtppy2_0-0.1.7 → mtppy2_0-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "MTPPy2.0"
-version = "0.1.7"
+version = "0.2.0"
 description = "Open-source modular automation with MTP 2.0"
 readme="README.md"
 license = "MIT"
@@ -103,7 +103,12 @@ filterwarnings = [
 ]
 
 [tool.ruff]
+line-length = 88
+target-version = "py310"
+inline-quotes = "double"
+
 lint.select = ["ALL"]
+
 # ANN001 - Missing type annotation for function argument
 # `incorrect-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible. Ignoring `incorrect-blank-line-before-class`.
 # `multi-line-summary-first-line` (D212) and `multi-line-summary-second-line` (D213) are incompatible. Ignoring `multi-line-summary-second-line`.
@@ -113,3 +118,6 @@ lint.select = ["ALL"]
 # `Missing blank line after last section` (D413)
 # `Too many arguments in function definition` (PLR0913)
 lint.ignore = ["ANN002","ANN003","D203","D213","D205","D413","PLR0913"]
+
+[tool.ruff.pydocstyle]
+convention = "google"  # Enforce Google-style docstrings

{mtppy2_0-0.1.7 → mtppy2_0-0.2.0/src/MTPPy2.0.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MTPPy2.0
-Version: 0.1.7
+Version: 0.2.0
 Summary: Open-source modular automation with MTP 2.0
 Author: Dresden University of Technology, Process-to-Order Group
 Author-email: Julius Lorenz <julius.lorenz@tu-dresden.de>, Leon Urbas <leon.urbas@tu-dresden.de>

{mtppy2_0-0.1.7 → mtppy2_0-0.2.0}/src/MTPPy2.0.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/examples/modbus/__init__.py
 src/examples/modbus/m15_logic.py
 src/examples/modbus/m15_pea.py
 src/examples/modbus/m15_pea_test.py
+src/examples/modbus/m15_simulator.py
 src/examples/rmtp/__init__.py
 src/examples/rmtp/minimal+pid.py
 src/examples/rmtp/minimal.py
@@ -23,6 +24,8 @@ src/mtppy/feas/__init__.py
 src/mtppy/feas/modbus/__init__.py
 src/mtppy/feas/modbus/config_loader.py
 src/mtppy/feas/modbus/config_loader_test.py
+src/mtppy/feas/modbus/io_action.py
+src/mtppy/feas/modbus/io_action_test.py
 src/mtppy/feas/modbus/io_logic.py
 src/mtppy/feas/modbus/io_logic_test.py
 src/mtppy/feas/modbus/io_procedure.py
@@ -173,6 +176,7 @@ src/mtppy/pea/user_logic/user_logic_pea.py
 src/mtppy/pea/user_logic/user_logic_registry.py
 src/mtppy/pea/user_logic/user_logic_registry_test.py
 src/mtppy/pea/user_logic/user_logic_service.py
+src/mtppy/pea/user_logic/user_logic_service_scenario_test.py
 src/mtppy/pea/user_logic/user_logic_service_test.py
 src/mtppy/utils/__init__.py
 src/mtppy/utils/data_assembly_dict.py

{mtppy2_0-0.1.7 → mtppy2_0-0.2.0}/src/examples/modbus/m15_logic.py

@@ -5,29 +5,42 @@ __copyright__ = (
 )
 __license__ = "MIT"
 
+from mtppy.part3.data_assembly_set.active_elements.pid.pid_ctrl import PIDCtrl
+from mtppy.utils.logging import logger
 from mtppy.part4.automation_services.service import Service
 from mtppy.pea.user_logic.user_logic_registry import register
 
-# DataAssembly names, see mapping.txt / m15_modbus.json (register-derived names
-# for unmapped items, per the "_M15_<register>" convention).
+__requirements_mtp__ = "M15.mtp"
+
 DA_PRESSURE_UNITS = "p_eng_units"
 DA_TEMP_UNITS = "t_eng_units"
 DA_VOLUME_UNITS = "v_eng_units"
 DA_START_STOP = "start_stop"
-DA_VALVE = "valve"
+DA_VALVE = "V010"
+
 
 """
-Spezifikation für produce.auto.idle.entry:
+Spezifikation für produce.auto.starting.entry:
     Setze die Anzeigeeinheiten des Generators (Druck, Temperatur,
     Volumen) auf den Standardwert 0.
 """
 
 
-@register("produce.auto.idle.entry")
+@register("produce.auto.starting.entry")
 def reset_units(context: Service) -> bool:
     context.get_param(DA_PRESSURE_UNITS).V = 0
     context.get_param(DA_TEMP_UNITS).V = 0
     context.get_param(DA_VOLUME_UNITS).V = 0
+
+    pctl: PIDCtrl = context.get_param("PIC009")
+
+    pctl.op_mode.set_state_channel(True)
+    pctl.op_mode.set_state_aut_aut(True)
+    pctl.src_mode.set_src_channel(True)
+    pctl.src_mode.set_src_man_aut(True)
+    pctl.SPManMin = pctl.SPSclMin = 0
+    pctl.SPManMax = pctl.SPSclMax = 100
+
     return True
 
 
@@ -39,8 +52,15 @@ Spezifikation für produce.auto.starting.do:
 
 @register("produce.auto.starting.do")
 def start_generator(context: Service) -> bool:
-    context.get_param(DA_START_STOP).V = 0
-    context.get_param(DA_VALVE).V = 1
+    start_stop = context.get_param(DA_START_STOP)
+    valve = context.get_param(DA_VALVE)
+    p_out_sp = context.get_param("p_out_sp")
+    pctl: PIDCtrl = context.get_param("PIC009")
+
+    start_stop.V = 0
+    valve.OpenAut = 1
+    pctl.SPMan = p_out_sp.VOut
+
     return True
 
 
@@ -52,7 +72,7 @@ Spezifikation für produce.auto.holding.do:
 
 @register("produce.auto.holding.do")
 def hold_generator(context: Service) -> bool:
-    context.get_param(DA_VALVE).V = 0
+    context.get_param(DA_VALVE).CloseAut = 1
     return True
 
 
@@ -64,7 +84,7 @@ Spezifikation für produce.auto.unholding.do:
 
 @register("produce.auto.unholding.do")
 def unhold_generator(context: Service) -> bool:
-    context.get_param(DA_VALVE).V = 1
+    context.get_param(DA_VALVE).OpenAut = 1
     return True
 
 
@@ -79,6 +99,10 @@ Spezifikation für produce.auto.completing.do sowie stopping und aborting:
     "produce.auto.completing.do", "produce.auto.stopping.do", "produce.auto.aborting.do"
 )
 def stop_generator(context: Service) -> bool:
-    context.get_param(DA_START_STOP).V = 1
-    context.get_param(DA_VALVE).V = 0
+    start_stop = context.get_param(DA_START_STOP)
+    valve = context.get_param(DA_VALVE)
+
+    start_stop.V = 1
+    valve.CloseAut = 1
+
     return True

{mtppy2_0-0.1.7 → mtppy2_0-0.2.0}/src/examples/modbus/m15_pea.py

@@ -153,7 +153,7 @@ class M15Pea(UserLogicPEA):
 
     def stop(self) -> None:
         """Stop the cyclic I/O service, OPC UA server, and Modbus client."""
-        self.io_service.thread_ctrl.stop()
+        self.io_service.stop()
         super().stop()
         self.modbus_client.close()
 

mtppy2_0-0.2.0/src/examples/modbus/m15_simulator.py

@@ -0,0 +1,42 @@
+import asyncio
+
+from pymodbus.simulator import SimData, SimDevice, DataType
+from pymodbus.server import StartAsyncTcpServer
+
+
+async def my_action(
+    function_code: int,  # request function code
+    start_address: int,  # address of current_registers[0]
+    address: int,  # request address
+    count: int,  # request count
+    current_registers: list[int],  # current registers (modify inline)
+    set_values: (
+        list[int] | list[bool] | None
+    ),  # request values to be written (None for read requests)
+) -> None:
+    if set_values is not None:
+        print(f"{address}:{set_values}")
+
+
+devices = SimDevice(
+    id=1,
+    simdata=[
+        SimData(address=400, count=3, datatype=DataType.UINT16),
+        SimData(address=534, count=1, datatype=DataType.UINT16),
+        SimData(address=1001, count=21, datatype=DataType.UINT16),
+        SimData(address=1101, count=1, datatype=DataType.UINT16),
+        SimData(address=1106, count=20, datatype=DataType.UINT16),
+        SimData(address=1200, count=6, datatype=DataType.UINT16),
+        SimData(address=1400, count=1, datatype=DataType.UINT16),
+        SimData(address=1479, count=1, datatype=DataType.UINT16),
+    ],
+    action=my_action,
+)
+
+
+async def __main__():
+    await StartAsyncTcpServer(context=devices, address=("0.0.0.0", 5020))
+
+
+if __name__ == "__main__":
+    asyncio.run(__main__())

mtppy2_0-0.2.0/src/examples/rmtp/minimal+pid.py

@@ -0,0 +1,81 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import random
+
+from mtppy.part4.automation_services.service import Service
+from mtppy.pea.user_logic.user_logic_registry import register
+from mtppy.utils.logging import logger
+
+"""
+Spezifikation für Service rand_num_gen:
+    Funktion: Generiert eine Zufallszahl innerhalb der angegebenen Grenzen.
+    Zustände: Die aktuelle Zahl wird nur in execute generiert, in allen anderen Zuständen 
+        wird kein neuer Wert generiert.
+    Prozedur: cont
+    Parameter der Prozedur:
+        lower_bound: Untere Grenze für die Zufallszahl.
+        upper_bound: Obere Grenze für die Zufallszahl.
+        generated_value: Reportvariable, in die die generierte Zufallszahl geschrieben wird.
+"""
+
+
+@register("rand_num_gen.cont.idle.entry")
+def setup_cont(self: Service) -> bool:
+    self.cycle_time = 1.0
+    return True
+
+
+@register("rand_num_gen.cont.execute.do")
+def random_number(self: Service) -> bool:
+    lb = self.get_param(PROC, "lower_bound")
+    ub = self.get_param(PROC, "upper_bound")
+    gn = self.get_param(PROC, "generated_value")
+    pid = self.get_param("pid_ctrl")
+
+    pid.SPSclMin = pid.SPIntMin = lb.VOut
+    pid.SPSclMax = pid.SPIntMax = ub.VOut
+    gn.V = random.randint(lb.VOut, ub.VOut)
+
+    logger.app(f"--- generated: {gn.V}")
+
+    return True
+
+
+"""Spezifikation für Service control:
+    Funktion: Implementiert die Steuerlogik für den PID-Regler.
+    Zustände: Die Steuerung erfolgt nur in execute, in allen anderen Zuständen 
+        wird keine Regelaktion durchgeführt. Eingangsgröße des Reglers ist die
+        in der Prozedur "auto" erzeugte Zufallszahl.
+    Prozedur: ctrl
+    Parameter der Prozedur: - 
+"""
+
+
+@register("control.ctrl.idle.entry")
+def setup_ctrl(self: Service) -> bool:
+    self.cycle_time = 0.1
+    pid_ctrl = self.get_param("pid_ctrl")
+    pid_ctrl.StateChannel = True
+    pid_ctrl.SetAutAut = True
+    pid_ctrl.SrcChannel = True
+    pid_ctrl.SrcIntAut = True
+    pid_ctrl.P = 1
+    pid_ctrl.Ti = 0
+    pid_ctrl.Td = 0
+    return True
+
+
+@register("control.ctrl.execute.do")
+def set_target_value(self: Service) -> bool:
+    sp = self.get_param("generated_value")
+    pid_ctrl = self.get_param("pid_ctrl")
+
+    if pid_ctrl.SP != sp.V:
+        pid_ctrl.SPInt = sp.V
+
+    logger.app(f"--- Setpoint {pid_ctrl.SP}")
+
+    return True

{mtppy2_0-0.1.7 → mtppy2_0-0.2.0}/src/examples/rmtp/minimal.py

@@ -2,7 +2,7 @@ __copyright__ = (
     "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
 )
 __license__ = "MIT"
-
+__requirements_mtp__ = "minimal.mtp"
 import random
 
 from mtppy.utils.logging import logger

{mtppy2_0-0.1.7 → mtppy2_0-0.2.0}/src/examples/scratch/pea_minimal.py

@@ -5,13 +5,16 @@ __copyright__ = (
 )
 __license__ = "MIT"
 
+import asyncio
 import time
 import random
 import argparse
 import sys
+from pathlib import Path
 
 from mtppy.utils.logging import logger, CHOICES, setLogLevel
 from mtppy.pea.pea import PEA
+from mtppy.pea.mtp_generator.mtp_generator import MTPGenerator
 from mtppy.part3.data_assembly_set.active_elements.pid.pid_ctrl import PIDCtrl
 from mtppy.part3.data_assembly_set.indicator_elements.views.ana_view import AnaView
 from mtppy.part4.automation_services.service import Service
@@ -25,6 +28,7 @@ from utils.resolve_unit.unit_lib import Units
 class RandomNumberGenerator(Service):
     def __init__(self, tag_name: str, tag_description: str):
         super().__init__(tag_name, tag_description)
+        self.set_cycle_time(0.2)
 
         # Define a single procedure with two parameters and one reporting value and add it to the service
         proc_1 = Procedure(1, "cont", is_self_completing=False)
@@ -50,17 +54,6 @@ class RandomNumberGenerator(Service):
                 v_unit=Units.UNSPECIFIED.code,
             )
         )
-        proc_1.add_procedure_parameter(
-            DIntServParam(
-                "cycle_time",
-                v_op=500,
-                v_min=0,
-                v_max=1000,
-                v_scl_min=0,
-                v_scl_max=1000,
-                v_unit=Units.UNSPECIFIED.code,
-            )
-        )
         proc_1.add_report_value(
             AnaView(
                 "generated_value",
@@ -70,93 +63,81 @@ class RandomNumberGenerator(Service):
             )
         )
         self.add_procedure(proc_1)
+        proc_1.add_required_equipment(proc_1.procedure_parameters)
+        proc_1.add_required_equipment(proc_1.report_values)
 
     # Define the user logic
-    def idle(self):
+    async def idle(self):
         logger.app("- Idle -")
         cycle = 0
-        while self.is_state("idle"):
+        while self.is_state("idle") and not self.thread_ctrl.is_stopped():
             logger.app(
                 f" Idle cycle={cycle}, sm.act_state={self.state_machine.act_state}"
             )
             cycle += 1
-            time.sleep(0.2)
+            await asyncio.sleep(0.2)
 
-    def starting(self):
+    async def starting(self):
         logger.app("- Starting -")
         logger.app("  Applying procedure parameters...")
         self.state_change()
 
-    def execute(self):
+    async def execute(self):
         logger.app("- Execute -")
         cycle = 0
-        while self.is_state("execute"):
+        while self.is_state("execute") and not self.thread_ctrl.is_stopped():
             logger.debug(f"  About to execute cycle {cycle}")
-            # Read procedure parameters
-            lower_bound = (
-                self._get_procedures()[1]
-                .procedure_parameters["lower_bound"]
-                .get_v_out()
-            )
-            upper_bound = (
-                self._get_procedures()[1]
-                .procedure_parameters["upper_bound"]
-                .get_v_out()
-            )
-            cycle_time = (
-                self._get_procedures()[1].procedure_parameters["cycle_time"].get_v_out()
-            ) / 1000.0
-
-            # Create and report random number
-            generated_number = random.randint(lower_bound, upper_bound)
-            self._get_procedures()[1].report_values["generated_value"].set_v(
-                generated_number
-            )
+            # Read procedure parameter data assemblies
+            lower_bound: DIntServParam = self.get_param("lower_bound")
+            upper_bound: DIntServParam = self.get_param("upper_bound")
+            generated_value: AnaView = self.get_param("generated_value")
+
+            generated_value.V = random.randint(lower_bound.VOut, upper_bound.VOut)
 
             logger.app(
-                f" {cycle}, generated_number={generated_number}, bounds={[lower_bound, upper_bound]}, cycle_time={cycle_time}s"
+                f" {cycle}, generated_number={generated_value.V}, bounds={[lower_bound.VOut, upper_bound.VOut]}"
             )
 
             cycle += 1
-            time.sleep(max(0.2, cycle_time))
+            await asyncio.sleep(self.cycle_time)
 
-    def completing(self):
+    async def completing(self):
         self.state_change()
 
-    def completed(self):
+    async def completed(self):
         pass
 
-    def pausing(self):
+    async def pausing(self):
         pass
 
-    def paused(self):
+    async def paused(self):
         pass
 
-    def resuming(self):
+    async def resuming(self):
         pass
 
-    def holding(self):
+    async def holding(self):
         pass
 
-    def held(self):
+    async def held(self):
         pass
 
-    def unholding(self):
+    async def unholding(self):
         pass
 
-    def stopping(self):
+    async def stopping(self):
         pass
 
-    def stopped(self):
+    async def stopped(self):
         pass
 
-    def aborting(self):
+    async def aborting(self):
         pass
 
-    def aborted(self):
+    async def aborted(self):
         pass
 
-    def resetting(self):
+    async def resetting(self):
         logger.app("- Resetting -")
         self.state_change()
 
@@ -190,6 +171,11 @@ def parse_args():
         default=False,
         help="don't stop, continue to run (default: exit ).",
     )
+    p.add_argument(
+        "--mtp",
+        default=None,
+        help="Directory to generate the MTP file into (default: no MTP is generated).",
+    )
     return p.parse_args()
 
 
@@ -227,17 +213,14 @@ if __name__ == "__main__":
     logger.pol("--- Set procedure parameters to Operator mode ---")
     opcua_write("lower_bound.StateOpOp", True)
     opcua_write("upper_bound.StateOpOp", True)
-    time.sleep(1)
 
     logger.pol("--- Set procedure parameter values ---")
     opcua_write("lower_bound.VOp", 40)
     opcua_write("upper_bound.VOp", 60)
-    opcua_write("cycle_time.VOp", 500)
-    time.sleep(1)
 
     logger.pol("--- Set service to Operator mode ---")
     opcua_write("rand_num_gen.StateOpOp", True)
-    time.sleep(1)
+    time.sleep(0.1)
 
     logger.pol("--- Start service ---")
     opcua_write("rand_num_gen.ProcedureOp", 1)
@@ -250,6 +233,17 @@ if __name__ == "__main__":
 
     logger.pol("--- Reset service ---")
     opcua_write("rand_num_gen.CommandOp", CC.RESET.code)
+    time.sleep(1)
+
+    # -------------------------- MTP generation --------------------------
+    # The MTP file is generated from the same in-memory model that defines the
+    # running PEA. MTPGenerator serializes the PEA's data assemblies, services,
+    # process values and alarms into a CAEX .mtp archive.
+    if args.mtp:
+        out_dir = Path(args.mtp)
+        out_dir.mkdir(parents=True, exist_ok=True)
+        logger.app(f"--- Generate MTP into {out_dir} ---")
+        MTPGenerator().generate(pea, out_path=str(out_dir))
 
     # -------------------------- PEA shutdown or detach --------------------------
     if not args.daemon:

{mtppy2_0-0.1.7 → mtppy2_0-0.2.0}/src/mtppy/feas/modbus/__init__.py

@@ -6,6 +6,14 @@ __copyright__ = (
 __license__ = "MIT"
 
 from mtppy.feas.modbus.io_logic import IOLogic, RegisterMapping
+from mtppy.feas.modbus.io_action import (
+    ACTION_CLASSES,
+    IOAction,
+    MapAction,
+    ScaleAction,
+    register_action,
+    resolve_action,
+)
 from mtppy.feas.modbus.io_procedure import IOProcedure
 from mtppy.feas.modbus.io_service import IOService
 from mtppy.feas.modbus.config_loader import (
@@ -16,6 +24,12 @@ from mtppy.feas.modbus.config_loader import (
 __all__ = [
     "IOLogic",
     "RegisterMapping",
+    "IOAction",
+    "ScaleAction",
+    "MapAction",
+    "ACTION_CLASSES",
+    "register_action",
+    "resolve_action",
     "IOProcedure",
     "IOService",
     "create_internal_data_assemblies",

{mtppy2_0-0.1.7 → mtppy2_0-0.2.0}/src/mtppy/feas/modbus/config_loader.py

@@ -10,6 +10,7 @@ import json
 from pathlib import Path
 
 from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.feas.modbus.io_action import ACTION_CLASSES, IOAction, resolve_action
 from mtppy.feas.modbus.io_logic import RegisterMapping
 from mtppy.utils.logging import logger
 
@@ -61,31 +62,10 @@ def create_internal_data_assemblies(
     }
 
 
-def _parse_scale(entry: dict[str, object]) -> tuple[float, float, float, float] | None:
-    """Parse the ``map`` field into a raw-to-engineering linear scale.
-
-    The ``map`` field is expected to be ``[raw_min, raw_max, eng_min, eng_max]``
-    (as strings or numbers), describing a linear conversion between the raw
-    register value and the engineering value stored on the DataAssembly.
-
-    Args:
-        entry: Element configuration dict.
-
-    Returns:
-        A ``(raw_min, raw_max, eng_min, eng_max)`` tuple of floats, or
-        ``None`` if no ``map`` is configured.
-    """
-    scaling = entry.get("map")
-    if scaling is None:
-        return None
-
-    raw_min, raw_max, eng_min, eng_max = (float(value) for value in scaling)
-    return raw_min, raw_max, eng_min, eng_max
-
-
 def load_register_mappings(
     config_path: str | Path,
     data_assemblies: dict[str, DataAssembly],
+    actions: dict[str, type[IOAction]] | None = None,
 ) -> tuple[
     dict[str, DataAssembly],
     list[RegisterMapping],
@@ -96,7 +76,7 @@ def load_register_mappings(
     Each entry under ``internal_equipment`` declares a DataAssembly (``class``)
     and one or more element bindings. Each element key (e.g. ``"V"`",
     ``"VSclMin"``) maps to a dict with at least ``register``, and optionally
-    ``map``, ``access``, and ``description``. An optional ``assign`` key
+    ``action``, ``access``, and ``description``. An optional ``assign`` key
     (list of procedure names) on the entry indicates that the DataAssembly
     shall be added as required equipment to those procedures.
 
@@ -104,6 +84,11 @@ def load_register_mappings(
         config_path: Path to the JSON mapping file (see modbus example README).
         data_assemblies: Existing application-level DataAssemblies, keyed by
             tag_name, that mapping entries may refer to (R-002.1).
+        actions: Optional registry of action key to
+            [IOAction][mtppy.feas.modbus.io_action.IOAction] class used to
+            validate each element's ``action`` string. Defaults to the built-in
+            [ACTION_CLASSES][mtppy.feas.modbus.io_action.ACTION_CLASSES].
+            Unregistered or non-matching actions are dropped.
 
     Returns:
         A tuple of:
@@ -114,6 +99,8 @@ def load_register_mappings(
     with Path(config_path).open(encoding="utf-8") as handle:
         config: dict[str, dict[str, dict[str, object]]] = json.load(handle)
 
+    actions_registry = actions if actions is not None else ACTION_CLASSES
+
     internal_equipment = config.get(INTERNAL_EQUIPMENT_KEY, {})
     internal_data_assemblies = create_internal_data_assemblies(internal_equipment)
 
@@ -152,13 +139,23 @@ def load_register_mappings(
                 continue
 
             access = element_config.get("access", "read")
+            action = element_config.get("action")
+            if (
+                isinstance(action, str)
+                and resolve_action(action, actions_registry) is None
+            ):
+                logger.warning(
+                    f"unknown or invalid action {action!r} for "
+                    f"{tag_name!r}.{element_name!r}"
+                )
+                action = None
             mappings.append(
                 RegisterMapping(
                     register=int(element_config["register"]),
                     data_assembly=data_assembly,
                     element=element_name,
-                    scale=_parse_scale(element_config),
                     access=access,
+                    action=action,
                 )
             )
     return internal_data_assemblies, mappings, assignments