MTPPy2.0 0.1.5__py3-none-any.whl

examples/minimal+pid.py

@@ -0,0 +1,82 @@
+__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
+
+"""
+Prompt für Service SERV, Prozedur PROC und Zustand execute.do:
+    Lese obere und untere Grenze aus den Parametern lower_bound 
+    und upper_bound aus, erzeuge eine Integerzufallszahl in diesen
+    Grenzen und schreibe das Ergebnis in die Reportvariable
+    generated_value 
+"""
+PROC = "cont"
+SERV = "rand_num_gen"
+
+
+@register(f"{SERV}.{PROC}.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")
+
+    gn.V = random.randint(lb.VOut, ub.VOut)
+
+    logger.app(f"--- generated: {gn.V}")
+
+    return True
+
+
+"""
+Prompt für Service "control", Prozedur "ctrl" und Zustand execute.entry:
+    Es soll der Prozedurparameter "target_value" ausgelesen werden
+    und an den Setpoint des DataAssembly "pid_ctrl" geschickt werden
+"""
+CTRL_PROC = "ctrl"
+CTRL_SERV = "control"
+
+
+@register(f"{CTRL_SERV}.{CTRL_PROC}.execute.entry")
+def set_target_value(self: Service) -> bool:
+    # Read target_value parameter
+    target_value = self.get_param(CTRL_PROC, "target_value")
+    pid_ctrl = self.ressources["pid_ctrl"]
+
+    pid_ctrl.SetSpMan = target_value.VOut
+
+    logger.app(f"--- Target value set to {pid_ctrl.SetSpMan} in PID controller")
+
+    return True
+
+
+"""
+Prompt für Service "control", Prozedur "ctrl" und Zustand execute.run:
+    Es soll ein Schritt des Regelalgorithmus ausgeführt werden
+"""
+
+
+@register(f"{CTRL_SERV}.{CTRL_PROC}.execute.run")
+def run_regulation_algorithm(self: Service) -> bool:
+    pid_ctrl = self.ressources["pid_ctrl"]
+    current_value = self.get_param(CTRL_PROC, "current_value")
+    mv_report = self.get_param(CTRL_PROC, "manipulated_value")
+
+    # Set process value in PID controller
+    pid_ctrl.PV = current_value.VOut
+
+    # Get the calculated manipulated value
+    mv = pid_ctrl.MV
+
+    # In a real system, this would send the MV to an actuator
+    logger.app(f"--- PID calculation: PV={current_value.VOut}, MV={mv}")
+
+    # Update the report value with the manipulated value
+    mv_report.V = mv
+
+    return True

examples/minimal.py

@@ -0,0 +1,32 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import random
+
+from mtppy.utils.logging import logger
+from mtppy.part4.automation_services.service import Service
+from mtppy.pea.user_logic.user_logic_registry import register
+
+"""
+Prompt für rand_num_gen.cont.execute.do:
+    Lese obere und untere Grenze aus den Parametern lower_bound 
+    und upper_bound aus, erzeuge eine Integerzufallszahl in diesen
+    Grenzen und schreibe das Ergebnis in die Reportvariable
+    generated_value.
+    Lade erst alle parameter-objekte und rechne anschließend.    
+"""
+
+
+@register(f"rand_num_gen.cont.execute.do")
+def random_number(context: Service) -> bool:
+    lb = context.get_param("lower_bound")
+    ub = context.get_param("upper_bound")
+    gn = context.get_param("generated_value")
+
+    gn.V = random.randint(lb.VOut, ub.VOut)
+
+    logger.app(f"--- generated: {gn.V} in [{lb.VOut},{ub.VOut}]")
+
+    return True

examples/minimal_recipe.py

@@ -0,0 +1,117 @@
+"""POL recipe for the minimal random-number-generator example."""
+
+import argparse
+import time
+from typing import Any
+
+from opcua import Client  # pyright: ignore
+from mtppy.part4.definitions.command_codes import CommandCodes as CC
+from mtppy.utils.logging import CHOICES, logger, setLogLevel
+
+
+def run(
+    client: Any,
+    namespace_index: str,
+    duration: float = 10.0,
+    lower_bound_vop: int = 40,
+    upper_bound_vop: int = 60,
+) -> None:
+    """Run the recipe against an already connected OPC UA client."""
+
+    def write(command: str, value: object) -> None:
+        node_id = f"ns={namespace_index};s={command}"
+        client.get_node(node_id).set_value(value)
+
+    logger.pol("--- Set procedure parameters to Operator mode ---")
+    write("lower_bound.StateOpOp", True)
+    write("upper_bound.StateOpOp", True)
+    time.sleep(1)
+
+    logger.pol("--- Set procedure parameter values ---")
+    write("lower_bound.VOp", lower_bound_vop)
+    write("upper_bound.VOp", upper_bound_vop)
+    time.sleep(1)
+
+    logger.pol("--- Set service to Operator mode ---")
+    write("rand_num_gen.StateOpOp", True)
+    time.sleep(1)
+
+    logger.pol("--- Start service ---")
+    write("rand_num_gen.ProcedureOp", 1)
+    write("rand_num_gen.CommandOp", CC.START.code)
+    time.sleep(duration)
+
+    logger.pol("--- Complete service ---")
+    write("rand_num_gen.CommandOp", CC.COMPLETE.code)
+    time.sleep(1)
+
+    logger.pol("--- Reset service ---")
+    write("rand_num_gen.CommandOp", CC.RESET.code)
+
+
+def parse_args(args: list[str] | None = None) -> argparse.Namespace:
+    """Parse command-line options for the minimal OPC UA recipe."""
+    parser = argparse.ArgumentParser("minimal MTP OPC UA recipe")
+    parser.add_argument(
+        "-e",
+        "--endpoint",
+        required=True,
+        help="OPC UA endpoint of the running PEA",
+    )
+    parser.add_argument(
+        "-n",
+        "--namespace-index",
+        required=True,
+        help="OPC UA namespace index used by the PEA nodes",
+    )
+    parser.add_argument(
+        "-d",
+        "--duration",
+        type=float,
+        default=10.0,
+        help="seconds to leave the service running",
+    )
+    parser.add_argument(
+        "-l",
+        "--log-level",
+        default="MTP",
+        choices=["DEBUG", "INFO", *CHOICES, "WARNING", "ERROR", "CRITICAL"],
+        help="logging level (default: MTP)",
+    )
+    parser.add_argument(
+        "--lower-bound",
+        type=int,
+        default=40,
+        help="value written to lower_bound.VOp (default: 40)",
+    )
+    parser.add_argument(
+        "--upper-bound",
+        type=int,
+        default=60,
+        help="value written to upper_bound.VOp (default: 60)",
+    )
+    return parser.parse_args(args)
+
+
+def main(args: list[str] | None = None) -> None:
+    """Connect to the PEA and execute the minimal OPC UA recipe."""
+    parsed_args = parse_args(args)
+    setLogLevel(parsed_args.log_level)
+    client = Client(parsed_args.endpoint)
+    logger.app(f"--- Connect recipe client to {parsed_args.endpoint} ---")
+    client.connect()
+    try:
+        run(
+            client,
+            parsed_args.namespace_index,
+            parsed_args.duration,
+            parsed_args.lower_bound,
+            parsed_args.upper_bound,
+        )
+    finally:
+        logger.app("--- Disconnect recipe client ---")
+        client.disconnect()
+
+
+if __name__ == "__main__":
+    main()

examples/pea_alarm_base.py

@@ -0,0 +1,47 @@
+"""Build a minimal PEA containing one static AlarmSet.Base alarm."""
+
+# ruff: noqa: INP001
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from mtppy.part3.data_assembly_set.indicator_elements.views.bin_view import BinView
+from mtppy.part6.alarm_set.alarm import Alarm
+from mtppy.pea.pea import PEA
+
+
+def build_pea() -> PEA:
+    """Build a PEA with a binary level indicator and one static alarm."""
+    pea = PEA()
+    level_high = BinView(
+        "LevelHigh",
+        tag_description="High-level indication",
+        v_state_0="Level is normal",
+        v_state_1="Level is too high",
+    )
+    pea.add_data_assembly(level_high)
+    pea.add_alarm(
+        Alarm(
+            tag_name="LevelHigh.Alarm",
+            data_assembly=level_high,
+            trigger=level_high.get_item(BinView.V_),
+            trigger_value=True,
+            message="Level is too high.",
+            ack_required=True,
+            severity=500,
+        ),
+    )
+    return pea
+
+
+def main() -> None:
+    """Build the example and report the registered alarm."""
+    pea = build_pea()
+    alarm = pea.alarms["LevelHigh.Alarm"]
+    print(f"Registered AlarmSet.Base alarm: {alarm.tag_name}")  # noqa: T201
+
+
+if __name__ == "__main__":
+    main()

examples/pea_minimal.py

@@ -0,0 +1,258 @@
+"""**pea_minimal**, a minimal example of a self-contained PEA application."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import time
+import random
+import argparse
+import sys
+
+from mtppy.utils.logging import logger, CHOICES, setLogLevel
+from mtppy.pea.pea import PEA
+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
+from mtppy.part4.automation_services.procedure import Procedure
+from mtppy.part4.automation_services.service_elements.parameter_elements.dint_serv_param import (
+    DIntServParam,
+)
+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)
+
+        # 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)
+        proc_1.add_procedure_parameter(
+            DIntServParam(
+                "lower_bound",
+                v_op=10,
+                v_min=0,
+                v_max=100,
+                v_scl_min=0,
+                v_scl_max=100,
+                v_unit=Units.UNSPECIFIED.code,
+            )
+        )
+        proc_1.add_procedure_parameter(
+            DIntServParam(
+                "upper_bound",
+                v_op=90,
+                v_min=0,
+                v_max=100,
+                v_scl_min=0,
+                v_scl_max=100,
+                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",
+                v_scl_min=0,
+                v_scl_max=100,
+                v_unit=Units.UNSPECIFIED.code,
+            )
+        )
+        self.add_procedure(proc_1)
+
+    # Define the user logic
+    def idle(self):
+        logger.app("- Idle -")
+        cycle = 0
+        while self.is_state("idle"):
+            logger.app(
+                f" Idle cycle={cycle}, sm.act_state={self.state_machine.act_state}"
+            )
+            cycle += 1
+            time.sleep(0.2)
+
+    def starting(self):
+        logger.app("- Starting -")
+        logger.app("  Applying procedure parameters...")
+        self.state_change()
+
+    def execute(self):
+        logger.app("- Execute -")
+        cycle = 0
+        while self.is_state("execute"):
+            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
+            )
+
+            logger.app(
+                f" {cycle}, generated_number={generated_number}, bounds={[lower_bound, upper_bound]}, cycle_time={cycle_time}s"
+            )
+
+            cycle += 1
+            time.sleep(max(0.2, cycle_time))
+
+    def completing(self):
+        self.state_change()
+
+    def completed(self):
+        pass
+
+    def pausing(self):
+        pass
+
+    def paused(self):
+        pass
+
+    def resuming(self):
+        pass
+
+    def holding(self):
+        pass
+
+    def held(self):
+        pass
+
+    def unholding(self):
+        pass
+
+    def stopping(self):
+        pass
+
+    def stopped(self):
+        pass
+
+    def aborting(self):
+        pass
+
+    def aborted(self):
+        pass
+
+    def resetting(self):
+        logger.app("- Resetting -")
+        self.state_change()
+
+
+def parse_args():
+    p = argparse.ArgumentParser("minimal PEA example")
+    p.add_argument(
+        "-l",
+        "--log-level",
+        dest="log_level",
+        default="APP",
+        type=str,
+        choices=["DEBUG", "INFO"] + CHOICES + ["WARNING", "ERROR", "CRITICAL"],
+        help="Set the logging level (default: APP)",
+    )
+    p.add_argument(
+        "--duration",
+        type=float,
+        default=10.0,
+        help="Set the duration of the execute phase",
+    )
+    p.add_argument(
+        "-e",
+        "--endpoint",
+        default="opc.tcp://localhost:4840",
+        help="Set the OPCUA endpoint (default opc.tcp://localhost:4840).",
+    )
+    p.add_argument(
+        "--daemon",
+        action="store_true",
+        default=False,
+        help="don't stop, continue to run (default: exit ).",
+    )
+    return p.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    setLogLevel(args.log_level)
+
+    # -------------------------- PEA setup --------------------------
+    # create PEA instance with specified endpoint
+    pea = PEA(endpoint=args.endpoint)
+
+    # define service and add it to the PEA
+    service_1 = RandomNumberGenerator(
+        "rand_num_gen", "This service generates random numbers"
+    )
+    pea.add_service(service_1)
+
+    # define an active element and add it to the PEA
+    pid_ctrl = PIDCtrl("pid_ctrl")
+    pea.add_data_assembly(pid_ctrl)
+
+    # Setup done, now start the PEA
+    logger.app("--- Start PEA ---")
+    pea.start()
+    time.sleep(1)
+
+    # -------------------------- POL test script --------------------------
+    from mtppy.part4.definitions.command_codes import CommandCodes as CC
+
+    opcua_server = pea.pea_opcua_server.opcua_server
+    ns_index = pea.pea_opcua_server._get_opcua_ns_index()
+    nodeid = lambda cmd: f"ns={ns_index};s={cmd}"
+    opcua_write = lambda cmd, val: opcua_server.get_node(nodeid(cmd)).set_value(val)
+
+    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)
+
+    logger.pol("--- Start service ---")
+    opcua_write("rand_num_gen.ProcedureOp", 1)
+    opcua_write("rand_num_gen.CommandOp", CC.START.code)
+    time.sleep(args.duration)
+
+    logger.pol("--- Complete service ---")
+    opcua_write("rand_num_gen.CommandOp", CC.COMPLETE.code)
+    time.sleep(1)
+
+    logger.pol("--- Reset service ---")
+    opcua_write("rand_num_gen.CommandOp", CC.RESET.code)
+
+    # -------------------------- PEA shutdown or detach --------------------------
+    if not args.daemon:
+        logger.app("--- Stop PEA ---")
+        pea.stop()
+        sys.exit(0)

mtppy/__init__.py

@@ -0,0 +1 @@
+__version__ = '2.0.0'

mtppy/part1/__init__.py

@@ -0,0 +1,4 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"

mtppy/part1/empty_folder_test.py

@@ -0,0 +1,7 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+def test_true():
+    assert True == True

mtppy/part3/__init__.py

@@ -0,0 +1,4 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"

mtppy/part3/data_assembly_set/__init__.py

@@ -0,0 +1,4 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"

mtppy/part3/data_assembly_set/active_elements/__init__.py

@@ -0,0 +1,4 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"

mtppy/part3/data_assembly_set/active_elements/active_element.py

@@ -0,0 +1,22 @@
+"""Base Class for Active Elements."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part3.data_assembly_set.base_functions.oslevel import OSLevelBaseFunction
+from mtppy.part3.data_assembly_set.base_functions.wqc import WQCBaseFunction
+
+
+class ActiveElement(DataAssembly):
+    os_level: OSLevelBaseFunction
+    wqc: WQCBaseFunction
+
+    def __init__(self, tag_name: str, tag_description: str):
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataObjectSUCLib/DataAssembly/ActiveElement"
+
+        self.os_level = OSLevelBaseFunction()
+        self.wqc = WQCBaseFunction()

mtppy/part3/data_assembly_set/active_elements/drives/__init__.py

@@ -0,0 +1,4 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"