EUT-Überwachung verwenden und erweitern ======================================== EUT-Überwachung ist Bestandteil jeder Störfestigkeitsprüfung. mpylab trennt dabei drei Verantwortungen: * Monitore beobachten den Prüfling und liefern strukturierte Ereignisse. * Der Messkernel entscheidet über Fortsetzen, Wiederholen oder Abbruch. * Der Mess-Worker führt Sicherheitsaktionen wie RF-Off unmittelbar aus. Ein Monitor greift deshalb nicht direkt auf ``MGraph`` oder HF-Geräte zu. Manuelle Intervention bleibt auch bei automatischer Überwachung verfügbar. Die vollständige :doc:`Ereignisstruktur und Bewertung <../results/immunity-results>` ist separat dokumentiert. Vorhandene Messklassen verwenden -------------------------------- ``MSC.Measure_Immunity`` und ``TEMCell.Measure_Immunity`` akzeptieren dieselben grundlegenden Parameter: ``eut_monitor`` Ein automatischer ``EUTMonitor`` oder eine Folge von Monitoren. ``manual_eut_monitor`` Optionaler manueller Monitor einer UI. Ohne Angabe erzeugt die Messklasse eine tastaturgestützte Rückfallebene. ``performance_criterion`` Leistungskriterium ``"A"``, ``"B"`` oder ``"C"``: * **A:** Das EUT muss während und nach der Exposition ohne unzulässige Beeinträchtigung bestimmungsgemäß arbeiten. * **B:** Eine vorübergehende Beeinträchtigung während der Exposition ist zulässig. Danach muss das EUT selbsttätig wieder normal arbeiten; Betriebsart und gespeicherte Daten dürfen nicht verloren gehen. * **C:** Ein vorübergehender Funktionsausfall ist zulässig. Die normale Funktion darf sich selbsttätig, durch Bedienereingriff oder Reset wiederherstellen. Die konkrete Produktnorm kann diese allgemeinen Kriterien präzisieren oder zusätzliche Anforderungen festlegen. ``post_exposure_timeout`` Beobachtungszeit nach RF-Off. Sie ist insbesondere für die Bewertung der Erholung nach Kriterium B oder C erforderlich. ``eut_event_policy`` Anwendungsentscheidung für ``degraded``, ``failed`` und ``not_evaluated``. Die Sicherheitsanforderung ``safety_action="rf_off"`` wird davon unabhängig behandelt. Ein reproduzierbarer virtueller Monitor eignet sich für den ersten Lauf: .. code-block:: python from mpylab.env.eut import VirtualEUTMonitor monitor = VirtualEUTMonitor([{ "status": "degraded", "reason": "virtual_output_tolerance", "safety_action": "none", }]) status = measurement.Measure_Immunity( description="EUT", eut_monitor=monitor, performance_criterion="B", post_exposure_timeout=10.0, eut_event_policy={ "degraded": "continue", "failed": "stop", "not_evaluated": "stop", "max_retries": 0, }, # weitere verfahrensspezifische Parameter ) Die MSC-Schwellwertsuche erhält den Monitor im Parameterblock des ``ImmunityThresholdKernel``. Qt-Anwendungen reichen ihren ``ManualEUTMonitor`` und automatische Monitore an die Messklasse weiter. TEMField bietet dafür ``set_automatic_eut_monitor``. Die :doc:`MSC- <../measurements/msc>` und :doc:`TEM-Anleitungen <../measurements/tem>` beschreiben die jeweiligen Messabläufe. Einen spezifischen Monitor entwickeln -------------------------------------- Ein anwendungsspezifischer Monitor erbt von ``EUTMonitor``. Typische Quellen sind Kamerabilder, Kommunikationsantworten, digitale Zustände oder Prozessmesswerte. ``poll_event`` muss nichtblockierend oder zeitlich klar begrenzt sein: .. code-block:: python from mpylab.env.eut import EUTMonitor, make_eut_event class CommunicationEUTMonitor(EUTMonitor): def start_exposure(self, context): self.frequency = context.get("frequency") self.start_observation() def poll_event(self): observation = self.read_status_nonblocking() if observation is None: return None if observation == "ok": return make_eut_event( "passed", "communication_ok", source="eut_link", ) return make_eut_event( "failed", "communication_lost", details={"frequency": self.frequency}, safety_action="rf_off", source="eut_link", ) def stop_exposure(self): self.stop_observation() def close(self): self.close_connection() Treiberzugriffe mit nennenswerter Laufzeit werden gekapselt: .. code-block:: python from mpylab.env.eut import ThreadedEUTMonitor monitor = ThreadedEUTMonitor( CommunicationEUTMonitor(), poll_interval=0.02, join_timeout=1.0, ) Der umschlossene ``poll_event``-Aufruf muss trotzdem eine endliche maximale Laufzeit besitzen, damit der Thread beim Stoppen sicher beendet werden kann. Ein Ausfall eines automatischen Monitors wird als ``monitor_diagnostic`` gespeichert; er darf nicht als beobachteter EUT-Ausfall ausgegeben werden. In eine neue Anwendung integrieren ---------------------------------- ``EUTMonitoringSession`` bündelt manuelle und automatische Monitore und verwaltet Exposition, Phasen, Eventvalidierung und Diagnosen: .. code-block:: python from mpylab.env.eut import EUTMonitoringSession, ManualEUTMonitor manual = ManualEUTMonitor(poll_key=my_poll_key, keylist="sS") session = EUTMonitoringSession.from_monitors(manual, [monitor]) try: session.start_exposure({"frequency": frequency, "position": position}) event = session.poll_event() if event is not None and event["safety_action"] == "rf_off": measurement_worker.rf_off() # unmittelbarer Sicherheitspfad session.start_phase( "post_exposure", {"frequency": frequency, "position": position, "rf_on": False}, ) finally: session.close() Die Session schaltet RF niemals selbst. Eine neue Messanwendung muss Sicherheitsaktionen im Worker ausführen, Monitorereignisse in die Messhistorie übernehmen und ``close`` in einem ``finally`` aufrufen. RF-Off muss dabei vor möglicherweise fehlschlagendem Monitor-Cleanup erfolgen. Ohne Hardware testen -------------------- * ``VirtualEUTMonitor`` liefert vorgegebene Ereignisse deterministisch. * ``RandomEUTMonitor(seed=...)`` eignet sich für längere Ablauf- und UI-Tests, nicht als Nachweis eines realen EUT-Verhaltens. * Tests müssen manuelle Intervention, sofortiges RF-Off, Post-Exposure, Monitordiagnosen und Cleanup-Fehler abdecken. * Ein virtueller End-to-End-Lauf soll dieselben Messklassenparameter wie der spätere Hardwarelauf verwenden. Die kuratierte :doc:`Python-API <../../api/measurement>` dokumentiert alle öffentlichen Monitor- und Sessionmethoden. Thread- und GUI-Regeln stehen unter :doc:`ui-workers`.