Mitgelieferte Generatoren

Referenztest-Packagegenerator

Anwendungsfälle und allgemeine Beschreibung

Der Referenztest-Packagegenerator kann die Signalverläufe zweier Tracedateien (Referenz- und Test-Trace) qualitativ miteinander vergleichen. Einfache Signalvergleiche können mittels eines Traceanalyse-Berechnungsschrittes durchgeführt werden. Für komplexere Analysen wird empfohlen die Traceanalyse aus einem Analysepackage oder einem Package zu referenzieren oder die Traceanalyse individuell (codebasiert) zu definieren. Dabei können auch Signale mit unterschiedlichen Bezeichnern in den Aufnahmen zuvor einander zugeordnet werden (SignalMatching). Wenn im Vergleich zum Referenz-Trace Signale entfallen bzw. neu hinzugekommen sind, können hierfür individuell Bewertungskriterien festgelegt werden. Zusätzlich können irrelevante Signale mittels Filter explizit ausgeschlossen werden.

Die Parametrierung des Referenztest-Packagegenerators kann entweder GUI-unterstützt oder codebasiert vorgenommen werden. Für die codebasierte Parametrierung stehen die folgenden Schnittstellen als Builtins zur Verfügung: api, user, tools Die Referenztest-Packagegenerator-Tools sind spezifisch für diesen Generator.

Zur einfacheren Handhabung der Tracesignale werden diese als Object API-konforme Signal-Objekte übergeben.

Bedienung und Einstellungen

Im Dialog stehen folgende Tabs für weitere Einstellungen zur Verfügung:

Allgemein

Hier kann beeinflusst werden, ob ein gemeinsames Package mit allen Signalvergleichen oder für jeden Signalvergleich ein eigenes Package erzeugt werden soll. Außerdem ist es möglich dass ein einzelnes Package generiert wird, welches dann über Parametersätze mit den verschiedenen Signalpaaren aufgerufen wird.

Folgende Arten der Generierung können gewählt werden, um die n Signalpaare zu analysieren:

Methode	Generierte Artefakte	Auswertung	Ausführungsgeschwindigkeit
Einzelpackage	Ein Package mit n Analyseschritten	Weniger differenzierte Auswertung, da das gesamte Package fehlschlägt, wenn ein Signalvergleich fehlschlägt	Schnellste
Mehrere Packages	Ein Package pro Signalpaar	Höchst differenzierte Auswertungsmöglichkeiten	Langsamste
Parametersätze	Ein Package mit n Parametersätzen	Kompromiss zwischen Geschwindigkeit und Detailgrad der Auswertung	Mittel

Signalfilterung

Hier können Filter definiert werden, um Signale ein- bzw. auszuschließen. Die angegebenen Filter werden sowohl auf die Signale des Referenz- als auch des Test-Traces angewendet.

Package-Vorbereitung

Festlegung eines individuellen Package-Namens bei der Generierung.

Signalzuordnung

Angaben zur Zuordnung der Signale aus dem Referenz- und dem Testtrace.

Traceanalyse

Hier wird die eigentliche Tracenanalyse definiert, welche auf die Signalpaare angewandt wird. Es wird eine Traceanalyse generiert. Über einen Berechnungs-Traceschritt werden das Referenzsignal und das Testsignal miteinander verglichen.

Vorschau

Vorschau des ausgeführten Codes. Diese Ansicht dient nur Debug-Zwecken.

Beispiele

Beispiel Signalfilterung

Im folgenden Beispiel ist ein Spezialfall dargestellt, bei dem ein einziges ausgewähltes Referenzsignal auf sämtliche gefilterten Testsignale angewandt wird.

def FilterSignals(refSignals, testSignals):
    """
    Use this method to filter the signals you want to be analyzed.

    :param refSignals:   list of all signals within reference trace file
    :type refSignals:    list<string>
    :param testSignals:  list of all signals within Testtrace file
    :type testSignals:   list<string>
    :return:             tuple of signals to be analyzed
    :rtype:              tuple(refSignals, testSignals)
    """

    # filter test signals
    testSignals = [testSignal for testSignal in testSignals if testSignal.name.startswith("Sig")]

    # filter reference signal list. The result should contain only one element.
    refSignals = [refSignal for refSignal in refSignals if refSignal.name.startswith("Ref")]

    # The first element will be the reference signal for all test signals
    singleRefSignal = refSignals[0]
    refSignals = [singleRefSignal]*len(testSignals)

    return (refSignals, testSignals)

Beispiel Package-Vorbereitung

Im folgenden Beispiel ist dargestellt, wie für jedes generierte Einzelpackage ein individueller Name erstellt wird, entsprechend der einander zugeordneten Signalpaare.

def PreparePackage(packageObject, traceAnalysisObject, signals):
    """
    Within this method the 'packageObject' and 'traceAnalysisObject' can be customized according to
    the Object API to fit individual needs. For instance, attributes or the name of the test package
    can be adjusted. Also the trace analysis can be preconfigured by adding episodes that can be
    used within 'CreateAnalysis()' by 'tools.GetOrCreateEpisode(traceAnalysisObject, episodeName)'.
    e.g. packageObject.Attributes.SetValue('MyTestcaseAttribute','theAttributeValue')

    This method is executed *once* per package.

    :param packageObject:        object of the generated reference test package
    :type packageObject:         :class:`.PackageFacade`
    :param traceAnalysisObject:  the trace analysis object
    :type traceAnalysisObject:   :class:`.TraceAnalysisFacade`
    :param signals:              list of tuples of 'refSignal' and 'testSignal'. One of those can be
                                 'None' if no matching signal was found.
    :type signals:               list<tuple(refSignal<Signal>, testSignal<Signal>)>
    :return:                     name of the package
    :rtype:                      string
    """
    api.countPreparePackageCalls += 1
    packageObject.Attributes.SetValue('MyTestcaseAttribute','theAttributeValue')

    refSignal = signals[0][0]
    testSignal = signals[0][1]
    return f'MyPackage_{refSignal} vs. {testSignal}'

Beispiel Traceanalyse

Mit diesem Code wird zusätzlich zu einer Hüllkurvenanalyse noch ein Plot je analysiertem Signalpaar generiert.

def CreateAnalysis(traceAnalysisObject, refName, testName):
    """
    Customizable method to add individual TraceAnalysisSteps to the 'traceAnalysisObject'
    for a corresponding pair of signals. Use the Trace Analysis API, which is already available
    as 'traceAnalysisApi', to create custom TraceSteps for your analysis.
    This method is executed *once* for every mached signal pair (refName, testName).

    :param traceAnalysisObject:  the trace analysis object
    :type traceAnalysisObject:   :class:`.TraceAnalysisFacade`
    :param refName:  signal name of the reference trace file
    :type refName:   string
    :param testName: signal name of the Testtrace file
    :type testName:  string
    """

    episode = tools.GetOrCreateEpisode(traceAnalysisObject)

    calculation = traceAnalysisApi.CreateCalculation(f'Comparison {refName} vs. {testName}')
    calculation.SetExpression(f'HoseAbsolute({refName}, {testName}, 1, 5)')

    episode.AppendTraceStep(calculation)
    tools.EnablePlot(calculation, plotName=testName)

    return traceAnalysisObject

2025-12-05