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 Ereignisstruktur und Bewertung 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:

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 MSC- und TEM-Anleitungen 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:

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:

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:

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 Python-API dokumentiert alle öffentlichen Monitor- und Sessionmethoden. Thread- und GUI-Regeln stehen unter UI-Adapter und Worker-Schnittstelle.