---
title: "Eine Methode ausführen"
product: "LumiScan Text Reader"
component: "lumiscan-text-reader-de"
version: "1.1.0"
display_version: "1.1.0.6"
latest_version: true
language: "de"
url: "https://docs.hdvisionsystems.com/de/lumiscan-text-reader-de/1.1.0/lumiscan-text-reader/execute-a-method.html"
---

# Eine Methode ausführen – LumiScan Text Reader

Jede Operation dieser Anwendung - Text lesen, die Sprachmodelle wählen und die Modulverwaltung - wird auf dieselbe Weise gestartet und meldet ihren Ausgang auf dieselbe Weise. Es sind Execute-Methoden des Data Layer; wie Execute-Methoden allgemein funktionieren, ist in [Execute-Methoden](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/execute.html) beschrieben.

## Der Aufbau einer Operation

Eine Operation liegt unter ihrer eigenen Adresse und hat immer drei Teile:

```
<operation>/execute                 write here to run it
<operation>/input/...               the values it works on
<operation>/output/status-code      what happened, as a number
<operation>/output/status-text      what happened, in words
```

Manche Operationen haben mehr unter `output/` - zum Beispiel den Text eines Leseergebnisses -, aber `execute`, `status-code` und `status-text` sind immer vorhanden.

## Eine Operation ausführen

1. Schreiben Sie die Eingabeknoten.
2. Schreiben Sie auf `execute`. Der Wert spielt keine Rolle; der Schreibvorgang selbst löst die Operation aus.
3. Lesen Sie `output/status-code`, um zu erfahren, ob sie funktioniert hat.

Das Schreiben auf `execute` ist ein **blockierender Aufruf**: Er kehrt zurück, wenn die Operation abgeschlossen ist. Sie müssen also kein "ready"-Flag pollen und keinen Zustand in Ihrem Programm verfolgen. Eingaben behalten ihre Werte zwischen den Durchläufen, eine wiederholte Operation braucht also nur Schritt 2.

## Den Ausgang prüfen

`output/status-code` ist eine vorzeichenbehaftete Zahl, und **allein das Vorzeichen sagt Ihnen, ob es funktioniert hat**:

| Wert | Bedeutung |
| --- | --- |
| größer als 0 | Die Operation war erfolgreich |
| 0 | Die Operation ist seit dem Start der Anwendung nicht gelaufen |
| kleiner als 0 | Die Operation ist fehlgeschlagen und hat nichts erzeugt |

Die Prüfung in einer SPS ist also einfach `status-code < 0`. Einen bestimmten Code brauchen Sie nur, wenn Sie auf verschiedene Fehler unterschiedlich reagieren wollen - etwa auf eine nicht installierte Sprache anders als auf eine Kamera, die nicht antwortet.

`output/status-text` enthält denselben Ausgang als Satz und nennt den beanstandeten Wert, wenn es einen gibt:

```
ok: 4 word(s), mean score 0.91 (eng, SINGLE_BLOCK)
error: crop/startX + crop/width (100 + 900 = 1000) exceeds the image width 640
```

Lesen Sie ihn, wenn etwas schiefgeht; bauen Sie keine Logik darauf auf, weil sich der Wortlaut zwischen Releases ändern kann. Die vollständige Liste der Codes steht in [Ausführungsstatus](https://docs.hdvisionsystems.com/de/lumiscan-text-reader-de/1.1.0/lumiscan-text-reader/execution-status.html).

> [!NOTE]
> Der Grund kommt auf `output/status-text` an, nicht in der Antwort auf den `execute`-Schreibvorgang selbst. Ein fehlgeschlagener Schreibvorgang antwortet nur mit einem Statuscode - über REST ein bloßes `400`. Der Data Layer verwirft jedes Detail, das ein Provider an einen fehlgeschlagenen Aufruf anhängt; deshalb erfahren Sie, was falsch war, indem Sie anschließend `output/status-text` lesen. Die Ergebnisse, mit denen ein Schreibvorgang antworten kann, und ihre Namen auf dem ctrlX Data Layer und auf LumiScan Keryx sind in [Ergebnisse eines Methodenaufrufs](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/status-codes.html#method-results) aufgelistet.
>
> Derselbe Text wird in das Anwendungsprotokoll geschrieben, sodass ein Fehler auch ganz ohne den Data Layer diagnostizierbar ist: auf ctrlX OS über das ctrlX Logbook oder `journalctl`, auf einem PC über die Konsolenausgabe der Anwendung. Sind mehrere Eingaben falsch, erhält jede ihre eigene Warnzeile.

## Eine Operation zur Zeit

Ein Modul führt jeweils eine Operation aus. Eine zweite zu starten, während die erste noch läuft, stellt sie nicht in eine Warteschlange - sie kehrt sofort mit Statuscode `-1` (belegt) zurück und tut nichts. Der Schreibvorgang selbst antwortet mit `TooManyOperations` (ctrlX: `DL_TOO_MANY_OPERATIONS`), siehe [Eine Operation zur Zeit](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/execute.html#busy).

Die Sperre gilt pro Modul, verschiedene Module lesen also parallel - eine zweite Kamera wird von der ersten nicht aufgehalten.

## Die Ausgaben gehören zum startenden Durchlauf

Jede Methode leert ihre eigenen Ausgabeknoten, sobald sie beginnt - `read-text` sein `output/result`. Sie werden geleert, **bevor** irgendetwas fehlschlagen kann; ein Durchlauf, der aus irgendeinem Grund fehlschlägt, lässt sie also leer zurück, statt das Ergebnis eines früheren Durchlaufs zu behalten.

Deshalb ist es sicher, eine Ausgabe zu lesen, ohne vorher `output/status-code` zu prüfen: Was Sie sehen, ist entweder das Ergebnis dieses Durchlaufs oder nichts, nie ein veralteter Wert von einem früheren Bild.

`output/status-code` und `output/status-text` sind die Ausnahme - sie beschreiben immer den letzten Versuch, und genau das ist ihr Zweck.

> [!WARNING]
> **Lesen Sie eine Ausgabe, bevor Sie den nächsten Durchlauf auslösen.** Die Ausgaben beschreiben den jüngsten Durchlauf, und der nächste Aufruf leert sie in dem Moment, in dem er startet. Wenn Sie `execute` erneut aufrufen und dann das vorherige Ergebnis lesen, erhalten Sie nichts.
>
> Der einzige Fall, der **nichts** leert, ist ein Aufruf, der als `-1` (belegt) abgelehnt wird: Er ist nie gelaufen und lässt die Ausgaben der laufenden Operation unberührt. Ein zweites `execute`, das direkt nach dem ersten ausgelöst wird, hat also zwei mögliche Ausgänge, und sie unterscheiden sich:
>
> - der erste Durchlauf **läuft noch** - der zweite wird mit `-1` abgelehnt, und die Ausgaben enthalten noch den Durchlauf davor;
> - der erste Durchlauf ist **gerade fertig** - der zweite wird angenommen und leert die Ausgaben, die der erste gerade erst geschrieben hat.
>
> Warten Sie, bis `execute` zurückkehrt, lesen Sie die Ausgaben und lösen Sie erst dann den nächsten Durchlauf aus.
