Hardwareschnittstellen benutzen

In diesem Abschnitt wird beschrieben, wie aus einem Skript oder aus einer Treiberdatei auf verschiedene Hardwareschnittstellen zugegriffen werden 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 */ });
  }
}

Hardwareschnittstellen anfordern

Hardwareschnittstellen werden in KalibriWare über die Dependency-Injection angefordert. Es grundsätzlich drei Varianten eine Schnittstelle anzufordern:

Schnittstelle mit Alias-Name anfordern (empfohlen)

Jeder Hardwareschnittstelle kann in der Benutzeroberfläche ein Alias-Name zugeordnet werden. Das ermöglicht es, Schnittstellen über viele Skripte und Messplätze identisch zu verwenden. Das folgende Codebeispiel zeigt, wie eine Schnittstelle ü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: HardwareByAlias ist eine Hilfsfunktion, welche die Alias-Namen auf die echte Schnittstelle auflöst 
import { HardwareByAlias } from '@runtime/hardware-injection';
// NEU: GPIB für Code-Completion
import { GPIB } from '@script/hw';

@Injectable()
export class HardwareByAliasExample extends Script {

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

  }
}

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

Schnittstelle im Standard anfordern (empfohlen)

Wenn eine Hardwareschnittstelle innerhalb einer Treiberklasse für einen Standard benutzt wird, kann auf den Alias verzichtet werden. Das folgende Codebeispiel zeigt die Benutzung von GPIB direkt im Standard:

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

// NEU: GPIB und Standard-Konfiguration
import { GPIB } from '@scripts/hw';
import { CalibratorConfig } from '@runtime/calibrators-injection';
import { GPIBDeviceConfig } from './common';

@Injectable()
export class StandardWithHardwareExample extends Script {

  // Schnittstelle anfordern.
  // Hierbei weiß die Laufzeitumgebung, dass hier ein Objekt vom Typ GPIB benötigt wird und stellt es bereit.
  // Weiterhin wird die GPIBDeviceConfig angefordert, wo die Adresse des Standards hinterlegt wird.
  constructor(private gpib: GPIB, @Inject(CalibratorConfig) private cfg: GPIBDeviceConfig) {

  }
}

Beim Start eines jeden Kalibrierjobs lädt die Kalibrierumgebung aus der Datenbank alle Informationen zum aktuellen Messplatz:

  • Eingerichtete Schnittstellen
  • Standards
    • Beziehung von Standard zu Schnittstelle
    • Addressen der Standards
  • Job-Details
  • Prüfling

Daraus basierend wird für jeden Standard die Treiberdatei erzeugt und entsprechend transparent mit der Hardwareschnittstelle verlinkt.

Dynamisches Laden von Schnittstellen

In speziellen Randfällen kann es notwendig sein, eine Schnittstelle 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 diesen Fällen kann eine Hardwareschnittstelle dynamisch angefragt werden, dafür kann der folgedene Code benutzt werden:

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

import { GPIB } from '@script/hw';
import { HardwareByAlias } from '@runtime/hardware-injection';


@Injectable()
export class DynamicHardwareExample 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 die eigentliche Schnittstelle erst dynamisch vom Injektor angefordert.
     * Das kann zu einer beliebigen Zeit passieren, z.B. vor oder in einem Messschritt.
     * Schnittstellen können dynamisch mehrfach angefordert werden, das Objekt wird nicht neu erzeugt dabei.
     * Wichtig dabei ist, am Ende das `as GPIB` zu benutzen, um den korrekten Typ für die automatische Codevervollständigung zu bekommen.
     */
    const standard = this.injector.Get(HardwareByAlias.createOrGet('GPIB0')) as GPIB;
  }
}