node-red-contrib-me-vplc 1.0.0

package/project/backend/app.py

@@ -0,0 +1,839 @@
+import copy
+import json
+import math
+import zipfile
+import threading
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+
+from st_compiler import STCompiler, STProgram
+from connector_runtime import create_connector
+
+BASE_DIR = Path(__file__).resolve().parent
+PROJECTS_ROOT = BASE_DIR / "projects"
+ACTIVE_PROJECT_FILE = BASE_DIR / "active_project.json"
+DEFAULT_PROJECT_NAMES: list[str] = []
+PROJECTS_ROOT.mkdir(exist_ok=True)
+LOG_DIR = BASE_DIR / "logs"
+LOG_DIR.mkdir(exist_ok=True)
+COMPILER_LOG_FILE = LOG_DIR / "st_compiler.log"
+
+PHASES = ["READ", "EXECUTE", "WRITE", "SYNC"]
+EDITOR_TEXT_EXTENSIONS = {".st", ".json", ".txt", ".xml", ".csv", ".md", ".cfg", ".ini"}
+MAX_EDITOR_FILE_BYTES = 2_000_000
+
+
+def _safe_project_name(name: str) -> str:
+    clean = "".join(ch for ch in str(name or "").strip() if ch.isalnum() or ch in (" ", "_", "-"))
+    clean = clean.strip(" ._-")
+    if not clean:
+        clean = "Original"
+    return clean[:80]
+
+
+def _project_base_dir(project_name: str) -> Path:
+    return PROJECTS_ROOT / _safe_project_name(project_name)
+
+
+def _project_st_dir(project_name: str) -> Path:
+    return _project_base_dir(project_name) / "st_project"
+
+
+def _project_connector_dir(project_name: str) -> Path:
+    return _project_base_dir(project_name) / "connector"
+
+
+def _ensure_project_dirs(project_name: str) -> None:
+    _project_st_dir(project_name).mkdir(parents=True, exist_ok=True)
+    _project_connector_dir(project_name).mkdir(parents=True, exist_ok=True)
+
+
+def _list_projects() -> list[str]:
+    """Listet ausschließlich echte Projektordner unter backend/projects.
+
+    Es werden keine Default-Projekte mehr automatisch angelegt. Dadurch zeigt
+    das Frontend-Dropdown nur Projekte, die wirklich als Ordner im Verzeichnis
+    backend/projects vorhanden sind.
+    """
+    if not PROJECTS_ROOT.exists():
+        return []
+    return sorted([p.name for p in PROJECTS_ROOT.iterdir() if p.is_dir()], key=str.lower)
+
+
+def _bootstrap_projects() -> None:
+    # Keine künstlichen Default-Projektordner erzeugen.
+    # Quelle der Projektauswahl ist ausschließlich backend/projects/<Projektname>.
+    PROJECTS_ROOT.mkdir(exist_ok=True)
+
+
+def _read_active_project_name() -> str:
+    projects = _list_projects()
+    if ACTIVE_PROJECT_FILE.exists():
+        try:
+            data = json.loads(ACTIVE_PROJECT_FILE.read_text(encoding="utf-8"))
+            name = _safe_project_name(data.get("active_project", ""))
+            if name in projects:
+                return name
+        except Exception:
+            pass
+    if "Optimized_EFUSE-Function" in projects:
+        return "Optimized_EFUSE-Function"
+    if projects:
+        return projects[0]
+    return "Original"
+
+
+def _write_active_project_name(name: str) -> None:
+    ACTIVE_PROJECT_FILE.write_text(json.dumps({"active_project": _safe_project_name(name)}, indent=2), encoding="utf-8")
+
+
+def _first_file(directory: Path, suffixes: tuple[str, ...]) -> Optional[Path]:
+    files = sorted([p for p in directory.iterdir() if p.is_file() and p.suffix.lower() in suffixes], key=lambda item: item.name.lower())
+    return files[0] if files else None
+
+
+def _is_safe_archive_name(name: str) -> bool:
+    normalized = name.replace("\\", "/").strip()
+    return bool(normalized) and not normalized.startswith("/") and ".." not in normalized.split("/")
+
+
+def _read_editable_files(path: Path) -> list[dict[str, str]]:
+    if not path.exists():
+        raise FileNotFoundError(f"Datei nicht gefunden: {path.name}")
+
+    files: list[dict[str, str]] = []
+    if path.suffix.lower() == ".zip":
+        with zipfile.ZipFile(path, "r") as archive:
+            for info in sorted(archive.infolist(), key=lambda item: item.filename.lower()):
+                if info.is_dir():
+                    continue
+                filename = info.filename.replace("\\", "/")
+                if not _is_safe_archive_name(filename):
+                    continue
+                if Path(filename).suffix.lower() not in EDITOR_TEXT_EXTENSIONS:
+                    continue
+                if info.file_size > MAX_EDITOR_FILE_BYTES:
+                    continue
+                content = archive.read(info.filename).decode("utf-8", errors="replace")
+                files.append({"path": filename, "content": content})
+    else:
+        if path.stat().st_size > MAX_EDITOR_FILE_BYTES:
+            raise ValueError("Datei ist für den Editor zu groß.")
+        files.append({"path": path.name, "content": path.read_text(encoding="utf-8", errors="replace")})
+
+    if not files:
+        raise ValueError("Keine editierbaren Textdateien gefunden.")
+    return files
+
+
+def _write_editable_files(path: Path, files: list[dict[str, str]]) -> None:
+    clean_files: list[tuple[str, str]] = []
+    for item in files:
+        name = str(item.get("path", "")).replace("\\", "/").strip()
+        if not _is_safe_archive_name(name):
+            raise ValueError(f"Ungültiger Dateipfad: {name}")
+        if Path(name).suffix.lower() not in EDITOR_TEXT_EXTENSIONS:
+            raise ValueError(f"Dateityp darf nicht bearbeitet werden: {name}")
+        content = str(item.get("content", ""))
+        if len(content.encode("utf-8")) > MAX_EDITOR_FILE_BYTES:
+            raise ValueError(f"Datei ist zu groß: {name}")
+        clean_files.append((name, content))
+
+    if not clean_files:
+        raise ValueError("Keine Dateien zum Speichern erhalten.")
+
+    if path.suffix.lower() == ".zip":
+        tmp_path = path.with_suffix(path.suffix + ".tmp")
+        with zipfile.ZipFile(tmp_path, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+            for name, content in clean_files:
+                archive.writestr(name, content)
+        tmp_path.replace(path)
+    else:
+        # Bei Einzeldateien wird nur der erste Inhalt gespeichert.
+        path.write_text(clean_files[0][1], encoding="utf-8")
+
+
+
+@dataclass
+class PhaseStat:
+    min_ms: float = 0.0
+    avg_ms: float = 0.0
+    max_ms: float = 0.0
+    last_ms: float = 0.0
+    count: int = 0
+    window_size: int = 100
+    _samples: list[float] = field(default_factory=list, repr=False)
+
+    def update(self, value_ms: float) -> None:
+        """Aktualisiert Last/Min/Avg/Max live auf Basis der letzten 100 Zyklen.
+
+        Dadurch ändern sich Min/Avg/Max in jedem Zyklus mit und werden nicht
+        nur blockweise nach 100 Zyklen übernommen. Alte Ausreißer, z. B. frühere
+        Modbus-Timeouts, fallen nach spätestens 100 neuen Zyklen automatisch aus
+        der Anzeige heraus.
+        """
+        value_ms = round(max(0.0, float(value_ms)), 3)
+        self.last_ms = value_ms
+        self.count += 1
+        self._samples.append(value_ms)
+        if len(self._samples) > self.window_size:
+            del self._samples[0:len(self._samples) - self.window_size]
+
+        if self._samples:
+            self.min_ms = round(min(self._samples), 3)
+            self.max_ms = round(max(self._samples), 3)
+            self.avg_ms = round(sum(self._samples) / len(self._samples), 3)
+        else:
+            self.min_ms = 0.0
+            self.avg_ms = 0.0
+            self.max_ms = 0.0
+
+    def sync_window(self) -> None:
+        # Min/Avg/Max werden live rollierend berechnet. Diese Methode bleibt
+        # als Marker für die Anzeige der 100-Zyklen-Synchronisierung bestehen.
+        return
+
+    def reset(self) -> None:
+        self.min_ms = 0.0
+        self.avg_ms = 0.0
+        self.max_ms = 0.0
+        self.last_ms = 0.0
+        self.count = 0
+        self._samples.clear()
+
+    def to_dict(self) -> dict[str, float | int | bool]:
+        return {
+            "min_ms": self.min_ms,
+            "avg_ms": self.avg_ms,
+            "max_ms": self.max_ms,
+            "last_ms": self.last_ms,
+            "count": self.count,
+            "window_size": self.window_size,
+            "window_fill": len(self._samples),
+            "has_full_window": len(self._samples) >= self.window_size,
+        }
+
+
+class MEVPLC:
+    def __init__(self) -> None:
+        _bootstrap_projects()
+        self.lock = threading.RLock()
+        self.running = False
+        self.cycle_time_ms = 200
+        self.auto_cycle_enabled = False
+        self.auto_cycle_margin_percent = 20
+        self.auto_cycle_margin_ms = 2
+        self.cycle_count = 0
+        self.last_cycle_ms = 0.0
+        self.thread: Optional[threading.Thread] = None
+        self.stop_event = threading.Event()
+        self.stats_window_size = 100
+        self.last_stats_sync_cycle = 0
+        self.last_stats_sync_time = None
+        self.phase_stats: Dict[str, PhaseStat] = {phase: PhaseStat(window_size=self.stats_window_size) for phase in PHASES}
+        self.active_project = _read_active_project_name()
+        self.available_projects = _list_projects()
+        self.imported_st_project: Optional[str] = None
+        self.imported_connector: Optional[str] = None
+        self.compiled_program: Optional[STProgram] = None
+        self.st_compile_ok = False
+        self.st_compile_message = "Kein ST-Projekt importiert."
+        self.st_compiled_project: Optional[str] = None
+        self.st_compiled_file: Optional[str] = None
+        self.st_compiled_at: Optional[str] = None
+        self.compiler_log = []
+        self.connector_data: Dict[str, Any] = {}
+        self.connector_runtime = None
+        self.last_error: Optional[str] = None
+        self._load_project_assets_unlocked(self.active_project, publish=False)
+        self._snapshot: Dict[str, Any] = self._build_snapshot_unlocked()
+
+    def _active_st_dir_unlocked(self) -> Path:
+        _ensure_project_dirs(self.active_project)
+        return _project_st_dir(self.active_project)
+
+    def _active_connector_dir_unlocked(self) -> Path:
+        _ensure_project_dirs(self.active_project)
+        return _project_connector_dir(self.active_project)
+
+    def _clear_runtime_unlocked(self) -> None:
+        if self.connector_runtime is not None and hasattr(self.connector_runtime, "shutdown"):
+            try:
+                self.connector_runtime.shutdown()
+            except Exception:
+                pass
+        self.cycle_count = 0
+        self.last_cycle_ms = 0.0
+        self.last_stats_sync_cycle = 0
+        self.last_stats_sync_time = None
+        self.phase_stats = {phase: PhaseStat(window_size=self.stats_window_size) for phase in PHASES}
+        self.imported_st_project = None
+        self.imported_connector = None
+        self.compiled_program = None
+        self.st_compile_ok = False
+        self.st_compile_message = "Kein ST-Projekt importiert."
+        self.st_compiled_project = None
+        self.st_compiled_file = None
+        self.st_compiled_at = None
+        self.compiler_log = []
+        self.connector_data = {}
+        self.connector_runtime = None
+        self.last_error = None
+
+    def _compile_st_file_unlocked(self, st_file: Path) -> None:
+        # Wichtig für den Multiprojekt-Betrieb:
+        # Beim Projektwechsel darf keine alte Runtime/kein alter AST weiterverwendet werden.
+        # Deshalb wird das ST-Projekt des aktiven Projektordners immer frisch kompiliert
+        # und danach eindeutig mit Projektname + Dateiname im Status markiert.
+        self.imported_st_project = st_file.name
+        try:
+            program = STCompiler.compile_path(st_file)
+            compiler_log = list(getattr(program.compiler, "compile_log", []))
+            self._write_compiler_log_file(f"{self.active_project}/{st_file.name}", compiler_log)
+            self.compiled_program = program
+            self.st_compile_ok = True
+            self.compiler_log = compiler_log
+            self.st_compiled_project = self.active_project
+            self.st_compiled_file = st_file.name
+            self.st_compiled_at = time.strftime("%Y-%m-%d %H:%M:%S")
+            self.st_compile_message = (
+                f"IEC 61131-3 ST kompiliert: PROGRAM {program.name}, "
+                f"{len(program.variables)} Variable(n), {len(program.statements)} Anweisung(en). "
+                f"Projekt: {self.active_project}. Optimierte Runtime aktiv."
+            )
+        except Exception as exc:
+            self.compiled_program = None
+            self.st_compile_ok = False
+            self.st_compiled_project = self.active_project
+            self.st_compiled_file = st_file.name
+            self.st_compiled_at = time.strftime("%Y-%m-%d %H:%M:%S")
+            self.st_compile_message = f"ST Compile Fehler in Projekt {self.active_project}: {exc}"
+            self.compiler_log = [{"time": time.strftime("%H:%M:%S"), "level": "ERROR", "message": str(exc)}]
+
+    def _load_project_assets_unlocked(self, project_name: str, publish: bool = True) -> None:
+        self.active_project = _safe_project_name(project_name)
+        _ensure_project_dirs(self.active_project)
+        self.available_projects = _list_projects()
+        self._clear_runtime_unlocked()
+
+        st_file = _first_file(_project_st_dir(self.active_project), (".zip", ".st", ".txt", ".json"))
+        if st_file is not None:
+            self._compile_st_file_unlocked(st_file)
+
+        connector_file = _first_file(_project_connector_dir(self.active_project), (".zip", ".json", ".txt"))
+        if connector_file is not None:
+            try:
+                connector_data = self._load_connector_file(connector_file)
+                self.imported_connector = connector_file.name
+                self.connector_data = connector_data
+                self.connector_runtime = create_connector(connector_data)
+            except Exception as exc:
+                self.imported_connector = connector_file.name
+                self.connector_runtime = None
+                self.last_error = f"Connector Import Fehler: {exc}"
+
+        _write_active_project_name(self.active_project)
+        if publish:
+            self._publish_snapshot_unlocked()
+
+    def select_project(self, project_name: str) -> tuple[bool, str]:
+        clean_name = _safe_project_name(project_name)
+        with self.lock:
+            if self.running:
+                return False, "Projektwechsel ist nur bei PLC STOP möglich."
+            if clean_name not in _list_projects():
+                return False, f"Projekt nicht gefunden: {clean_name}"
+            self._load_project_assets_unlocked(clean_name, publish=True)
+            if self.imported_st_project and self.st_compile_ok:
+                return True, f"Projekt gewechselt und ST-Projekt frisch kompiliert: {clean_name}"
+            if self.imported_st_project and not self.st_compile_ok:
+                return False, f"Projekt gewechselt, aber ST-Kompilierung fehlgeschlagen: {clean_name}"
+            return True, f"Projekt gewechselt: {clean_name}"
+
+    def _load_connector_file(self, path: Path) -> Dict[str, Any]:
+        if path.suffix.lower() == ".json":
+            return json.loads(path.read_text(encoding="utf-8", errors="replace"))
+        if path.suffix.lower() == ".zip":
+            with zipfile.ZipFile(path, "r") as archive:
+                json_files = [name for name in archive.namelist() if name.lower().endswith(".json") and not name.endswith("/")]
+                if not json_files:
+                    raise ValueError("Keine .json Datei im Connector-ZIP gefunden.")
+                return json.loads(archive.read(json_files[0]).decode("utf-8", errors="replace"))
+        return json.loads(path.read_text(encoding="utf-8", errors="replace"))
+
+    def _real_cycle_avg_unlocked(self) -> float:
+        read_avg = float(self.phase_stats["READ"].avg_ms or 0.0)
+        execute_avg = float(self.phase_stats["EXECUTE"].avg_ms or 0.0)
+        write_avg = float(self.phase_stats["WRITE"].avg_ms or 0.0)
+        return round(read_avg + execute_avg + write_avg, 3)
+
+    def _suggested_cycle_time_unlocked(self) -> int:
+        real_avg = self._real_cycle_avg_unlocked()
+        if real_avg <= 0:
+            return int(self.cycle_time_ms)
+        margin_factor = 1.0 + (float(self.auto_cycle_margin_percent) / 100.0)
+        suggested = int(math.ceil((real_avg * margin_factor) + float(self.auto_cycle_margin_ms)))
+        return max(1, min(60000, suggested))
+
+    def _build_snapshot_unlocked(self) -> Dict[str, Any]:
+        return {
+            "active_project": self.active_project,
+            "projects": self.available_projects,
+            "running": self.running,
+            "can_start": self.can_start_unlocked(),
+            "cycle_time_ms": self.cycle_time_ms,
+            "auto_cycle_enabled": self.auto_cycle_enabled,
+            "auto_cycle_margin_percent": self.auto_cycle_margin_percent,
+            "real_cycle_avg_ms": self._real_cycle_avg_unlocked(),
+            "suggested_cycle_time_ms": self._suggested_cycle_time_unlocked(),
+            "cycle_count": self.cycle_count,
+            "last_cycle_ms": self.last_cycle_ms,
+            "phases": {name: stat.to_dict() for name, stat in self.phase_stats.items()},
+            "stats_window": {
+                "window_size": self.stats_window_size,
+                "last_sync_cycle": self.last_stats_sync_cycle,
+                "last_sync_time": self.last_stats_sync_time,
+                "current_window_count": min(self.cycle_count, self.stats_window_size),
+                "next_sync_cycle": ((self.cycle_count // self.stats_window_size) + 1) * self.stats_window_size,
+                "rolling_live": True,
+            },
+            "imported_st_project": self.imported_st_project,
+            "imported_connector": self.imported_connector,
+            "st_compile_ok": self.st_compile_ok,
+            "st_compile_message": self.st_compile_message,
+            "st_compiled_project": self.st_compiled_project,
+            "st_compiled_file": self.st_compiled_file,
+            "st_compiled_at": self.st_compiled_at,
+            "compiler_log": self.compiler_log[-250:],
+            "last_error": self.last_error,
+            "connector_status": self.connector_runtime.to_dict() if self.connector_runtime else None,
+        }
+
+    def _publish_snapshot_unlocked(self) -> None:
+        # Frontend/API liest nur diese fertige Kopie; keine Berechnung im Status-Request.
+        self._snapshot = self._build_snapshot_unlocked()
+
+    def can_start_unlocked(self) -> bool:
+        # Start nur sperren, wenn weder ST noch Connector vorhanden ist.
+        return self.imported_st_project is not None or self.imported_connector is not None
+
+    def can_start(self) -> bool:
+        with self.lock:
+            return self.can_start_unlocked()
+
+    def start(self) -> tuple[bool, str]:
+        with self.lock:
+            if self.running:
+                return True, "PLC läuft bereits."
+            if not self.can_start_unlocked():
+                return False, "Start nicht möglich: Kein ST-Projekt und kein Connector importiert."
+            if self.imported_st_project and not self.compiled_program:
+                return False, "Start nicht möglich: ST-Projekt ist nicht kompiliert."
+            # Statistik bei jedem PLC-Start bewusst zurücksetzen, damit alte
+            # Offline-/Timeout-Werte die aktuelle Anzeige nicht verfälschen.
+            self.cycle_count = 0
+            self.last_cycle_ms = 0.0
+            self.last_stats_sync_cycle = 0
+            self.last_stats_sync_time = None
+            self.phase_stats = {phase: PhaseStat(window_size=self.stats_window_size) for phase in PHASES}
+            if self.connector_runtime is not None and hasattr(self.connector_runtime, "force_next_write"):
+                # Beim Start Ausgänge einmal aktiv synchronisieren, auch wenn sich ST-Werte noch nicht geändert haben.
+                self.connector_runtime.force_next_write = True
+            self.running = True
+            self.last_error = None
+            self.stop_event.clear()
+            self._publish_snapshot_unlocked()
+            self.thread = threading.Thread(target=self._run_loop, daemon=True, name="ME-vPLC-Cycle")
+            self.thread.start()
+            return True, "PLC gestartet."
+
+    def stop(self) -> None:
+        with self.lock:
+            self.running = False
+            self.stop_event.set()
+            self._publish_snapshot_unlocked()
+
+    def set_cycle_time(self, value_ms: int) -> None:
+        value_ms = max(1, min(60000, int(value_ms)))
+        with self.lock:
+            self.auto_cycle_enabled = False
+            self.cycle_time_ms = value_ms
+            self._publish_snapshot_unlocked()
+
+    def set_auto_cycle(self, enabled: bool) -> None:
+        with self.lock:
+            self.auto_cycle_enabled = bool(enabled)
+            if self.auto_cycle_enabled:
+                self.cycle_time_ms = self._suggested_cycle_time_unlocked()
+            self._publish_snapshot_unlocked()
+
+    def reset_stats(self) -> None:
+        with self.lock:
+            self.cycle_count = 0
+            self.last_cycle_ms = 0.0
+            self.last_stats_sync_cycle = 0
+            self.last_stats_sync_time = None
+            self.phase_stats = {phase: PhaseStat(window_size=self.stats_window_size) for phase in PHASES}
+            self._publish_snapshot_unlocked()
+
+    def _write_compiler_log_file(self, filename: str, entries: list) -> None:
+        header = f"\n===== {time.strftime('%Y-%m-%d %H:%M:%S')} | {filename} =====\n"
+        lines = [header]
+        for entry in entries:
+            details = entry.get("details")
+            suffix = f" | {json.dumps(details, ensure_ascii=False)}" if details else ""
+            lines.append(f"[{entry.get('time', '-')}] {entry.get('level', 'INFO')}: {entry.get('message', '')}{suffix}\n")
+        COMPILER_LOG_FILE.parent.mkdir(exist_ok=True)
+        with COMPILER_LOG_FILE.open("a", encoding="utf-8") as handle:
+            handle.writelines(lines)
+
+    def import_st_project(self, path: Path, filename: str) -> None:
+        # Import/Compile außerhalb des Runtime-Zyklus. ST wird einmal kompiliert und im Zyklus nur ausgeführt.
+        try:
+            program = STCompiler.compile_path(path)
+            compiler_log = list(getattr(program.compiler, "compile_log", []))
+            self._write_compiler_log_file(filename, compiler_log)
+        except Exception as exc:
+            compiler_log = list(getattr(exc, "compile_log", []))
+            if compiler_log:
+                self._write_compiler_log_file(filename, compiler_log)
+            with self.lock:
+                self.imported_st_project = filename
+                self.compiled_program = None
+                self.st_compile_ok = False
+                self.st_compile_message = f"ST Compile Fehler: {exc}"
+                self.compiler_log = compiler_log or [{
+                    "time": time.strftime("%H:%M:%S"),
+                    "level": "ERROR",
+                    "message": str(exc),
+                }]
+                self._publish_snapshot_unlocked()
+            raise
+        with self.lock:
+            self.imported_st_project = filename
+            self.compiled_program = program
+            self.st_compile_ok = True
+            self.st_compiled_project = self.active_project
+            self.st_compiled_file = filename
+            self.st_compiled_at = time.strftime("%Y-%m-%d %H:%M:%S")
+            self.compiler_log = compiler_log
+            self.st_compile_message = (
+                f"IEC 61131-3 ST kompiliert: PROGRAM {program.name}, "
+                f"{len(program.variables)} Variable(n), {len(program.statements)} Anweisung(en). "
+                f"Projekt: {self.active_project}. Optimierte Runtime aktiv."
+            )
+            self._publish_snapshot_unlocked()
+
+    def import_connector(self, path: Path, filename: str) -> None:
+        connector_data = self._load_connector_file(path)
+        with self.lock:
+            if self.connector_runtime is not None and hasattr(self.connector_runtime, "shutdown"):
+                try:
+                    self.connector_runtime.shutdown()
+                except Exception:
+                    pass
+            self.imported_connector = filename
+            self.connector_data = connector_data
+            self.connector_runtime = create_connector(connector_data)
+            self._publish_snapshot_unlocked()
+
+    def _measure_read(self, connector_runtime: Any, program: Optional[STProgram]) -> float:
+        if connector_runtime is None or program is None:
+            return 0.0
+        start = time.perf_counter()
+        connector_runtime.read_cycle(program)
+        return (time.perf_counter() - start) * 1000.0
+
+    def _measure_execute(self, program: Optional[STProgram]) -> float:
+        if program is None:
+            return 0.0
+        start = time.perf_counter()
+        program.execute()
+        return (time.perf_counter() - start) * 1000.0
+
+    def _measure_write(self, connector_runtime: Any, program: Optional[STProgram]) -> float:
+        if connector_runtime is None or program is None:
+            return 0.0
+        start = time.perf_counter()
+        connector_runtime.write_cycle(program)
+        return (time.perf_counter() - start) * 1000.0
+
+    def _run_loop(self) -> None:
+        while not self.stop_event.is_set():
+            cycle_start = time.perf_counter()
+            with self.lock:
+                connector_runtime = self.connector_runtime
+                program = self.compiled_program
+                target_ms = self.cycle_time_ms
+
+            try:
+                read_ms = self._measure_read(connector_runtime, program)
+                execute_ms = self._measure_execute(program)
+                write_ms = self._measure_write(connector_runtime, program)
+
+                elapsed_before_sync_ms = (time.perf_counter() - cycle_start) * 1000.0
+                requested_sync_ms = max(0.0, target_ms - elapsed_before_sync_ms)
+                sync_start = time.perf_counter()
+                if requested_sync_ms > 0:
+                    time.sleep(requested_sync_ms / 1000.0)
+                sync_ms = (time.perf_counter() - sync_start) * 1000.0
+
+                cycle_elapsed_ms = (time.perf_counter() - cycle_start) * 1000.0
+                with self.lock:
+                    self.phase_stats["READ"].update(read_ms)
+                    self.phase_stats["EXECUTE"].update(execute_ms)
+                    self.phase_stats["WRITE"].update(write_ms)
+                    self.phase_stats["SYNC"].update(sync_ms)
+                    next_cycle = self.cycle_count + 1
+                    if next_cycle % self.stats_window_size == 0:
+                        for stat in self.phase_stats.values():
+                            stat.sync_window()
+                        self.last_stats_sync_cycle = next_cycle
+                        self.last_stats_sync_time = time.strftime("%H:%M:%S")
+                    self.cycle_count = next_cycle
+                    self.last_cycle_ms = round(cycle_elapsed_ms, 3)
+                    if self.auto_cycle_enabled and self.cycle_count >= 5:
+                        self.cycle_time_ms = self._suggested_cycle_time_unlocked()
+                    self._publish_snapshot_unlocked()
+            except Exception as exc:
+                with self.lock:
+                    self.last_error = str(exc)
+                    self.compiler_log.append({
+                        "time": time.strftime("%H:%M:%S"),
+                        "level": "ERROR",
+                        "message": "Runtime-Fehler im PLC-Zyklus",
+                        "details": {"error": str(exc), "cycle": self.cycle_count},
+                    })
+                    self.running = False
+                    self.stop_event.set()
+                    self._publish_snapshot_unlocked()
+
+    def status(self) -> Dict[str, Any]:
+        with self.lock:
+            return copy.deepcopy(self._snapshot)
+
+
+plc = MEVPLC()
+app = Flask(__name__)
+CORS(app)
+
+
+def _reject_when_running(action: str):
+    payload = plc.status()
+    if payload.get("running"):
+        payload["error"] = f"{action} ist nur bei PLC STOP möglich."
+        return jsonify(payload), 409
+    return None
+
+
+@app.get("/api/status")
+def api_status():
+    return jsonify(plc.status())
+
+
+@app.post("/api/start")
+def api_start():
+    ok, message = plc.start()
+    payload = plc.status()
+    payload["message"] = message
+    if not ok:
+        return jsonify(payload), 400
+    return jsonify(payload)
+
+
+@app.post("/api/stop")
+def api_stop():
+    plc.stop()
+    return jsonify(plc.status())
+
+
+@app.post("/api/cycle-time")
+def api_cycle_time():
+    blocked = _reject_when_running("PLC Cycle Time ändern")
+    if blocked:
+        return blocked
+    data = request.get_json(force=True, silent=True) or {}
+    plc.set_cycle_time(int(data.get("cycle_time_ms", 200)))
+    return jsonify(plc.status())
+
+
+@app.post("/api/reset-stats")
+def api_reset_stats():
+    blocked = _reject_when_running("Statistik zurücksetzen")
+    if blocked:
+        return blocked
+    plc.reset_stats()
+    return jsonify(plc.status())
+
+
+@app.post("/api/auto-cycle")
+def api_auto_cycle():
+    blocked = _reject_when_running("Auto-Zyklus ändern")
+    if blocked:
+        return blocked
+    data = request.get_json(force=True, silent=True) or {}
+    plc.set_auto_cycle(bool(data.get("enabled", False)))
+    return jsonify(plc.status())
+
+
+@app.post("/api/import/st-project")
+def api_import_st_project():
+    blocked = _reject_when_running("ST-Projekt importieren")
+    if blocked:
+        return blocked
+    file = request.files.get("file")
+    if not file:
+        return jsonify({"error": "Keine Datei hochgeladen."}), 400
+    with plc.lock:
+        target_dir = plc._active_st_dir_unlocked()
+        for existing in target_dir.iterdir():
+            if existing.is_file():
+                existing.unlink()
+        target = target_dir / file.filename
+    file.save(target)
+    try:
+        plc.import_st_project(target, file.filename)
+    except Exception as exc:
+        return jsonify({"error": f"ST Import/Compile Fehler: {exc}"}), 400
+    return jsonify(plc.status())
+
+
+@app.post("/api/import/connector")
+def api_import_connector():
+    blocked = _reject_when_running("PLC Connector importieren")
+    if blocked:
+        return blocked
+    file = request.files.get("file")
+    if not file:
+        return jsonify({"error": "Keine Datei hochgeladen."}), 400
+    with plc.lock:
+        target_dir = plc._active_connector_dir_unlocked()
+        for existing in target_dir.iterdir():
+            if existing.is_file():
+                existing.unlink()
+        target = target_dir / file.filename
+    file.save(target)
+    try:
+        plc.import_connector(target, file.filename)
+    except Exception as exc:
+        return jsonify({"error": f"Connector Import Fehler: {exc}"}), 400
+    return jsonify(plc.status())
+
+
+@app.get("/api/editor/st-project")
+def api_editor_get_st_project():
+    with plc.lock:
+        if plc.running:
+            return jsonify({"error": "ST-Projekt kann nur bei PLC STOP editiert werden."}), 409
+        filename = plc.imported_st_project
+    if not filename:
+        return jsonify({"error": "Kein ST-Projekt importiert."}), 404
+    try:
+        path = plc._active_st_dir_unlocked() / filename
+        files = _read_editable_files(path)
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 400
+    return jsonify({"kind": "st-project", "filename": filename, "files": files})
+
+
+@app.post("/api/editor/st-project")
+def api_editor_save_st_project():
+    with plc.lock:
+        if plc.running:
+            return jsonify({"error": "ST-Projekt kann nur bei PLC STOP gespeichert werden."}), 409
+        filename = plc.imported_st_project
+    if not filename:
+        return jsonify({"error": "Kein ST-Projekt importiert."}), 404
+    data = request.get_json(force=True, silent=True) or {}
+    with plc.lock:
+        target = plc._active_st_dir_unlocked() / filename
+    try:
+        _write_editable_files(target, data.get("files", []))
+        plc.import_st_project(target, filename)
+    except Exception as exc:
+        return jsonify({"error": f"ST-Projekt konnte nicht gespeichert/kompiliert werden: {exc}"}), 400
+    return jsonify(plc.status())
+
+
+@app.get("/api/editor/connector")
+def api_editor_get_connector():
+    with plc.lock:
+        if plc.running:
+            return jsonify({"error": "PLC Connector kann nur bei PLC STOP editiert werden."}), 409
+        filename = plc.imported_connector
+    if not filename:
+        return jsonify({"error": "Kein PLC Connector importiert."}), 404
+    try:
+        path = plc._active_connector_dir_unlocked() / filename
+        files = _read_editable_files(path)
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 400
+    return jsonify({"kind": "connector", "filename": filename, "files": files})
+
+
+@app.post("/api/editor/connector")
+def api_editor_save_connector():
+    with plc.lock:
+        if plc.running:
+            return jsonify({"error": "PLC Connector kann nur bei PLC STOP gespeichert werden."}), 409
+        filename = plc.imported_connector
+    if not filename:
+        return jsonify({"error": "Kein PLC Connector importiert."}), 404
+    data = request.get_json(force=True, silent=True) or {}
+    with plc.lock:
+        target = plc._active_connector_dir_unlocked() / filename
+    try:
+        _write_editable_files(target, data.get("files", []))
+        plc.import_connector(target, filename)
+    except Exception as exc:
+        return jsonify({"error": f"PLC Connector konnte nicht gespeichert werden: {exc}"}), 400
+    return jsonify(plc.status())
+
+
+@app.get("/api/compiler-log")
+def api_compiler_log():
+    return jsonify({"compiler_log": plc.status().get("compiler_log", [])})
+
+
+@app.get("/api/projects")
+def api_projects():
+    payload = plc.status()
+    return jsonify({
+        "active_project": payload.get("active_project"),
+        "projects": payload.get("projects", []),
+    })
+
+
+@app.post("/api/projects/select")
+def api_select_project():
+    data = request.get_json(force=True, silent=True) or {}
+    ok, message = plc.select_project(data.get("project", ""))
+    payload = plc.status()
+    payload["message"] = message
+    if not ok:
+        return jsonify(payload), 400
+    return jsonify(payload)
+
+
+@app.get("/api/imported")
+def api_imported():
+    with plc.lock:
+        st_dir = plc._active_st_dir_unlocked()
+        connector_dir = plc._active_connector_dir_unlocked()
+    return jsonify({
+        "active_project": plc.status().get("active_project"),
+        "projects": plc.status().get("projects", []),
+        "st_project_files": sorted([p.name for p in st_dir.iterdir() if p.is_file()]),
+        "connector_files": sorted([p.name for p in connector_dir.iterdir() if p.is_file()]),
+    })
+
+
+if __name__ == "__main__":
+    # Debug bewusst deaktiviert, damit Flask-ReLoader/Trace den PLC-Zyklus nicht verfälscht.
+    import os
+    app.run(host="0.0.0.0", port=int(os.environ.get("ME_VPLC_PORT", "5000")), debug=False, threaded=True)