Einbinden eines Standards in ein Skript

In diesem Abschnitt wird beschrieben, wie ein Standard mit dem Kalibrierskript verbunden wird und man damit interagieren kann.

Im vorangegangenen Dokument wurde bereits das Skelett für ein neues Kalibrierskript vorgestellt, welches hier als Grundlage dienen soll:

// Zusatzfunktion der Abhängigkeitsauflösung importieren
import { Injectable } from 'injection-js';
// Basisklasse für alle Skripte, jedes Skript muss von `Script` erben.
import { Script, StepsService } from '@script';

// Klasse als erzeugbar markieren
@Injectable()
export class SkriptName extends Script {

  // Hier wird der StepsService aus der Dependency Injection angefordert und innerhalb der Klasse abgespeichert.
  constructor(private steps: StepsService) {

  }

  // Run enthält das eigentliche Kalibrierskript.
  public Run(): void {

    // Makroschritt hinzufügen.
    // Im ersten Parameter steht der Name, welcher am Ende auch in der Benutzerschnittstelle angezeigt wird.
    // Im zweiten Parameter ist die wirkliche "Ausführungsfunktion", diese führt alle Messungen zu diesem Parameter durch. Diese Funktion kann mehrfach ausgeführt werden, z.B. wenn eine Messung fehlschlägt und der Schritt wiederholt wird.
    // Im dritten Parameter sind Optionen enthalten, darüber kann ein Schritt z.B. als überspringbar oder automatisch startend festgelegt werden.
    this.steps.Add("Schrittname", async () => {
      // TODO Benutzer: Messfunktionen einfügen
    }, {});

    this.steps.Add("Schritt 2", async () => {
      // TODO Benutzer: Messfunktion einfügen
    }, { /* TODO Benutzer: Optionen */ });
  }
}

Standards anfordern

Standards werden in KalibriWare über die Dependency-Injection angefordert. Es grundsätzlich drei Varianten einen Standard anzufordern:

Standard mit Alias-Name anfordern (empfohlen)

Jedem Standard kann in der Benutzeroberfläche ein Alias-Name zugeordnet werden. Das ermöglicht es, Standards über viele Skripte und Messplätze identisch zu verwenden. Das folgende Codebeispiel zeigt, wie ein Standard über den Alias-Namen angefordert werden kann:

// NEU: Inject importiert, um die Abhängigkeit anzufordern
import { Injectable, Inject } from 'injection-js';
import { Script, StepsService } from '@script';

// NEU: CalibratorByAlias ist eine Hilfsfunktion, welche die Alias-Namen auf den echten Standard auflöst 
import { CalibratorByAlias } from '@runtime/calibrators-injection';

@Injectable()
export class StandardByAliasExample extends Script {

  // Standard anfordern.
  // CalibratorByAlias.createOrGet("NAME") löst den Alias auf einen Standard auf
  // @Inject() fragt den Standard von der Laufzeitumgebung an.
  // private standard: IStandard speichert das Objekt im Skript um ihn später zu benutzen.
  constructor(@Inject(CalibratorByAlias.createOrGet("ALIAS_NAME")) private standard: IStandard) {

  }
}

Wichtig hierbei ist, den Parameter mit dem korrekten Typ (hier: IStandard) zu versehen. Durch die Verbindung von Typ zu Parameter kann später eine korrekte Überprüfung der Skripte erfolgen.

Standard als Klasse anfordern

Alternativ zum oberen Beispiel mit dem Alias-Name, kann auch ein Standard über seine Klasse angefordert werden, also z.B. es gibt nur einen OMS-200 Standard im Lab, welcher benutzt werden muss. Das folgende Codebeispiel zeigt die Nutzung des Standards über seine Klasse:

import { Injectable } from 'injection-js';
import { Script, StepsService } from '@script';

import { OMS200 } from '@runtime/scripts/drivers/OMS200';


@Injectable()
export class StandardByClassExample extends Script {

  // Standard anfordern.
  // Hierbei weiß die Laufzeitumgebung, dass hier ein Objekt vom Typ OMS200 benötigt wird und stellt es bereit.
  constructor(private oms200: OMS200) {

  }
}

Achtung: Bei Benutzung dieser Methode kann nur ein Standard pro Typ angefragt werden. Wenn z.B. zwei gleiche Multimeter benutzt werden, können nicht beide Multimeter über die Klasse angefragt werden - es ist nicht definiert, welches von beiden Objekten dann geladen wird. In diesen Fällen muss die Methode über Aliases benutzt werden!

Dynamisches Laden von Standards

In speziellen Randfällen kann es notwendig sein, einen Standard nur unter einer bestimmten Bedingung anzufordern, z.B. nur wenn der Kunde wünscht, dass ein spezieller Parameter mit einem Spezialmessgerät gemessen werden muss. In solchen Fällen ist es nicht wünschenswert, den Standard über die oberen zwei Methoden anzufordern, denn dann würde der Standard im Protokoll / Kalibrierschein erwähnt werden, obwohl er ggf. nicht benutzt wurde.

Daher kann für diese Fälle der folgedene Code benutzt werden:

import { Injectable, Injector } from 'injection-js';
import { Script, StepsService } from '@script';

import { OMS200 } from '@runtime/scripts/drivers/OMS200';


@Injectable()
export class DynamicStandardExample extends Script {

  // Injektor anfordern.
  // Hierbei weiß die Laufzeitumgebung, dass wir dynamisch auf andere Objekte zugreifen wollen.
  constructor(private injector: Injector) {

  }

  public Run(): void {
    /**
     * Hier wird der eigentliche Standard erst dynamisch vom Injektor angefordert.
     * Das kann zu einer beliebigen Zeit passieren, z.B. vor oder in einem Messschritt.
     * Standards können dynamisch mehrfach angefordert werden, das Objekt wird nicht neu erzeugt dabei.
     * Wichtig dabei ist, am Ende das `as OMS200` zu benutzen, um den korrekten Typ für die automatische Codevervollständigung zu bekommen.
     * Analog dazu kann auch hier CalibratorByAlias.createOrGet() benutzt werden.
     */
    const standard = this.injector.Get(OMS200) as OMS200;
  }
}