node-red-contrib-me-vplc 1.0.0

package/project/backend/connector_runtime.py

@@ -0,0 +1,585 @@
+"""Connector-Runtime für ME vPLC.
+
+Aktuell umgesetzt: Modbus TCP Connector gemäß JSON-Struktur aus example_connector.zip.
+- READ-Variablen werden vor EXECUTE in das ST-Prozessabbild geschrieben.
+- WRITE-Variablen werden nach EXECUTE aus dem ST-Prozessabbild gelesen und an Modbus geschrieben.
+- Modbus-Requests werden nach Registertyp und zusammenhängenden Adressen gebündelt.
+- Coils werden nur geschrieben, wenn sich Werte geändert haben.
+- Bei Kommunikationsfehlern wird nicht der PLC-Zyklus beendet; der Connector geht offline und versucht nach Backoff erneut zu verbinden.
+"""
+
+from __future__ import annotations
+
+import math
+import struct
+import threading
+import time
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+
+try:  # pymodbus >= 3.x
+    from pymodbus.client import ModbusTcpClient  # type: ignore
+except Exception:  # pragma: no cover - fallback für ältere pymodbus-Versionen
+    try:
+        from pymodbus.client.sync import ModbusTcpClient  # type: ignore
+    except Exception:  # pragma: no cover
+        ModbusTcpClient = None  # type: ignore
+
+
+class ConnectorError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class ConnectorVariable:
+    name: str
+    direction: str
+    register_type: str
+    data_type: str
+    address: int
+    word_count: int = 1
+
+
+@dataclass
+class ConnectorStatus:
+    configured: bool = False
+    type: str = "-"
+    name: str = "-"
+    endpoint: str = "-"
+    connected: bool = False
+    mode: str = "-"
+    read_variables: int = 0
+    write_variables: int = 0
+    read_requests: int = 0  # letzter Zyklus
+    write_requests: int = 0  # letzter Zyklus
+    skipped_writes: int = 0  # letzter Zyklus
+    total_read_requests: int = 0
+    total_write_requests: int = 0
+    total_skipped_writes: int = 0
+    last_write_changed: bool = False
+    last_write_reason: str = "-"
+    write_resync_ms: int = 1000
+    error_count: int = 0
+    last_error: Optional[str] = None
+    last_read_ms: float = 0.0
+    last_write_ms: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = asdict(self)
+        data["last_read_ms"] = round(float(self.last_read_ms), 3)
+        data["last_write_ms"] = round(float(self.last_write_ms), 3)
+        return data
+
+
+class STPathAccessor:
+    """Löst Connector-Namen wie CSC_BCM_BatteryTemp1 auf ST-Pfade wie CSC.BCM.BatteryTemp1 auf."""
+
+    @staticmethod
+    def _keys(obj: Any) -> Optional[Dict[str, Any]]:
+        if isinstance(obj, dict):
+            return obj
+        vars_dict = getattr(obj, "_vars", None)
+        if isinstance(vars_dict, dict):
+            return vars_dict
+        # STStruct aus dem ST-Compiler speichert seine Felder in _values.
+        # Damit können Connector-Pfade wie CSC_EFuseControl_CTL1 auch auf
+        # reine PROGRAM/TYPE-Strukturen ohne FunctionBlocks aufgelöst werden.
+        values_dict = getattr(obj, "_values", None)
+        if isinstance(values_dict, dict):
+            return values_dict
+        return None
+
+    @staticmethod
+    def _find_key(obj: Any, key: str) -> Optional[str]:
+        data = STPathAccessor._keys(obj)
+        if data is None:
+            return None
+        key_upper = key.upper()
+        for existing in data.keys():
+            if existing.upper() == key_upper:
+                return existing
+        return None
+
+    @staticmethod
+    def _get_child(obj: Any, key: str) -> Any:
+        data = STPathAccessor._keys(obj)
+        real_key = STPathAccessor._find_key(obj, key)
+        if data is not None and real_key is not None:
+            return data[real_key]
+        return getattr(obj, key)
+
+    @staticmethod
+    def _set_child(obj: Any, key: str, value: Any) -> None:
+        data = STPathAccessor._keys(obj)
+        real_key = STPathAccessor._find_key(obj, key)
+        if data is not None:
+            data[real_key or key] = value
+            # Falls das Objekt eine vorbereitete ST-Runtime-Umgebung besitzt, synchron halten.
+            runtime = getattr(obj, "_runtime", None)
+            env = getattr(runtime, "env", None)
+            if isinstance(env, dict):
+                env[real_key or key] = value
+                env[(real_key or key).upper()] = value
+            return
+        setattr(obj, real_key or key, value)
+
+    @staticmethod
+    def _resolve_parent(program: Any, flat_name: str) -> Tuple[Any, str]:
+        root = getattr(program, "variables", program)
+        parts = [p for p in flat_name.split("_") if p]
+        if not parts:
+            raise ConnectorError(f"Leerer Connector-Variablenname: {flat_name}")
+        current: Any = root
+        index = 0
+        while index < len(parts) - 1:
+            # Greedy: unterstützt auch ST-Namen mit Unterstrichen.
+            found = None
+            found_end = None
+            for end in range(len(parts), index, -1):
+                candidate = "_".join(parts[index:end])
+                if STPathAccessor._find_key(current, candidate) is not None:
+                    found = candidate
+                    found_end = end
+                    break
+            if found is None or found_end is None:
+                raise ConnectorError(f"ST-Pfad nicht gefunden für Connector-Variable '{flat_name}' bei '{'_'.join(parts[index:])}'.")
+            current = STPathAccessor._get_child(current, found)
+            index = found_end
+        return current, parts[-1]
+
+    @staticmethod
+    def set_value(program: Any, flat_name: str, value: Any) -> None:
+        parent, leaf = STPathAccessor._resolve_parent(program, flat_name)
+        STPathAccessor._set_child(parent, leaf, value)
+
+    @staticmethod
+    def get_value(program: Any, flat_name: str) -> Any:
+        parent, leaf = STPathAccessor._resolve_parent(program, flat_name)
+        return STPathAccessor._get_child(parent, leaf)
+
+
+def _word_count(data_type: str) -> int:
+    dt = data_type.upper()
+    if dt in {"DINT", "UDINT", "DWORD", "REAL", "LREAL"}:
+        return 2
+    return 1
+
+
+def _bool(value: Any) -> bool:
+    if isinstance(value, str):
+        return value.strip().upper() in {"1", "TRUE", "ON", "YES"}
+    return bool(value)
+
+
+def _signed16(value: int) -> int:
+    value &= 0xFFFF
+    return value - 0x10000 if value & 0x8000 else value
+
+
+def _signed32(value: int) -> int:
+    value &= 0xFFFFFFFF
+    return value - 0x100000000 if value & 0x80000000 else value
+
+
+def _decode_registers(registers: Sequence[int], data_type: str, byte_order: str = "BigEndian", word_swap: bool = False) -> Any:
+    dt = data_type.upper()
+    regs = [int(r) & 0xFFFF for r in registers]
+    if word_swap and len(regs) >= 2:
+        regs = list(reversed(regs))
+    if dt in {"INT", "SINT"}:
+        return _signed16(regs[0])
+    if dt in {"UINT", "WORD", "BYTE"}:
+        return regs[0]
+    if dt in {"DINT"}:
+        return _signed32((regs[0] << 16) | regs[1])
+    if dt in {"UDINT", "DWORD"}:
+        return ((regs[0] << 16) | regs[1]) & 0xFFFFFFFF
+    if dt in {"REAL", "LREAL"}:
+        raw = struct.pack(">HH", regs[0], regs[1])
+        return float(struct.unpack(">f", raw)[0])
+    return regs[0]
+
+
+def _encode_registers(value: Any, data_type: str, word_swap: bool = False) -> List[int]:
+    dt = data_type.upper()
+    if dt in {"INT", "UINT", "WORD", "BYTE", "SINT"}:
+        regs = [int(value) & 0xFFFF]
+    elif dt in {"DINT", "UDINT", "DWORD"}:
+        raw = int(value) & 0xFFFFFFFF
+        regs = [(raw >> 16) & 0xFFFF, raw & 0xFFFF]
+    elif dt in {"REAL", "LREAL"}:
+        raw = struct.pack(">f", float(value))
+        regs = list(struct.unpack(">HH", raw))
+    else:
+        regs = [int(value) & 0xFFFF]
+    if word_swap and len(regs) >= 2:
+        regs = list(reversed(regs))
+    return regs
+
+
+def _make_variables(config: Dict[str, Any]) -> List[ConnectorVariable]:
+    result: List[ConnectorVariable] = []
+    for item in config.get("variables", []):
+        name = str(item.get("name", "")).strip()
+        if not name:
+            continue
+        data_type = str(item.get("dataType", "BOOL")).strip().upper()
+        result.append(
+            ConnectorVariable(
+                name=name,
+                direction=str(item.get("direction", "READ")).strip().upper(),
+                register_type=str(item.get("registerType", "Coil")).strip(),
+                data_type=data_type,
+                address=int(item.get("address", 0)),
+                word_count=_word_count(data_type),
+            )
+        )
+    return result
+
+
+def _group_contiguous(variables: Iterable[ConnectorVariable]) -> List[List[ConnectorVariable]]:
+    ordered = sorted(variables, key=lambda item: item.address)
+    groups: List[List[ConnectorVariable]] = []
+    current: List[ConnectorVariable] = []
+    next_addr: Optional[int] = None
+    for var in ordered:
+        if not current or next_addr is None or var.address == next_addr:
+            current.append(var)
+        else:
+            groups.append(current)
+            current = [var]
+        next_addr = var.address + max(1, var.word_count)
+    if current:
+        groups.append(current)
+    return groups
+
+
+class ModbusTCPConnector:
+    """Modbus TCP Connector mit entkoppeltem Worker.
+
+    Wichtiger Grundsatz:
+    - PLC READ/WRITE greifen nur auf lokale Caches zu und blockieren nicht.
+    - Alle echten Modbus/TCP-Zugriffe laufen ausschließlich im Worker-Thread.
+    """
+
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self.config = config
+        self.ip = str(config.get("ip") or config.get("host") or "127.0.0.1")
+        self.port = int(config.get("port", 502))
+        self.timeout = max(0.05, float(config.get("requestTimeoutMs", 250)) / 1000.0)
+        self.poll_period_ms = max(10, int(config.get("pollPeriodMs", 100)))
+        unit = config.get("unit", {}) if isinstance(config.get("unit"), dict) else {}
+        self.unit_id = int(unit.get("address", config.get("unitId", 1)))
+        self.byte_order = str(unit.get("byteOrder", "BigEndian"))
+        self.word_swap = bool(unit.get("wordSwap", False))
+        self.mode = str(config.get("mode", "REAL_MODBUS_TCP"))
+        self.variables = _make_variables(config)
+        self.read_variables = [v for v in self.variables if v.direction == "READ"]
+        self.write_variables = [v for v in self.variables if v.direction == "WRITE"]
+        self.client: Any = None
+        self.last_write_values: Dict[Tuple[str, int], Any] = {}
+        self.force_next_write = True
+        self.write_resync_ms = int(config.get("writeResyncMs", config.get("writeResyncPeriodMs", 1000)))
+        self.last_write_resync_at = 0.0
+        self.next_retry_at = 0.0
+        self.offline_backoff_s = 1.0
+        self.max_offline_backoff_s = 10.0
+        self.status = ConnectorStatus(
+            configured=True,
+            type=str(config.get("type", "ModbusTCP")),
+            name=str(config.get("name", "ModbusTCP")),
+            endpoint=f"{self.ip}:{self.port}/unit {self.unit_id}",
+            mode=self.mode,
+            read_variables=len(self.read_variables),
+            write_variables=len(self.write_variables),
+            write_resync_ms=self.write_resync_ms,
+        )
+        self.lock = threading.RLock()
+        self.input_cache: Dict[str, Any] = {}
+        self.output_cache: Dict[str, Any] = {}
+        self.output_dirty = True
+        self.worker_read_requests = 0
+        self.worker_write_requests = 0
+        self.worker_skipped_writes = 0
+        self.worker_stop = threading.Event()
+        self.worker_thread = threading.Thread(target=self._worker_loop, daemon=True, name="ME-vPLC-Modbus-Worker")
+        self.worker_thread.start()
+
+    def close(self) -> None:
+        if self.client is not None:
+            try:
+                self.client.close()
+            except Exception:
+                pass
+        self.client = None
+        with self.lock:
+            self.status.connected = False
+
+    def shutdown(self) -> None:
+        self.worker_stop.set()
+        self.close()
+
+    def _mark_error(self, message: str) -> None:
+        with self.lock:
+            self.status.error_count += 1
+            self.status.last_error = message
+            self.status.connected = False
+            self.force_next_write = True
+            self.next_retry_at = time.monotonic() + self.offline_backoff_s
+            self.offline_backoff_s = min(self.max_offline_backoff_s, self.offline_backoff_s * 2.0)
+        self.close()
+
+    def _ensure_connected(self) -> bool:
+        if ModbusTcpClient is None:
+            self._mark_error("pymodbus ist nicht installiert. Bitte Backend-Requirements installieren.")
+            return False
+        if str(self.mode).upper() in {"SIM", "SIMULATED", "OFFLINE"}:
+            with self.lock:
+                self.status.connected = False
+            return False
+        if self.client is not None:
+            try:
+                if getattr(self.client, "connected", True):
+                    with self.lock:
+                        self.status.connected = True
+                    return True
+            except Exception:
+                return True
+        with self.lock:
+            if time.monotonic() < self.next_retry_at:
+                return False
+        try:
+            self.client = ModbusTcpClient(self.ip, port=self.port, timeout=self.timeout)
+            ok = bool(self.client.connect())
+            with self.lock:
+                self.status.connected = ok
+            if ok:
+                with self.lock:
+                    self.offline_backoff_s = 1.0
+                    self.status.last_error = None
+                    self.force_next_write = True
+                return True
+            self._mark_error(f"Modbus-Verbindung fehlgeschlagen: {self.ip}:{self.port}")
+            return False
+        except Exception as exc:
+            self._mark_error(str(exc))
+            return False
+
+    def _call(self, method_name: str, *args: Any, **kwargs: Any) -> Any:
+        if self.client is None:
+            raise ConnectorError("Modbus-Client ist nicht verbunden.")
+        method = getattr(self.client, method_name)
+        try:
+            return method(*args, slave=self.unit_id, **kwargs)
+        except TypeError:
+            return method(*args, unit=self.unit_id, **kwargs)
+
+    @staticmethod
+    def _response_error(response: Any) -> Optional[str]:
+        if response is None:
+            return "Keine Modbus-Antwort."
+        is_error = getattr(response, "isError", None)
+        if callable(is_error) and is_error():
+            return str(response)
+        return None
+
+    def read_cycle(self, program: Any) -> None:
+        """PLC READ-Phase: nur Cache in das ST-Prozessabbild kopieren."""
+        start = time.perf_counter()
+        with self.lock:
+            cache = dict(self.input_cache)
+        for name, value in cache.items():
+            try:
+                STPathAccessor.set_value(program, name, value)
+            except Exception:
+                # Mappingfehler dürfen den PLC-Zyklus nicht blockieren.
+                pass
+        with self.lock:
+            # PLC-Phase zeigt bewusst keine Modbus-Requests; diese laufen im Worker.
+            self.status.last_read_ms = (time.perf_counter() - start) * 1000.0
+
+    def write_cycle(self, program: Any) -> None:
+        """PLC WRITE-Phase: nur ST-Ausgänge in den Ausgangs-Cache übernehmen."""
+        start = time.perf_counter()
+        next_outputs: Dict[str, Any] = {}
+        for var in self.write_variables:
+            try:
+                next_outputs[var.name] = STPathAccessor.get_value(program, var.name)
+            except Exception:
+                pass
+        with self.lock:
+            if next_outputs != self.output_cache:
+                self.output_cache = next_outputs
+                self.output_dirty = True
+            self.status.last_write_ms = (time.perf_counter() - start) * 1000.0
+
+    def _worker_loop(self) -> None:
+        while not self.worker_stop.is_set():
+            loop_start = time.perf_counter()
+            if self._ensure_connected():
+                self._worker_read()
+                self._worker_write()
+            elapsed_ms = (time.perf_counter() - loop_start) * 1000.0
+            sleep_ms = max(10.0, float(self.poll_period_ms) - elapsed_ms)
+            self.worker_stop.wait(sleep_ms / 1000.0)
+
+    def _worker_read(self) -> None:
+        start = time.perf_counter()
+        local_cache: Dict[str, Any] = {}
+        read_requests = 0
+        if not self.read_variables:
+            with self.lock:
+                self.status.read_requests = 0
+            return
+        try:
+            by_type: Dict[str, List[ConnectorVariable]] = {}
+            for var in self.read_variables:
+                by_type.setdefault(var.register_type.lower(), []).append(var)
+            for reg_type, vars_of_type in by_type.items():
+                for group in _group_contiguous(vars_of_type):
+                    first = group[0].address
+                    last = max(v.address + max(1, v.word_count) for v in group)
+                    count = last - first
+                    if reg_type == "discreteinput":
+                        response = self._call("read_discrete_inputs", first, count)
+                        err = self._response_error(response)
+                        if err:
+                            raise ConnectorError(err)
+                        bits = list(getattr(response, "bits", []))
+                        for var in group:
+                            local_cache[var.name] = bool(bits[var.address - first])
+                    elif reg_type == "coil":
+                        response = self._call("read_coils", first, count)
+                        err = self._response_error(response)
+                        if err:
+                            raise ConnectorError(err)
+                        bits = list(getattr(response, "bits", []))
+                        for var in group:
+                            local_cache[var.name] = bool(bits[var.address - first])
+                    elif reg_type == "inputregister":
+                        response = self._call("read_input_registers", first, count)
+                        err = self._response_error(response)
+                        if err:
+                            raise ConnectorError(err)
+                        regs = list(getattr(response, "registers", []))
+                        for var in group:
+                            offset = var.address - first
+                            local_cache[var.name] = _decode_registers(regs[offset:offset + var.word_count], var.data_type, self.byte_order, self.word_swap)
+                    elif reg_type == "holdingregister":
+                        response = self._call("read_holding_registers", first, count)
+                        err = self._response_error(response)
+                        if err:
+                            raise ConnectorError(err)
+                        regs = list(getattr(response, "registers", []))
+                        for var in group:
+                            offset = var.address - first
+                            local_cache[var.name] = _decode_registers(regs[offset:offset + var.word_count], var.data_type, self.byte_order, self.word_swap)
+                    else:
+                        raise ConnectorError(f"Nicht unterstützter Registertyp für READ: {reg_type}")
+                    read_requests += 1
+            with self.lock:
+                self.input_cache.update(local_cache)
+                self.status.read_requests = read_requests
+                self.status.total_read_requests += read_requests
+                self.status.last_read_ms = (time.perf_counter() - start) * 1000.0
+                self.status.connected = True
+                self.status.last_error = None
+        except Exception as exc:
+            self._mark_error(str(exc))
+            with self.lock:
+                self.status.last_read_ms = (time.perf_counter() - start) * 1000.0
+
+    def _worker_write(self) -> None:
+        start = time.perf_counter()
+        with self.lock:
+            outputs = dict(self.output_cache)
+            dirty = bool(self.output_dirty or self.force_next_write)
+        write_requests = 0
+        skipped_writes = 0
+        if not self.write_variables:
+            return
+        try:
+            now = time.monotonic()
+            due_resync = False
+            if self.write_resync_ms > 0:
+                due_resync = (now - self.last_write_resync_at) * 1000.0 >= self.write_resync_ms
+            force_write = dirty or due_resync
+            last_write_changed = False
+            last_write_reason = "-"
+
+            by_type: Dict[str, List[ConnectorVariable]] = {}
+            for var in self.write_variables:
+                by_type.setdefault(var.register_type.lower(), []).append(var)
+            for reg_type, vars_of_type in by_type.items():
+                for group in _group_contiguous(vars_of_type):
+                    first = group[0].address
+                    if reg_type == "coil":
+                        values = [_bool(outputs.get(var.name, False)) for var in group]
+                        key = ("coil", first)
+                        changed = self.last_write_values.get(key) != values
+                        if not changed and not force_write:
+                            skipped_writes += 1
+                            continue
+                        response = self._call("write_coils", first, values)
+                        err = self._response_error(response)
+                        if err:
+                            raise ConnectorError(err)
+                        self.last_write_values[key] = list(values)
+                        last_write_changed = changed
+                        last_write_reason = "changed" if changed else "resync"
+                    elif reg_type == "holdingregister":
+                        regs: List[int] = []
+                        for var in group:
+                            regs.extend(_encode_registers(outputs.get(var.name, 0), var.data_type, self.word_swap))
+                        key = ("holdingregister", first)
+                        changed = self.last_write_values.get(key) != regs
+                        if not changed and not force_write:
+                            skipped_writes += 1
+                            continue
+                        response = self._call("write_registers", first, regs)
+                        err = self._response_error(response)
+                        if err:
+                            raise ConnectorError(err)
+                        self.last_write_values[key] = list(regs)
+                        last_write_changed = changed
+                        last_write_reason = "changed" if changed else "resync"
+                    else:
+                        raise ConnectorError(f"Nicht unterstützter Registertyp für WRITE: {reg_type}")
+                    write_requests += 1
+            with self.lock:
+                self.status.write_requests = write_requests
+                self.status.skipped_writes = skipped_writes
+                self.status.total_write_requests += write_requests
+                self.status.total_skipped_writes += skipped_writes
+                self.status.last_write_changed = last_write_changed
+                self.status.last_write_reason = last_write_reason
+                self.status.last_write_ms = (time.perf_counter() - start) * 1000.0
+                self.status.connected = True
+                self.status.last_error = None
+                if force_write:
+                    self.force_next_write = False
+                    self.output_dirty = False
+                    self.last_write_resync_at = now
+        except Exception as exc:
+            self._mark_error(str(exc))
+            with self.lock:
+                self.status.last_write_ms = (time.perf_counter() - start) * 1000.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        with self.lock:
+            data = self.status.to_dict()
+            data["worker_decoupled"] = True
+            data["poll_period_ms"] = self.poll_period_ms
+            data["input_cache_values"] = len(self.input_cache)
+            data["output_cache_values"] = len(self.output_cache)
+            retry_in = max(0.0, self.next_retry_at - time.monotonic())
+            data["retry_in_s"] = round(retry_in, 1)
+            return data
+
+def create_connector(config: Dict[str, Any]) -> Optional[ModbusTCPConnector]:
+    if not isinstance(config, dict) or not config:
+        return None
+    connector_type = str(config.get("type", "")).strip().lower()
+    if connector_type in {"modbustcp", "modbus_tcp", "modbus-tcp", ""}:
+        return ModbusTCPConnector(config)
+    raise ConnectorError(f"Connector-Typ nicht unterstützt: {config.get('type')}")

package/project/backend/requirements.txt

@@ -0,0 +1,3 @@
+Flask==3.0.3
+flask-cors==4.0.1
+pymodbus==3.6.9