# LumiScan Cam Driver 2.2.1.10 – complete documentation

> All pages of the LumiScan Cam Driver 2.2.1.10 manual (language: de) by HD Vision Systems GmbH, in navigation order. Each page starts with a level-1 heading followed by its URL; cite that URL. Manual: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/

# Beschreibung – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/description.html

Der LumiScan Cam Driver verbindet Ethernet-fähige, GenICam-konforme Kameras mit einer ctrlX CORE oder einem ctrlX IPC (ctrlX OS) oder mit einem PC und stellt ihre Bilder und Kamerafunktionen über den Data Layer bereit: den ctrlX Data Layer auf ctrlX OS, LumiScan Keryx auf einem PC. Die Knotenadressen sind auf beiden gleich.

Was in jeder LumiScan-App gleich ist - wie Adressen aufgebaut sind, die Aufrufmuster Handshake, Execute und Stream, Statuscodes, Einstellungen und Werkzeuge - ist im Handbuch [LumiScan Keryx](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/index.html) beschrieben. Dieses Handbuch behandelt nur das, was spezifisch für den LumiScan Cam Driver ist; die Seiten dieses Handbuchs beschreiben seine eigenen Knoten.

Er übernimmt die Kameraerkennung, die Verbindung, die Bildaufnahme und die grundlegende Kamerakonfiguration. Kameraparameter wie Belichtungszeit, Pixelformat und andere unterstützte GenICam-Features sind über die Anwendungskonfiguration und den Data Layer zugänglich.

> [!NOTE]
> Die verfügbaren Kamera-Features hängen vom Kameramodell und seiner GenICam-Implementierung ab. Einige Funktionen sind möglicherweise nicht für jede Kamera verfügbar.

## Wo Bilder abgerufen werden können

Jede konfigurierte Kamera veröffentlicht ihr aufgenommenes Bild über den Data Layer.

Zum Beispiel:

```
hdvisionsystems/lumiscan-cam-driver/camera1/output/image
```

Der Bildknoten liefert die Bilddaten zusammen mit Informationen wie Breite, Höhe und Pixeltyp.

Andere LumiScan-Anwendungen können diese Data-Layer-Adresse als Bildquelle verwenden. Die Bilddaten können auch direkt von Anwendungen abgerufen werden, die die entsprechende Data-Layer-Schnittstelle unterstützen.

## Bilder streamen

Ab v2.3.0 kann eine Kamera ihre Bilder auch streamen: Nach `<camera name>/control/publish/execute` veröffentlicht der Cam Driver jedes Bild, das die Kamera liefert, auf `<camera name>/control/publish/output/stream/frame` für einen Abonnenten, statt ein Bild pro Capture-Request. Die Bilder kommen, wie die Kamera getriggert wird: per Hardware, per `control/trigger/execute` oder kontinuierlich. Diese Funktion ist experimentell. Siehe [Bilder streamen (experimentell)](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html).

## Module

Ein **Modul** steht für eine konfigurierte Kamera.

Jedes Modul legt fest, welche Kamera verwendet wird, und enthält die kameraspezifische Konfiguration, zum Beispiel:

- Kameraidentifikation
- Verbindungseinstellungen
- Aufnahmeeinstellungen
- Kamera-Features und -Parameter
- Data-Layer-Adressen für Steuerung, Status und Bildausgabe

Jedes Modul hat seine eigene Data-Layer-Adresse und arbeitet unabhängig von den anderen konfigurierten Kameras.

Zum Beispiel:

```
hdvisionsystems/lumiscan-cam-driver/camera1
hdvisionsystems/lumiscan-cam-driver/camera2
```

So kann eine Installation des LumiScan Cam Driver mehrere Kameras verbinden und verwalten, wobei jede Kamera ihr eigenes Modul und ihre eigene Konfiguration verwendet.

# Voraussetzungen – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/requirements.html

- Eines von beiden:
  - ctrlX OS: eine ctrlX CORE mit dem ctrlX Data Layer
  - ein PC mit Windows 11 oder Ubuntu 24.04 und LumiScan Keryx
- Ethernet-fähige, GenICam-konforme Kamera
- Stromversorgung der Kamera, entweder über PoE oder über ein externes Netzteil

> [!NOTE]
> Die Anwendung wurde mit ausgewählten Kameras von Basler, Baumer, IDS, LUCID Vision Labs, Hikvision und Balluff getestet.

> [!IMPORTANT]
> GenICam-Implementierungen können sich zwischen Herstellern und Kameramodellen unterscheiden. Deshalb sind bei nicht getesteten Kameras einige Funktionen möglicherweise nicht verfügbar oder verhalten sich anders. Prüfen Sie alle benötigten Funktionen vor dem Einsatz.

Zum Data Layer auf jeder Plattform siehe [ctrlX Data Layer und LumiScan Keryx](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/platforms.html).

## Lizenz {#licence}

Wie LumiScan Cam Driver lizenziert wird, hängt davon ab, wo Sie es gekauft haben und wo es läuft:

| Gekauft bei | Läuft auf | Lizenzierung |
| --- | --- | --- |
| HD Vision Systems | Windows 11 oder Ubuntu 24.04 | Die Lizenz liegt auf Ihrem LumiScan Key. Sie ist ein Einmalkauf und wird nicht verlängert.<br><br>[Lizenzierungsweg: gekauft bei HD Vision Systems](https://docs.hdvisionsystems.com/de/lumiscan-licensing-de/1.0.4/path-hdvs.html) |
| ctrlX Store | Windows 11 | Die Lizenz liegt in ctrlX WORKS. Zusätzlich ist der LumiScan Key erforderlich; er schützt die Software vor Reverse Engineering.<br><br>[Lizenzierungsweg: ctrlX Store, Windows](https://docs.hdvisionsystems.com/de/lumiscan-licensing-de/1.0.4/path-ctrlx-windows.html) |
| ctrlX Store | ctrlX OS (ctrlX CORE oder IPC) | ctrlX-Lizenz `SWL-W-XCx-CAMDRIVERxHDVSx-V2NN`, eine Lizenz pro angeschlossener Kamera.<br><br>[Lizenzierungsweg: ctrlX Store, ctrlX OS](https://docs.hdvisionsystems.com/de/lumiscan-licensing-de/1.0.4/path-ctrlx-os.html) |

Jedes Gerät, auf dem LumiScan Cam Driver gleichzeitig läuft, benötigt einen eigenen LumiScan Key. Keys können zwischen Geräten ausgetauscht werden.

Wie Sie die CodeMeter Runtime installieren und Lizenzen anfordern, verlängern und an einem anderen PC verwenden, steht in [LumiScan Lizenzierung](https://docs.hdvisionsystems.com/de/lumiscan-licensing-de/1.0.4/index.html).

Auf ctrlX OS beendet sich die Anwendung kurz nach dem Start, wenn die Lizenz fehlt; der Grund wird in das Systemprotokoll geschrieben.

> [!NOTE]
> Bis einschließlich v2.1.0 müssen alle Lizenzen gemeinsam installiert werden und als ein Eintrag Cam Driver V2 erscheinen, der alle Kameras abdeckt. Getrennte Einträge führen zu einem Lizenzfehler. Ab v2.2.0 werden auch getrennt installierte Lizenzen unterstützt. Siehe [Release Notes: v2.2.0](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/release-notes/v2-2-0-2026-08-05.html).

# Anleitung: Eine GenICam-Kamera an die ctrlX CORE anschließen – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/connect-a-genicam-camera.html

Diese Anleitung schließt eine Ethernet-Kamera nach dem GenICam-Standard (GigE Vision) an eine ctrlX CORE an und führt bis zu einem aufgenommenen Bild auf dem ctrlX Data Layer. Sie benötigen dafür nur die ctrlX-Weboberfläche.

Am Ende gilt:

- Die Kamera hat eine feste IP-Adresse im Netzwerk der ctrlX CORE.
- LumiScan Cam Driver hat ein Modul für die Kamera und findet sie.
- Die Kamera ist verbunden, und jede Aufnahme legt ein Bild auf den Data Layer.
- Aufgenommene Bilder lassen sich optional im internen Speicher, auf einem USB-Speichergerät, einer SD-Karte oder einer Netzwerkfreigabe speichern.

## Bevor Sie beginnen {#prerequisites}

**Hardware**

- ctrlX CORE, zum Beispiel ctrlX CORE X3 oder X7
- GenICam-konforme Ethernet-Kamera (GigE Vision)
- Engineering-PC mit Browser
- Geschirmte Ethernet-Kabel (Foil Shielded Twisted Pair)
- Optional: ein Ethernet-Switch, der Jumbo Frames unterstützt

**Software und Lizenzen**

- LumiScan Cam Driver auf der ctrlX CORE installiert, mit einer Lizenz je Kamera, siehe [Voraussetzungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/requirements.html)
- Das Konfigurationswerkzeug des Kameraherstellers, um die IP-Adresse der Kamera einzustellen

## Wie es zusammenhängt {#overview}

LumiScan Cam Driver wird mit zwei Arten von Dateien konfiguriert und vollständig über den Data Layer gesteuert:

- `lumiscan-cam-driver.json`, die **Anwendungseinstellungen**, nennt in `modules` die zu ladenden Kameramodule und enthält die Einstellungen des Geräts, etwa Protokollierung und Bildspeicher.
- Eine **Moduldatei** je Kamera, zum Beispiel `camera1.json`, benennt die Kamera über ihre Seriennummer und legt Belichtungszeit und Pixelformat fest. Ihre `id` wird zum Namen des Moduls auf dem Data Layer: `hdvisionsystems/lumiscan-cam-driver/<id>/…`.

Jede Operation eines Moduls - verbinden, aufnehmen, speichern - liegt unter `hdvisionsystems/lumiscan-cam-driver/<id>/control/<Operation>/`. Sie wird entweder mit dem ready/request-Handshake gestartet oder, bei den meisten Operationen, mit einem einzigen Schreibzugriff auf `execute`. Siehe [Eine Methode ausführen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html) und [Grundkonzept des Handshakes](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html).

Die Einstellungsdateien werden nur beim Start der Anwendung gelesen. Starten Sie LumiScan Cam Driver nach jeder Änderung neu.

## Schritt 1 - Netzwerk einrichten {#step-1-network}

1. Geben Sie der Kamera mit dem Konfigurationswerkzeug des Herstellers eine feste IP-Adresse:
   - Stellen Sie eine statische (persistente) IP-Adresse ein, zum Beispiel `192.168.1.21`, Subnetzmaske `255.255.255.0`.

   - Schalten Sie DHCP und Auto IP (Link Local) aus.

     Die Adresse muss im Subnetz des ctrlX-CORE-Anschlusses liegen, an dem die Kamera betrieben wird. Ist die Kamera schon an der ctrlX CORE angeschlossen, aber im falschen Subnetz, können Sie die Adresse auch von dort aus setzen, siehe [Kamera-IP-Adresse einrichten](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/setup-camera-ip-address.html).

2. Verbinden Sie Kamera, ctrlX CORE und Engineering-PC. Zwei Topologien sind möglich - alle drei an einem Switch oder die Kamera direkt an der ctrlX CORE. Beide sind in [Hardware-Aufbau für ctrlX X3](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/hardware-setup-for-ctrlx-x3.html) beschrieben.

3. Geben Sie dem Engineering-PC eine freie Adresse im selben Subnetz, zum Beispiel `192.168.1.123`. Verwenden Sie nicht die Adresse des ctrlX-CORE-Anschlusses; bei einer ctrlX CORE X3 hat XF10 die Adresse `192.168.1.1`.

4. Öffnen Sie in der ctrlX-Weboberfläche **Settings > Network Interfaces** und wählen Sie den Anschluss, an dem die Kamera hängt.

5. Prüfen Sie die statische IPv4-Adresse des Anschlusses und schalten Sie DHCP aus.

6. Setzen Sie unter **Advanced settings** die **MTU** auf `8000` oder `9000` und klicken Sie auf **Save**.

   ![Einstellungen der ctrlX-Netzwerkschnittstelle](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/howto-genicam-network.png)

   *Abbildung 1. Netzwerkschnittstelle der ctrlX CORE mit statischer IP-Adresse und MTU*

> [!NOTE]
> Bilder sind groß, deshalb sendet die Kamera sie in Jumbo Frames. Ohne große MTU - am Anschluss der ctrlX CORE und an jedem Switch dazwischen - schlagen Aufnahmen mit dem Statuscode `-10004` (`couldNotCaptureImage`) fehl. Siehe [MTU-Größe ändern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#mtu-size-change).

## Schritt 2 - LumiScan Cam Driver konfigurieren {#step-2-settings}

1. Gehen Sie in der ctrlX-Weboberfläche zu **Home > Manage app data** und klicken Sie auf **Open file view**.

   ![Manage app data](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/howto-genicam-file-view.png)

   *Abbildung 2. Dateiansicht der App-Daten öffnen*

2. Öffnen Sie den Ordner `lumiscan-cam-driver`. Er enthält die Anwendungseinstellungen, die Moduldateien sowie die Ordner `schemas` und `images`.

3. Legen Sie die Moduldatei für Ihre Kamera an, zum Beispiel `camera1.json`. Am einfachsten kopieren Sie die mitinstallierte Beispiel-Moduldatei und ändern diese Werte:
   ```json
   {
     "id": "camera1",
     "serial": "LX123456",
     "exposureTimeUS": 4321,
     "pixelFormat": "RGB8"
   }
   ```
   - `id` - der Name des Moduls auf dem Data Layer. Nur Kleinbuchstaben, Ziffern, `-` und `_`, eindeutig über alle Module.

   - `serial` - die Seriennummer der Kamera, wie sie auf der Kamera steht oder vom Herstellerwerkzeug angezeigt wird.

   - `exposureTimeUS` - Belichtungszeit in Mikrosekunden.

   - `pixelFormat` - `RGB8` oder `Mono8`.

     Behalten Sie die Einträge `$schema` und `meta` der Beispieldatei bei. Alle Parameter sind in [Beispielinhalt einer Kameradatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/camera-example-file-content-example.html) beschrieben.

4. Öffnen Sie `lumiscan-cam-driver.json` und tragen Sie die Moduldatei in die Liste `modules` ein:
   ```json
   "modules": [
     "camera1.json"
   ]
   ```

   Jede Datei der Liste muss existieren, und zwei Module dürfen nicht dieselbe Kamera-Seriennummer verwenden.

   ![lumiscan-cam-driver.json in der Dateiansicht der ctrlX-Weboberfläche](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/howto-genicam-app-settings.png)

   *Abbildung 3. Anwendungseinstellungen mit der Liste der Moduldateien*

5. Klicken Sie auf **Save** und starten Sie LumiScan Cam Driver neu: **Settings > Apps**, **LumiScan Cam Driver** auswählen und auf **Restart** klicken.

> [!TIP]
> Die Einstellungen lassen sich auch auf dem Data Layer lesen und ändern, unter `hdvisionsystems/lumiscan-cam-driver/system/settings`. Siehe [Einstellungen auf dem Data Layer](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html).

## Schritt 3 - Prüfen, ob die Kamera gefunden wird {#step-3-detection}

Öffnen Sie in der ctrlX-Weboberfläche **Settings > Data Layer** und gehen Sie zu `hdvisionsystems/lumiscan-cam-driver/system`. Die im Netzwerk gefundenen Kameras stehen in:

- `found-camera-serials`
- `found-camera-ip-addresses`
- `found-camera-mac-addresses`
- `found-camera-modules`

Die Listen haben dieselbe Reihenfolge: Die erste Seriennummer gehört zur ersten IP-Adresse und zur ersten MAC-Adresse.

![Data-Layer-Browser mit den found-camera-Knoten unter lumiscan-cam-driver/system](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/howto-genicam-found-cameras.png)

*Abbildung 4. Von LumiScan Cam Driver gefundene Kameras*

Erwartet: Die Seriennummer aus Ihrer Moduldatei ist aufgeführt, mit einer IP-Adresse im Subnetz des ctrlX-CORE-Anschlusses. Unter `hdvisionsystems/lumiscan-cam-driver` gibt es einen Ordner mit der `id` Ihres Moduls.

Fehlt die Kamera, prüfen Sie zuerst Verkabelung und Subnetz. Fehlt der Modulordner, lesen Sie `system/settings`: Eine Moduldatei, die nicht gelesen werden konnte, steht dort mit dem Grund.

## Schritt 4 - Die Kamera verbinden {#step-4-connect}

Das Verbinden dauert einige Sekunden und wird deshalb nur als Handshake angeboten. Verwenden Sie diese Knoten:

```
hdvisionsystems/lumiscan-cam-driver/camera1/control/connect-camera/ready
hdvisionsystems/lumiscan-cam-driver/camera1/control/connect-camera/request
```

1. Warten Sie, bis `ready` den Wert `true` hat.
2. Setzen Sie `request` auf `true`.
3. Warten Sie, bis `ready` den Wert `false` hat: Die Anwendung hat die Anforderung gesehen.
4. Setzen Sie `request` wieder auf `false`.
5. Prüfen Sie `hdvisionsystems/lumiscan-cam-driver/camera1/device-info/is-connected`.

Erwartet: `is-connected` ist `true`. Die Kamera ist verbunden und bereit für Aufnahmen.

![Data-Layer-Browser](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/howto-genicam-connect.png)

*Abbildung 5. Knoten von connect-camera und der Verbindungszustand*

> [!NOTE]
> Prüfen Sie die Verbindung mit `is-connected`, nicht mit dem Statuscode. Eine fehlgeschlagene Verbindung zeigt `-10000` auf `control/status/code` nur für etwa 100 ms, danach wieder `0`.

## Schritt 5 - Ein Bild aufnehmen {#step-5-capture}

Am einfachsten ist ein Schreibzugriff auf die Methode `execute`:

1. Schreiben Sie auf `hdvisionsystems/lumiscan-cam-driver/camera1/control/capture/execute`. Der Schreibzugriff kehrt zurück, wenn die Aufnahme beendet ist.
2. Lesen Sie `hdvisionsystems/lumiscan-cam-driver/camera1/control/status/code`.

Erwartet: Der Statuscode ist `0`, und `output/package-identifier` ist um eins gestiegen. Das Bild liegt jetzt auf

```
hdvisionsystems/lumiscan-cam-driver/camera1/output/image
```

mit `data`, `width`, `height` und `pixel-type`. Andere LumiScan-Anwendungen lesen es von dieser Adresse.

![Data-Layer-Browser mit den capture-Knoten und output/image mit data](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/howto-genicam-capture.png)

*Abbildung 6. Knoten von capture und die Bildausgabe*

Sie können auch mit dem Handshake über `control/capture/ready` und `control/capture/request` aufnehmen. Eine fehlgeschlagene Aufnahme endet dann beim Statuscode `3`; siehe [Wann eine Funktion ausgeführt wird](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html#when-a-functionality-runs).

> [!TIP]
> `output/image` enthält Sensor-Rohdaten. Um das Bild anzusehen, öffnen Sie LumiScan Cockpit, oder schalten Sie `camera1/input/preview/enable` ein: Dann liegt nach jeder Aufnahme ein PNG auf `camera1/output/preview/encoded-data` (ab v2.1.0).

## Schritt 6 - Aufgenommene Bilder speichern (optional) {#step-6-save}

Bilder werden nur gespeichert, wenn ein Speicher konfiguriert ist. Er wird im Abschnitt `system` von `lumiscan-cam-driver.json` festgelegt. Für den internen Speicher der Anwendung:

```json
"system": {
  "storage": {
    "type": "Internal",
    "parameters": {
      "rootPath": "images"
    }
  }
}
```

Ein relativer `rootPath` ist ein Ordner im eigenen Verzeichnis der Anwendung. Für ein USB-Speichergerät oder eine SD-Karte verwenden Sie deren Einhängepfad, zum Beispiel `/media/sdb1/myCapturedImages`. Für einen freigegebenen Windows-Ordner verwenden Sie den Typ `Samba`. Alle Möglichkeiten sind in [Speichereinstellungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html#storage-settings) und [Bilddateien speichern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#saving-image-files) beschrieben.

![lumiscan-cam-driver.json mit markiertem Abschnitt storage](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/howto-genicam-storage.png)

*Abbildung 7. Speicher in den Anwendungseinstellungen*

1. Speichern Sie die Datei und starten Sie LumiScan Cam Driver neu.
2. Verbinden Sie die Kamera (Schritt 4) und nehmen Sie ein Bild auf (Schritt 5).
3. Schreiben Sie auf `hdvisionsystems/lumiscan-cam-driver/camera1/control/save/execute`.

Erwartet: Der Statuscode ist `0`, und das Bild erscheint als PNG-Datei im Speicherordner, standardmäßig in einem Unterordner mit dem Namen der Kamera.

## Ergebnis {#result}

- Die Kamera hat eine feste IP-Adresse und wird von LumiScan Cam Driver gefunden.
- Das Kameramodul ist konfiguriert und verbunden.
- Jede Aufnahme legt ein neues Bild auf `hdvisionsystems/lumiscan-cam-driver/camera1/output/image`.
- Aufgenommene Bilder lassen sich im konfigurierten Speicher ablegen.

## Wie es weitergeht {#next-steps}

- Bilder und Ergebnisse in LumiScan Cockpit ansehen.
- Das Bild mit einer anderen LumiScan-Anwendung auswerten: deren Bildadresse auf `hdvisionsystems/lumiscan-cam-driver/camera1/output/image` setzen.
- Kamerafunktionen wie Verstärkung oder Triggermodus unter `camera1/features` einstellen, siehe [GenICam-Features](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#genicam-features).
- Probleme bei Erkennung, Verbindung oder Aufnahme: siehe [Fehlerbehebung](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html).

# Anleitung: Mit Beispielbildern statt einer Kamera testen – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/test-with-example-images.html

Eine **simulierte Kamera** ist ein Kameramodul von LumiScan Cam Driver, das mit keiner Kamera spricht. Jede Aufnahme lädt stattdessen das nächste Bild aus einem Ordner. Für die anderen LumiScan-Anwendungen sieht sie genau wie eine echte Kamera aus: Das Bild erscheint auf denselben Knoten des Data Layer.

Damit richten Sie eine Auswertung - einen Code-Leser, LumiScan Template Finder, LumiScan AI Object Matching - mit bekannten Beispielbildern ein und testen sie, bevor die Kamera montiert ist oder ohne die Linie anzuhalten.

Am Ende liefert ein Modul namens `simulation` Ihre Beispielbilder, eines je Aufnahme, auf `hdvisionsystems/lumiscan-cam-driver/simulation/output/image`.

## Bevor Sie beginnen {#prerequisites}

- LumiScan Cam Driver auf der ctrlX CORE installiert, mit Lizenz, siehe [Voraussetzungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/requirements.html)
- Beispielbilder als PNG-Dateien, am besten mit der Kamera und Beleuchtung aufgenommen, die später verwendet werden
- Ein Browser mit Zugriff auf die ctrlX-Weboberfläche

## Wie es zusammenhängt {#overview}

Ob ein Kameramodul simuliert ist, hängt von seiner `serial` ab: Eine Seriennummer, die `simulation` enthält, lässt das Modul Bilder aus dem Speicherordner abspielen, statt eine Kamera zu suchen. Die `id` ist frei wählbar.

Die Bilder kommen aus dem in `lumiscan-cam-driver.json` konfigurierten Speicherordner, aus einem Unterordner mit der `id` des Moduls: `images/simulation` für die Einstellungen dieser Anleitung. Beim Verbinden durchsucht das Modul diesen Ordner; jede Aufnahme lädt dann das nächste Bild.

> [!NOTE]
> Seit v2.0.0 kommen die Bilder aus dem Unterordner `<id>`, nicht aus dem Speicherordner selbst. Ist `unifiedStorage` in den Systemeinstellungen auf `true` gesetzt (ab v2.2.0), wird der Speicherordner selbst verwendet.

## Schritt 1 - Die Moduldatei anlegen {#step-1-module}

1. Gehen Sie in der ctrlX-Weboberfläche zu **Home > Manage app data** und klicken Sie auf **Open file view**.

   ![Seite Manage app data der ctrlX-Weboberfläche mit der Schaltfläche Open file view](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/howto-simulation-file-view.png)

   *Abbildung 1. Manage app data mit der Schaltfläche Open file view*

2. Öffnen Sie den Ordner `lumiscan-cam-driver`.

3. Legen Sie die Datei `simulation.json` an, zum Beispiel als Kopie der Beispiel-Moduldatei, mit diesen Werten:
   ```json
   {
     "id": "simulation",
     "serial": "simulation"
   }
   ```

   Behalten Sie die Einträge `$schema` und `meta` der Beispieldatei bei.

   ![Moduldatei in der Dateiansicht mit der Seriennummer simulation](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/howto-simulation-module-file.png)

   *Abbildung 2. Moduldatei einer simulierten Kamera: Die Seriennummer enthält simulation*

4. Öffnen Sie `lumiscan-cam-driver.json` und tragen Sie `simulation.json` in die Liste `modules` ein:
   ```json
   "modules": [
     "simulation.json"
   ]
   ```

5. Prüfen Sie, dass `system` einen Speicher enthält, zum Beispiel den internen Speicher:
   ```json
   "storage": {
     "type": "Internal",
     "parameters": {
       "rootPath": "images"
     }
   }
   ```

   Siehe [Speichereinstellungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html#storage-settings).

## Schritt 2 - Die Beispielbilder hochladen {#step-2-images}

1. Öffnen Sie in der Dateiansicht von `lumiscan-cam-driver` den Speicherordner, `images` bei den Einstellungen oben.
2. Legen Sie einen Unterordner an, der genau wie die `id` des Moduls heißt: `simulation`.
3. Laden Sie die Beispielbilder in diesen Ordner hoch.

Die erste Aufnahme lädt das erste Bild des Ordners. Größere Mengen an Bildern laden Sie per WebDAV hoch, siehe [Daten hochladen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/uploading-data.html).

## Schritt 3 - LumiScan Cam Driver neu starten {#step-3-restart}

Wählen Sie unter **Settings > Apps** **LumiScan Cam Driver** aus und klicken Sie auf **Restart**. Die Anwendung liest ihre Einstellungsdateien nur beim Start.

Erwartet: Unter `hdvisionsystems/lumiscan-cam-driver` gibt es einen Ordner `simulation`.

## Schritt 4 - Verbinden und aufnehmen {#step-4-capture}

Werte auf dem Data Layer setzen Sie in der ctrlX-Weboberfläche unter **Settings > Data Layer** oder aus einer anderen Anwendung, zum Beispiel einem SPS-Programm.

1. Verbinden Sie die simulierte Kamera mit dem Handshake auf `hdvisionsystems/lumiscan-cam-driver/simulation/control/connect-camera`: warten, bis `ready` `true` ist, `request` auf `true` setzen, warten, bis `ready` `false` ist, `request` auf `false` setzen.
2. Prüfen Sie, dass `simulation/device-info/is-connected` den Wert `true` hat.
3. Schreiben Sie auf `hdvisionsystems/lumiscan-cam-driver/simulation/control/capture/execute`.

Erwartet: `simulation/control/status/code` ist `0`, und das erste Beispielbild liegt auf `hdvisionsystems/lumiscan-cam-driver/simulation/output/image`. Jede weitere Aufnahme lädt das nächste Bild.

> [!TIP]
> Welches Bild geladen ist, sehen Sie in LumiScan Cockpit. Es zeigt das Bild des Moduls `simulation` wie das einer echten Kamera.

## Schritt 5 - Die Bilder in einer anderen Anwendung verwenden {#step-5-use}

Richten Sie die Bildadresse der auswertenden Anwendung auf die simulierte Kamera:

```
hdvisionsystems/lumiscan-cam-driver/simulation/output/image
```

Bei LumiScan DMC Reader ist das zum Beispiel `input/image-address`, bei LumiScan AI Object Matching `externalImagePath` in der Moduldatei. Um später auf die echte Kamera zu wechseln, ändern Sie nur diese Adresse oder ersetzen die `serial` des Moduls durch die der Kamera.

## Ergebnis {#result}

- LumiScan Cam Driver hat eine simulierte Kamera, `simulation`.
- Jede Aufnahme lädt das nächste Beispielbild auf `hdvisionsystems/lumiscan-cam-driver/simulation/output/image`.
- Andere LumiScan-Anwendungen lassen sich mit diesen Bildern einrichten und testen, ohne Kamera-Hardware.

Mehr zum Simulationsmodus: [FAQ: Wie funktioniert der Simulationsmodus?](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/faq.html#faq-simulation-mode) und [Bilder laden](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#loading-images).

# Kamera-IP-Adresse einrichten – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/setup-camera-ip-address.html

1. Stellen Sie sicher, dass Sie nur ein Kameramodul verwenden, und setzen Sie serial auf **simulation**

2. Starten Sie LumiScan-Cam-Driver neu

3. Alle gefundenen Kameras sehen Sie unter `hdvisionsystems/lumiscan-cam-driver/system/found-camera-serials`

4. Suchen Sie die Seriennummer der Kamera, die Sie einrichten möchten

   Zum Beispiel: GX030303 im Bild oben. Sie steht als erstes Element in der Liste.

5. Kopieren Sie die MAC-Adresse der zugehörigen Kamera.

   Zum Beispiel: GX030303 ist die erste Seriennummer, also kopieren wir die erste MAC-Adresse

6. Setzen Sie die folgenden Parameter (alle Parameter sind in [Tabelle 4: IP-Konfiguration erzwingen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#force-ip-configuration-of-camera) beschrieben):

   a. gateway: 192.168.50.1

   b. macAddress: 00:0C:8D:60:76:5F

   c. ip: 192.168.50.2

   d. subnet: 255.255.255.0

7. Sobald die obigen Parameter gesetzt sind, folgen Sie der [Handshake-Konvention](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html), um force-ip aufzurufen

   a. Warten Sie, bis ready = true ist. Dieser Knoten ist schreibgeschützt und wird von der Anwendung gesetzt.

   b. Setzen Sie request = true

   c. Setzen Sie request = false

Sobald ready wieder true ist, sollten Sie sehen, dass sich der Wert des Knotens system/found-camera-ip-addresses geändert hat.

Falls nicht, verwenden Sie bitte das Programm des Herstellers, um die Kamera-IP zu setzen.

![simulation](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/simulation.png)

![found serials](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/found-serials.png)

![found macs](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/found-macs.png)

# Eine Methode ausführen – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html

Jede Kameraoperation liegt unter derselben Adresse: `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/<operation>/`.

Die meisten Operationen können auf **zwei verschiedene Arten** gestartet werden, und beide führen zum selben Ergebnis:

- Schreiben Sie auf den Methodenknoten **`execute`**. Das führt die Operation einmal aus und kehrt erst zurück, wenn sie abgeschlossen ist. Es ist ein einzelner Schreibvorgang, Ihr Programm muss also keinen Zustand verfolgen.
- Verwenden Sie den **ready/request-Handshake**. Er startet die Operation und kehrt sofort zurück; Ihr Programm beobachtet das Signal `ready`, um zu erfahren, wann die Operation abgeschlossen ist. Siehe [Grundkonzept des Handshakes](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html).

Der Handshake funktioniert für jede Operation außer `trigger`. Die Methode `execute` ist für die meisten, aber nicht für alle Operationen verfügbar.

**Tabelle 1. Startmöglichkeiten jeder Operation**

| Operation | `execute` | ready/request |
| --- | --- | --- |
| `capture` | Ja | Ja |
| `save` | Ja | Ja |
| `load` | Ja | Ja |
| `remove` | Ja | Ja |
| `list-images` | Ja | Ja |
| `connect-camera` | Nein | Ja |
| `disconnect-camera` | Nein | Ja |
| `reset` | Nein | Ja |
| `trigger` | Ja | Nein |

> [!NOTE]
> Connect, Disconnect und Reset werden bewusst nicht als `execute`-Methoden angeboten. Sie können mehrere Sekunden dauern, weil sie die vollständige Verbindung zur Kamera auf- oder abbauen, und `reset` trennt die Verbindung und baut sie neu auf. Ein wartender Methodenaufruf würde meist aufgeben, bevor die Kamera den Erfolg meldet, und dann einen Fehler für eine Operation melden, die tatsächlich funktioniert hat. Verwenden Sie für diese drei bitte den ready/request-Handshake.

## Software-Trigger {#software-trigger}

`hdvisionsystems/lumiscan-cam-driver/<camera name>/control/trigger/execute` sendet der Kamera einen Software-Trigger, aber nur, solange die Kamera im Software-Trigger-Modus ist. In jedem anderen Modus, etwa Hardware-Trigger oder Freilauf, tut der Aufruf nichts und antwortet trotzdem mit `DL_OK`. Die Kamera muss verbunden sein; bis dahin antwortet der Aufruf mit `DL_INVALID_OPERATION_MODE`. Es gibt dafür keinen ready/request- Handshake: Ein Trigger ist sofort vorbei.

Es ist kein Capture. Das Bild geht dorthin, wohin die Aufnahme der Kamera es liefert: in den Bild-Stream, solange dieser läuft. Außerhalb eines Streams wartet das Bild in der Warteschlange der Kamera (**number-of-images-in-queue**), und das nächste Capture nimmt es, sofern die Moduldatei nicht `clearBufferBeforeCapture` setzt.

Solange der Bild-Stream läuft, wird eine Kamera ohne Software-Trigger-Modus - eine simulierte Kamera, die einen Ordner mit Bildern abspielt, oder eine Plugin-Kamera ohne `TriggerSoftware` - stattdessen durch ihren eigenen Trigger ausgelöst: Jeder Aufruf liefert ein Bild auf `control/publish/output/stream/frame`. Siehe [Die Kamera triggern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#triggering).

Software-Trigger-Modus bedeutet, dass der Trigger-Modus der Kamera eingeschaltet und ihre Trigger-Quelle Software ist. Der Cam Driver liest beides in der eigenen Schreibweise der Kamera, genauso wie er sie beim Verbinden setzt: zum Beispiel `On` oder `Triggered` und `Software` oder `SoftwareTrigger`. Bei einer Kamera, die ihre Werte nicht auflisten kann, gelten `On` und `Software` von GenICam.

Der Befehl, der den Trigger auslöst, ist der kameraeigene: `TriggerSoftware` von GenICam oder `SoftwareTrigger` bei einer Kamera, die ihn so nennt. Ist die Kamera im Software-Trigger-Modus, hat aber keinen der beiden Befehle oder lehnt ihn ab, wird der Status `-10012` (`softwareTriggerFailed`).

Eine Kamera, die ihren Befehl, ihren Trigger-Modus oder ihre Trigger-Quelle oder deren Werte anders benennt, erhält ihre eigenen Namen in der Anwendungs-Einstellungsdatei. Fügen Sie unter `featureMappings` ein Feature-Mapping hinzu und benennen Sie es über die `featureMappingId` der Kamera:

```json
"cameras": [
    { "cameraId": "camera1", "serial": "200900623", "driverId": "default", "featureMappingId": "acme" }
],
"featureMappings": [
    {
        "id": "acme",
        "features": { "TriggerSoftware": "FireTrigger" },
        "values": { "TriggerSource_Software": "SW" }
    }
]
```

Unter `features` ist der Schlüssel das allgemeine Feature (`TriggerSoftware`, `TriggerMode`, `TriggerSource`, …) und der Wert der Name, den die Kamera dafür verwendet. Unter `values` ist der Schlüssel der allgemeine Wert (`TriggerSource_Software`, `TriggerMode_On`, …) und der Wert der Eintrag der Kamera dafür. Das Schema listet die Schlüssel auf. Ein gemappter Name wird zuerst versucht. Hat die Kamera ihn nicht, protokolliert der Cam Driver eine Warnung und verwendet seine eingebauten Namen. Eine `featureMappingId`, die kein Mapping benennt, stoppt den Cam Driver beim Start mit einem Fehler, der sie nennt. Ein unbekannter Schlüssel macht die Einstellungsdatei unlesbar: Der Cam Driver protokolliert einen Fehler, der den Schlüssel und die gültigen Schlüssel nennt, und läuft ohne Kameras.

## execute aufrufen {#calling-execute}

Um eine Operation auszuführen, schreiben Sie auf ihren `execute`-Knoten, zum Beispiel:

`hdvisionsystems/lumiscan-cam-driver/<camera name>/control/capture/execute`

Der Schreibvorgang kehrt zurück, sobald die Operation abgeschlossen ist. Zwei Ergebnisse sind auseinanderzuhalten:

- **Ob die Operation überhaupt gestartet werden konnte**, meldet der Schreibvorgang selbst. Ein abgelehnter Schreibvorgang wird nie in eine Warteschlange gestellt, und das Ergebnis sagt, warum. Die Tabelle verwendet die Namen des ctrlX Data Layer; LumiScan Keryx auf einem PC meldet dieselben Ergebnisse als `TooManyOperations`, `InvalidOperationMode` und `ResourceUnavailable`, siehe [Ergebnisse eines Methodenaufrufs](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/status-codes.html#method-results):

  | Ergebnis | Bedeutung | Was zu tun ist |
  | --- | --- | --- |
  | `DL_TOO_MANY_OPERATIONS` | Die Kamera ist gerade mit einer anderen Operation belegt, oder der Bild-Stream startet oder stoppt gerade. | Wiederholen Sie den Aufruf. Derselbe Schreibvorgang gelingt, sobald die laufende Operation abgeschlossen ist. |
  | `DL_INVALID_OPERATION_MODE` | Das Signal `ready` der Operation ist `false`, die Kamera ist also in einem Zustand, in dem diese Operation nicht laufen kann - zum Beispiel `capture`, während die Kamera nicht verbunden ist. | Wiederholen Sie nicht blind; der Aufruf schlägt weiter fehl. Bringen Sie die Kamera zuerst in den erforderlichen Zustand, siehe [Wann eine Operation bereit ist](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html#when-is-an-operation-ready). |
  | `DL_RESOURCE_UNAVAILABLE` | Die Anwendung wird beendet, oder die Einstellungen wurden auf dem Data Layer geändert und ein Neustart ist erforderlich (`status/code` `-5`). | Beim Beenden: nichts, Wiederholen hilft nicht. Neustart erforderlich: Starten Sie die Anwendung neu, siehe [Einstellungen auf dem Data Layer](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html#restart-required). |

- **Ob die Operation erfolgreich war**, wird auf `<camera name>/control/status/code` und `<camera name>/control/status/text` gemeldet. Ein erfolgreicher Schreibvorgang bedeutet also nur, dass die Operation ausgeführt wurde - prüfen Sie danach immer den Statuscode. Anders als der Handshake lässt `capture/execute` den eigenen Code eines fehlgeschlagenen Capture dort stehen; über den Handshake endet ein fehlgeschlagenes Capture bei `3`. Die Bedeutung jedes Werts ist in [Werte des Statuscodes](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#status-code-values) aufgeführt.

Ergebnisse erscheinen in beiden Fällen auf denselben Ausgabeknoten, sodass ein aufgenommenes Bild von `<camera name>/output/image` gelesen werden kann, egal auf welche Art das Capture gestartet wurde.

## Wann eine Operation bereit ist {#when-is-an-operation-ready}

`execute` prüft genau dasselbe Signal `<operation>/ready`, das der Handshake verwendet, und lehnt die Ausführung ab, solange es `false` ist. Das Signal ist keine Formalität - die meisten Operationen hängen von etwas ab, das zuerst geschehen muss:

| Operation | `ready` ist true, wenn |
| --- | --- |
| `capture` | Die Kamera ist verbunden, kein Capture-Fehler ist gespeichert **und** der Bild-Stream läuft nicht. Ein fehlgeschlagenes Capture (zum Beispiel ein Timeout) speichert den Fehler und hält `capture/ready` auf false, bis ein `reset` erfolgreich ist - eine Kamera, die einmal aufgenommen hat und dann fehlgeschlagen ist, lehnt also jedes spätere `capture/execute` ab. Der Bild-Stream hält `capture/ready` nur auf false, solange er läuft und solange die Kamera danach neu verbindet (etwa zwei Sekunden bei der von uns getesteten Kamera); siehe [Capture, während der Stream läuft](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#capture-while-streaming). |
| `save` | Ein Bild ist verfügbar, also nach einem erfolgreichen `capture` oder `load`. Direkt nach dem Start der Anwendung ist es false. |
| `load`, `remove` | `<camera name>/output/image-files` ist nicht leer. Führen Sie zuerst `list-images` aus, oder speichern Sie ein Bild. |
| `list-images` | Immer. |

Da `connect-camera` und `reset` nur über den Handshake verfügbar sind, kann ein Programm, das ausschließlich `execute` verwendet, den Zustand, den `capture` benötigt, nie erreichen. Verbinden Sie (und beheben Sie einen gespeicherten Fehler) über den Handshake, und verwenden Sie dann `execute` für die alltäglichen Operationen.

> [!TIP]
> Wird ein `execute` abgelehnt, lesen Sie `<operation>/ready` zusammen mit `<camera name>/control/status/code` und `.../status/text`. `ready == false` benennt die fehlende Vorbedingung, und der Statustext enthält noch die Meldung des Fehlers, der sie verursacht hat.

## Welche Art Sie wählen sollten {#choosing-between-the-two}

Verwenden Sie **`execute`**, wenn Ihr Programm warten kann, bis die Operation abgeschlossen ist. Das ist die einfachere Option: ein Schreibvorgang, und die Operation ist abgeschlossen, wenn der Schreibvorgang zurückkehrt.

Verwenden Sie den **ready/request-Handshake**, wenn:

- die Operation `connect-camera`, `disconnect-camera` oder `reset` ist, die keine `execute`-Methode anbieten,
- Ihr Programm nicht blockieren darf, während die Kamera arbeitet, oder
- Sie bereits ein funktionierendes Programm haben, das auf dem Handshake aufbaut. Der Handshake ist unverändert und funktioniert weiterhin, er muss also nicht umgeschrieben werden.

# Grundkonzept des Handshakes – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html

Die Kommunikation in der Anwendung LumiScan CamDriver beruht auf dem Grundkonzept des Handshakes. Die Namenskonvention für Handshake-Parameter besteht in der Regel aus der **Funktionalität** und den Namen **-ready** oder **-request**.

Der Handshake funktioniert für jede Operation außer `trigger`. Die meisten Operationen können auch mit einem einzelnen Schreibvorgang auf ihren `execute`-Knoten gestartet werden - siehe [Eine Methode ausführen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html) für einen Vergleich der beiden Arten.

Jede Operation hat einen Knoten `<parent address>/<functionality name>/ready` (schreibgeschützt, von der Anwendung gesetzt: `true`, wenn die Funktionalität gestartet werden darf) und einen Knoten `<parent address>/<functionality name>/request` (beschreibbar, von Ihnen gesetzt, um sie zu starten). Der allgemeine Handshake - seine Adressen, sein Ablauf und seine Regeln - ist in [Handshake](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/handshake.html) beschrieben. Diese Seite beschreibt, wie der Cam Driver ihm folgt.

## Ausführung einer Funktionalität {#functionality-execution}

> [!NOTE]
> Um nicht jedes Mal die gesamte Adresse zu wiederholen, werden in diesem Abschnitt der **unveränderliche Teil** mit der übergeordneten Adresse und der **variable Funktionalitätsname** (capture, connect-camera, disconnect-camera) durch **XXX** ersetzt.\
> Die Adresse **`hdvisionsystems/lumiscan-cam-driver/<camera name>/control/connect-camera/ready`** wird also als **XXX/ready** geschrieben.

Entsprechend wird die Adresse **`hdvisionsystems/lumiscan-cam-driver/<camera name>/control/connect-camera/request`** als **XXX/request** geschrieben.

> [!NOTE]
> Stellen Sie sicher, dass immer nur ein Prozess auf XXX/request zugreift.\
> Das Ergebnis der Ausführung ist **undefiniert, wenn**:

a. Prozess A XXX/request auf True setzt.

b. Prozess B XXX/request auf False setzt, ohne Prozess A zu berücksichtigen.

c. Unsere Anwendung könnte dann XXX/request von Prozess A verpassen.

Um eine Funktionalität auszuführen, führen Sie die folgenden Schritte aus (siehe auch [Schritte zur Ausführung einer Funktionalität](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html#functionality-execution-steps)):

1. Warten Sie, bis XXX/ready auf **True** gesetzt ist.
2. Setzen Sie XXX/request auf **True**.
3. Warten Sie, bis XXX/ready auf **False** wechselt: Die Anwendung hat den Request erkannt.
4. Setzen Sie XXX/request auf **False**.
5. Warten Sie, bis die Funktionalität abgeschlossen ist, und lesen Sie ihren Ausgang: siehe die Tabelle unten.

**Schritte zur Ausführung einer Funktionalität**

```mermaid
%% Der ready/request-Handshake. Mermaid rendert es im Browser; bearbeiten und Vorschau unter https://mermaid.live
sequenceDiagram
  autonumber
  participant C as Client (SPS oder Programm)
  participant M as Modul
  M-->>C: ready = true: die Funktion kann starten
  C->>M: request = true
  M-->>C: ready = false: die Anforderung wurde gesehen
  C->>M: request = false
  Note over M: führt die Funktion aus
  M-->>C: ready = true: die Funktion ist fertig
  C->>M: control/status/code und output/ lesen
```

## Wann eine Funktionalität läuft {#when-a-functionality-runs}

Es wird immer nur ein Request bedient, in dieser Reihenfolge: `reset`, `connect-camera`, `disconnect-camera`, `save`, `capture`, `load`, `list-images`, `remove`.

**Tabelle 1. Wann jede Funktionalität läuft**

| Funktionalität | Läuft | Am Ende |
| --- | --- | --- |
| `capture` | Sofort, sobald die Anwendung den Request erkennt: Sie wartet nicht, bis XXX/request zurückfällt. `status/code` ist `2` (running), solange es läuft, dann `3` (waitingForClient), solange die Anwendung darauf wartet, dass XXX/request zurückfällt. | Erfolg: `status/code` `0`, `capture/ready` **True**, und `output/package-identifier` ist um eins gestiegen.<br> **Fehler: `status/code` bleibt `3`**, nicht der Fehlercode des Capture, und `capture/ready` bleibt **False**, bis ein `reset` erfolgreich ist. |
| `connect-camera`, `disconnect-camera`, `reset`, `save`, `load`, `list-images`, `remove` | Nachdem XXX/request zurückgefallen ist. `status/code` ist bis dahin `3` und `2`, solange sie läuft. | `status/code` `0` oder ein Fehler (unter `0`). |

Ein fehlgeschlagenes `capture`, `reset`, `save` oder `load` bleibt gespeichert: Sein Status bleibt bestehen, bis ein `reset` erfolgreich ist. (Ein `save`, bevor etwas aufgenommen wurde, `-10005`, wird nicht gespeichert.) Jeder andere Fehler steht nur etwa 100 ms auf `status/code`, dann ersetzt ihn `0`. Prüfen Sie also, ob die Kamera verbunden ist, mit `hdvisionsystems/lumiscan-cam-driver/<camera name>/device-info/is-connected`, nicht mit dem Status.

Um den Ausgang eines Capture direkt zu lesen, verwenden Sie stattdessen `control/capture/execute`. Der Status behält dann den eigenen Code des Capture. Siehe [Eine Methode ausführen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html).

# Bilder streamen (experimentell) – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html

> [!IMPORTANT]
> Der Bild-Stream ist **experimentell** (ab v2.3.0). Seine Knoten können sich noch ändern. Verwenden Sie ihn zur Evaluierung, und prüfen Sie ihn mit Ihrer Kamera, bevor Sie sich darauf verlassen.

`capture` liefert ein Bild pro Request, und jeder Request wartet, bis sein Bild eingetroffen ist. Bei der von uns getesteten Kamera ergibt das etwa 34 Bilder pro Sekunde, deutlich weniger, als die Kamera selbst liefern kann: Die nächste Belichtung kann nicht beginnen, bevor das vorherige Bild ausgelesen und gesendet wurde.

Der Bild-Stream arbeitet umgekehrt. Solange er läuft, veröffentlicht der Cam Driver **jedes** Bild, das die Kamera liefert, auf `<camera name>/control/publish/output/stream/frame`. Ihr Programm abonniert diesen Knoten und erhält jedes Bild, sobald es eintrifft - mit seiner Größe, seinem Pixelformat und seiner Herkunft, siehe [Was jeder Frame enthält](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#frames).

Der Stream wird durch eine Funktion ein- und ausgeschaltet, `control/publish`: Setzen Sie ihre Eingaben, und rufen Sie dann `control/publish/execute` auf, um sie anzuwenden. Siehe [Einen Stream betreiben](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#running-a-stream).

Das allgemeine Stream-Konzept - Produzenten, Konsumenten und die Lineage ihrer Ergebnisse - ist in [Streams](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/streams.html) beschrieben. Diese Seite beschreibt den Stream des Cam Driver.

Der Cam Driver triggert die Kamera nicht von selbst. Ein Bild kommt, wenn die Kamera getriggert wird - durch ein Signal an ihrem Trigger-Eingang oder durch `control/trigger/execute` - oder, bei ausgeschaltetem Trigger-Modus der Kamera, so schnell, wie die Kamera läuft. Siehe [Die Kamera triggern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#triggering).

**Tabelle 1. Was ein Abonnent erhält**

| Data Layer | Bilder, die ein Abonnent von `control/publish/output/stream/frame` erhält |
| --- | --- |
| ctrlX Data Layer (ctrlX OS) | Jedes Bild, in Reihenfolge, sobald es veröffentlicht wird, unabhängig vom Publish-Intervall des Abonnements. Bilder werden nur verworfen, wenn der Data Layer weit zurückfällt. |
| LumiScan Keryx (PC) | Jedes Bild, in Reihenfolge. Der Data Layer verwirft Bilder nur, wenn ein Abonnent weit zurückfällt. |

Jeder Frame trägt seine Nummer im Stream, sodass ein Abonnent ein verworfenes Bild als Lücke erkennt. Ein Lesen von `control/publish/output/stream/frame` liefert immer das neueste Bild.

## Adressen {#addresses}

Alle Adressen unten beginnen mit `hdvisionsystems/lumiscan-cam-driver/<camera name>/`. Sie folgen der Regel jeder `execute`-Methode: Die Methode besitzt ihre Knoten, `control/publish/execute`, `control/publish/input/…` und `control/publish/output/…`.

**Tabelle 2. Die Methode und ihre Eingaben**

| Adresse | Typ | Standard | Bedeutung |
| --- | --- | --- | --- |
| `control/publish/execute` | Methode |   | Wendet die folgenden Eingaben gemeinsam an. Eine Eingabe allein zu schreiben ändert nichts. Kehrt sofort zurück: Der Stream startet oder stoppt innerhalb des nächsten Zyklus des Cam Driver, und `control/publish/output/stream/active` zeigt an, wann er läuft. Wird mit `DL_RESOURCE_UNAVAILABLE` abgelehnt, während der Cam Driver beendet wird oder nachdem seine Einstellungen auf dem Data Layer geändert wurden (`system/restart-required`). Wird mit `DL_CREATION_FAILED` abgelehnt, wenn ein geändertes `tag` nicht gespeichert werden kann: Dann ändert sich nichts. |
| `control/publish/input/enable` | bool | `false` | `true` lässt den Stream laufen, solange die Kamera verbunden ist; `false` stoppt ihn. |
| `control/publish/input/keep-latest-output` | bool | `false` | `true` kopiert jedes gestreamte Bild zusätzlich nach `output/image`: `data`, `width`, `height`, `pixel-type` und `timestamp` (die Zeit, zu der das Bild eingetroffen ist), und erhöht dann `output/package-identifier` um eins, wie `capture` es tut. Jede Kopie kostet Zeit, was einen schnellen Stream verlangsamt. Wird auf einen laufenden Stream angewendet, ohne ihn neu zu starten. Siehe [Capture, während der Stream läuft](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#capture-while-streaming). |
| `control/publish/input/tag` | string | `stream.tag` der Modulkonfigurationsdatei, oder leer | Das Tag auf den Bildern des Moduls: Der Schritt der Kamera in ihrer Lineage trägt es, und ebenso die Ergebnisse jeder Anwendung, die sie verarbeitet. Leer: der Kameraname, zum Beispiel `camera1`. Geben Sie ein anderes an, zum Beispiel die Station, auf die die Kamera blickt, um es in jedem Ergebnis zu sehen. Wird auf einen laufenden Stream angewendet, ohne ihn neu zu starten. Siehe [Das Tag](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#tag). |

Was `execute` angewendet hat, wird nicht gespeichert, außer dem Tag: Nach dem Start des Cam Driver ist der Stream aus, bis `control/publish/execute` mit `enable` `true` aufgerufen wird.

**Tabelle 3. Die Ausgaben der Methode, unter `control/publish/`**

| Adresse | Typ | Bedeutung |
| --- | --- | --- |
| `output/stream/active` | bool | `true`, solange der Stream läuft. |
| `output/stream/frame` | flatbuffers (`stream_image`) | Jedes gestreamte Bild: die Pixel, ihre Größe und ihr Format sowie die Lineage des Bildes. Abonnieren Sie ihn, um die Bilder zu erhalten. Siehe [Was jeder Frame enthält](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#frames). |
| `output/stream/width`, `output/stream/height` | uint64 | Größe der gestreamten Bilder in Pixeln, zum Nachsehen. Jeder Frame trägt seine eigene. |
| `output/stream/pixel-type` | string | Pixelformat der gestreamten Bilder, zum Nachsehen. Jeder Frame trägt sein eigenes. |
| `output/stream/statistics/…` | uint64 | Zähler des aktuellen oder letzten Streams, siehe [Die Statistik lesen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#statistics). |

**Tabelle 4. Neben der Methode**

| Adresse | Typ | Bedeutung |
| --- | --- | --- |
| `setting/settings-hash` | string | Der Hash der Einstellungen, mit denen die Bilder aufgenommen werden, als 16 Hexadezimalziffern. Siehe [Der Einstellungs-Hash](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#settings-hash). |
| `setting/stream/tag` | string | Das Tag, das `control/publish/execute` zuletzt angewendet hat, wie die Bilder es tragen. Leer: Die Bilder tragen den Kameranamen. |

### Das Tag {#tag}

Ein geändertes `control/publish/input/tag` wird als `stream.tag` in der Modulkonfigurationsdatei gespeichert, bevor `control/publish/execute` es anwendet; der Rest der Datei bleibt, wie er war. So tragen die Bilder es auch nach einem Neustart, und `control/publish/input/tag` beginnt damit. Kann die Datei nicht geschrieben werden, antwortet `control/publish/execute` mit `DL_CREATION_FAILED`, und weder das Tag noch die anderen Eingaben ändern sich. Ein unverändertes Tag wird nicht gespeichert, sodass ein Modul, dessen Datei nicht geschrieben werden kann, trotzdem streamt.

Das Tag ist nicht Teil des Einstellungs-Hashs: Es benennt die Bilder, es verändert sie nicht.

## Die Kamera triggern {#triggering}

Jeder Trigger, den die Kamera erhält, liefert ein Bild auf `control/publish/output/stream/frame`. Stellen Sie den Trigger-Modus der Kamera ein, bevor Sie den Stream starten, über ihre Feature-Knoten unter `features` oder in einer Feature-Datei.

| Bilder kommen | Kameraeinstellungen | Was zu tun ist |
| --- | --- | --- |
| Bei einem Hardware-Trigger | `TriggerMode` `On`, `TriggerSource` ein Trigger-Eingang, zum Beispiel `Line0` | Senden Sie für jedes Bild einen Impuls an den Trigger-Eingang. |
| Auf Anforderung | `TriggerMode` `On`, `TriggerSource` `Software` | Rufen Sie für jedes Bild einmal `control/trigger/execute` auf. Der Cam Driver sendet den Software-Trigger der Kamera, wie das Feature-Mapping von hdv ihn benennt. |
| Kontinuierlich | `TriggerMode` `Off` | Nichts. Die Kamera liefert so schnell, wie sie läuft, oder mit ihrer `AcquisitionFrameRate`, wo diese aktiviert ist. |

Eine Kamera ohne Software-Trigger-Modus - eine simulierte Kamera, die einen Ordner mit Bildern abspielt, oder eine Plugin- Kamera ohne `TriggerSoftware` - nimmt ebenfalls bei jedem Aufruf von `control/trigger/execute` ein Bild auf.

`control/trigger/execute` antwortet, wenn der Trigger gesendet wurde, nicht, wenn sein Bild eingetroffen ist. Eine Kamera, die noch mit dem vorherigen Bild beschäftigt ist, kann einen Trigger ignorieren, ohne es zu melden, siehe [Für die höchste Bildrate: TriggerOverlap](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#trigger-overlap).

### Für die höchste Bildrate: TriggerOverlap {#trigger-overlap}

Ist das GenICam-Feature `TriggerOverlap` auf `Off` gesetzt, nimmt eine Kamera das nächste Bild erst auf, wenn das vorherige ausgelesen wurde, und ignoriert einen Trigger, der früher kommt. Ein Overlap lässt die nächste Belichtung beginnen, während das vorherige Bild noch ausgelesen oder gesendet wird, was die Bildrate erhöht, die die Kamera erreicht.

**Um mit der höchsten Bildrate zu streamen, darf `TriggerOverlap` nicht `Off` sein.** Setzen Sie es auf einen Overlap, den Ihre Kamera unterstützt - `PreviousFrame` oder `ReadOut`, siehe ihre Dokumentation - in einer Feature-Datei des Kameramoduls, ein Feature pro Zeile:

```none
TriggerOverlap PreviousFrame
```

Tragen Sie die Datei in `cameras[].featureFiles` des Moduls ein. Der Cam Driver wendet sie jedes Mal an, wenn er die Kamera verbindet, bevor die Aufnahme beginnt, sodass sie auch für `capture` gilt. Ein Feature-Knoten unter `features` funktioniert ebenfalls, aber manche Kameras lehnen Trigger-Features ab, während sie aufnehmen, und der Wert geht verloren, wenn die Kamera erneut verbunden wird.

## Was jeder Frame enthält {#frames}

`control/publish/output/stream/frame` enthält eine FlatBuffers-Tabelle vom Typ `stream_image`, auf dem Data Layer registriert als `types/hdvisionsystems/lumiscan-cam-driver/stream_image`. Ihr kompiliertes Schema wird als `bfbs/stream_image.bfbs` installiert.

| Feld | Bedeutung |
| --- | --- |
| `image.data` | Die Pixel, Zeile für Zeile, ohne Padding. |
| `image.width`, `image.height` | Die Bildgröße in Pixeln. |
| `image.pixel_type` | Das Pixelformat, zum Beispiel `Mono8`. |
| `lineage.steps` | Woher das Bild stammt. Bei einem Kamerabild ist das ein Schritt, der der Kamera selbst:<br><br>\* `producer`: die Adresse der Kamera, `hdvisionsystems/lumiscan-cam-driver/<camera name>`. \* `tag`: das Tag des Moduls, `setting/stream/tag`, oder der Kameraname, wenn es leer ist. Siehe [Das Tag](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#tag). \* `run`: wann der Stream gestartet wurde, in Mikrosekunden seit 1970. Jeder Start des Streams ist ein neuer Lauf. \* `sequence`: die Nummer des Bildes im Lauf, ab 1. Eine Lücke bedeutet, dass Bilder unterwegs verloren gingen. \* `external_id`: die eigene Bildnummer der Kamera (die GigE-Vision-Block-ID). Eine Lücke hier ohne Lücke in `sequence` bedeutet, dass Bilder zwischen Kamera und Cam Driver verloren gingen. \* `time_us`: wann das Bild veröffentlicht wurde, in Mikrosekunden seit 1970. \* `settings_hash`: die Einstellungen, mit denen das Bild aufgenommen wurde, siehe [Der Einstellungs-Hash](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#settings-hash). |

Die Anwendungen, die den Stream verarbeiten - AI Object Matching, Calibration - übernehmen die Lineage dessen, was sie empfangen, und fügen einen eigenen Schritt mit ihrem eigenen Tag hinzu. Ihre Ergebnisse benennen deshalb weiterhin das Kamerabild, aus dem sie stammen, über `producer`, `run` und `sequence`, und jeder Schritt sagt über sein `tag`, welches Modul ihn erzeugt hat.

## Der Einstellungs-Hash {#settings-hash}

`setting/settings-hash` und der `settings_hash` jedes Frames identifizieren die Einstellungen, mit denen die Kamera arbeitet. Der Hash ändert sich, wenn sich eine davon ändert:

- die Moduleinstellungen und die Feature-Dateien, mit denen die Kamera verbunden wurde;
- jedes Kamera-Feature, das geschrieben wird, während die Kamera verbunden ist, zum Beispiel `ExposureTime` über `input/exposure-time` oder einen Feature-Knoten unter `features`, mit dem Wert, den die Kamera angenommen hat;
- die Version des Cam Driver.

Einstellungen, die nur den Transport der Bilder betreffen, wie das Timeout oder die Paketgröße, ändern den Hash nicht. Wenn ein Hash zum ersten Mal auftritt, schreibt der Cam Driver die Einstellungen, für die er steht, nach `settings-history/<camera name>-<hash>.json` in seinem Konfigurationsordner, sodass ein in einem Ergebnis gefundener Hash später nachgeschlagen werden kann.

> [!NOTE]
> Eine Kamera nimmt die Bilder, die bereits unterwegs sind, mit den alten Einstellungen auf. Die Bilder, die direkt nach dem Schreiben eines Features eintreffen, können den neuen Hash tragen, obwohl sie vor der Änderung aufgenommen wurden.

### Was der Hash nicht sagt {#settings-hash-limits}

- **Dass, nicht was.** Ein Frame trägt nur den Hash. Ein anderer Hash sagt, dass sich etwas geändert hat, womit die Bilder aufgenommen werden, nicht was sich geändert hat. Um das herauszufinden, vergleichen Sie die beiden Dateien in `settings-history`, die die Hashes benennen, von Hand. Die Dateien liegen auf dem Gerät, auf dem der Cam Driver lief.
- **Nur, was durch den Cam Driver geht.** Der Hash folgt einem Feature-Knoten unter `features`, `input/exposure-time` und den Einstellungen und Feature-Dateien, mit denen die Kamera verbunden wurde. Er folgt nicht Werten, die die Kamera selbst ändert: Bei eingeschaltetem `ExposureAuto` folgt der Hash der Einstellung `ExposureAuto`, nicht den Belichtungszeiten, die die Kamera wählt.

> [!IMPORTANT]
> Dass der Hash einer Änderung eines Kamera-Features folgt, wurde bisher nur in Unit-Tests geprüft, mit einem Ersatz für die Kamera, nicht mit einer echten Kamera. Bis das geschehen ist, verlassen Sie sich nicht allein auf den Einstellungs-Hash der Kamera, um zu erkennen, dass sich ein Kamera-Feature geändert hat.

## Einen Stream betreiben {#running-a-stream}

1. Verbinden Sie die Kamera mit dem Handshake `connect-camera`. Siehe [Verbindungsschritte](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#connection-steps).
2. Setzen Sie die benötigten Kamera-Features, wie die Belichtungszeit, den Trigger-Modus und `TriggerOverlap`, **bevor** Sie den Stream starten. Siehe [Die Kamera triggern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#triggering).
3. Abonnieren Sie `control/publish/output/stream/frame`.
4. Setzen Sie `control/publish/input/enable` auf `true` und `control/publish/input/keep-latest-output` auf `true`, wenn Sie jedes Bild auch auf `output/image` haben möchten.
5. Rufen Sie `control/publish/execute` auf, und warten Sie, bis `control/publish/output/stream/active` `true` ist.
6. Triggern Sie die Kamera. Jedes Bild trifft auf `control/publish/output/stream/frame` ein.
7. Zum Stoppen setzen Sie `control/publish/input/enable` auf `false` und rufen erneut `control/publish/execute` auf. `control/publish/output/stream/active` wird innerhalb des nächsten Zyklus `false`.
8. Bevor Sie wieder aufnehmen, warten Sie, bis `control/capture/ready` `true` ist. Siehe [Nach dem Stream](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#after-the-stream).

Gut zu wissen:

- Die Eingaben wirken erst bei `execute`, alle gemeinsam. Ein Programm kann sie daher in beliebiger Reihenfolge setzen, und nichts ändert sich halb.
- Was `execute` angewendet hat, bleibt bis zum nächsten `execute`: Der Stream läuft, solange `enable` als `true` angewendet wurde und die Kamera verbunden ist. Wird er angewendet, während die Kamera getrennt ist, startet der Stream, sobald die Kamera verbunden ist.
- `connect-camera`, `disconnect-camera` und `reset` stoppen einen laufenden Stream. Wurde `enable` als `true` angewendet, startet der Stream erneut, sobald die Kamera verbunden ist.
- Kann der Stream nicht starten, bleibt `control/publish/output/stream/active` `false`, und der Grund wird in das Protokoll geschrieben. Es wird kein neuer Versuch unternommen, bis `control/publish/execute` erneut aufgerufen wird.
- Eine Kamera ignoriert Trigger, die schneller kommen, als sie Bilder aufnehmen kann, ohne es zu melden. Wenn `statistics/frames` langsamer wächst als die Zahl der gesendeten Trigger, triggern Sie seltener oder setzen Sie einen Overlap, siehe [Für die höchste Bildrate: TriggerOverlap](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#trigger-overlap).
- Die Belichtungszeit auf `input/exposure-time` und das Inter-Packet-Delay werden nicht angewendet, solange der Stream läuft. Ändern Sie Kamera-Features nur, solange der Stream gestoppt ist.

## Capture, während der Stream läuft {#capture-while-streaming}

Der Stream und `capture` nutzen die Kamera auf unterschiedliche Weise, deshalb laufen sie nie gleichzeitig:

- `control/capture/ready` ist `false`, solange der Stream läuft, sodass ein Programm, das den Handshake verwendet, wartet.
- `control/capture/execute` antwortet mit `DL_INVALID_OPERATION_MODE`, solange der Stream läuft, und mit `DL_TOO_MANY_OPERATIONS`, während der Stream startet oder stoppt. Wiederholen Sie `DL_INVALID_OPERATION_MODE` nicht in einer Schleife. Stoppen Sie stattdessen den Stream und warten Sie auf `capture/ready`. Siehe [Eine Methode ausführen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html).
- Ein Capture-Request, der den Cam Driver erreicht, während der Stream läuft, wird mit Status `-3` (`invalidInput`) abgelehnt, mit dem Text "capture refused: the image stream (experimental) is active". Er speichert **keinen** Fehler, es ist also kein `reset` nötig.
- Ein Stream, der eingeschaltet wird, während ein Capture läuft, startet, sobald dieses Capture abgeschlossen ist. Er bricht ein Capture nie ab.

Gestreamte Bilder werden auf `control/publish/output/stream/frame` veröffentlicht. Sie erreichen `output/image` nur, solange `keep-latest-output` als `true` angewendet ist: Dann ersetzt jedes das dortige Bild, und `output/package-identifier` zählt es, wie es ein Capture zählt, fortlaufend ab der Nummer des letzten Capture. `save` speichert auch dann weiterhin das letzte Bild, das mit `capture` oder `load` aufgenommen wurde.

## Nach dem Stream {#after-the-stream}

Während des Streamings liefert die Kamera ihre Bilder in einem anderen Aufnahmemodus als dem, den `capture` verwendet. Um zurückzuschalten, trennt der Cam Driver die Kamera und verbindet sie erneut, wenn der Stream stoppt, und wendet dabei jede Verbindungseinstellung an, wie `connect-camera` es tut. `capture/ready` wird `true`, sobald das abgeschlossen ist. Bis dahin antwortet `capture/execute` mit `DL_TOO_MANY_OPERATIONS`.

Starten und Stoppen dauern deshalb unterschiedlich lang. Bei der von uns getesteten Kamera:

| Schritt | Dauer | Hauptsächlich verwendet für |
| --- | --- | --- |
| Stream starten | etwa 0,35 s | Umschalten des Aufnahmemodus der Kamera. |
| Stream stoppen, bis `capture/ready` wieder `true` ist | etwa 2,2 s | Erneutes Verbinden der Kamera: Öffnen des Geräts (etwa 0,8 s) und Lesen aller seiner GenICam- Features für den Data Layer (etwa 0,8 s). |

Wechseln Sie deshalb so selten wie möglich zwischen Streaming und Capture. Ein Programm, das während des Streamings einzelne Bilder benötigt, kann sie von `control/publish/output/stream/frame` nehmen, statt den Stream zu stoppen, oder `keep-latest-output` anwenden und `output/image` lesen, wenn sich `output/package-identifier` ändert.

## Gemessene Bildraten {#measured-frame-rates}

Diese Werte wurden mit einer LUCID PHX016S (1440 x 1080, Mono8, Belichtung 1 ms) und LumiScan Keryx auf einem PC gemessen. Sie zeigen nur die Größenordnung: Ihre Kamera, Belichtungszeit, Ihr Netzwerk und Ihr Data Layer entscheiden, was Sie erreichen.

Sie wurden gemessen, als der Cam Driver die Kamera noch selbst triggerte, mit fester Rate. Ein Hardware-Trigger oder eine kontinuierlich laufende Kamera sollte dasselbe ergeben. Das Triggern mit `control/trigger/execute` fügt einen Methodenaufruf pro Bild hinzu; das wurde noch nicht gemessen.

| Methode | Gelieferte Bilder pro Sekunde |
| --- | --- |
| `capture/execute` in einer Schleife | etwa 34 |
| Stream, `TriggerOverlap` `Off` | bis zu 63, jedes Bild geliefert |
| Stream, `TriggerOverlap` `PreviousFrame` | bis zu 66, jedes Bild geliefert |
| Was die Kamera selbst liefern kann (`AcquisitionFrameRate`) | 71,7 |

## Die Statistik lesen {#statistics}

Die Zähler unter `control/publish/output/stream/statistics/` beginnen bei jedem Start des Streams bei null und werden etwa viermal pro Sekunde aktualisiert, solange er läuft.

| Zähler | Bedeutung |
| --- | --- |
| `elapsed-ms` | Millisekunden seit dem Start des Streams, gemessen vom Cam Driver. Teilen Sie einen Zähler dadurch, um eine Rate zu erhalten. |
| `frames` | Vollständige Bilder, die die Kamera geliefert hat. |
| `incomplete-frames` | Bilder, die die Kamera unvollständig geliefert hat. Sie werden nicht veröffentlicht. |
| `lost-frames` | Bilder, die den Cam Driver nie erreicht haben, ermittelt aus Lücken in den Bildnummern der Kamera. |
| `published-frames` | Bilder, die auf `control/publish/output/stream/frame` geschrieben wurden. |

# Die Kamera initialisieren – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html

## Data Layer {#data-layer}

LumiScan Cam Driver bietet seine Funktionen auf dem Data Layer unter `hdvisionsystems/lumiscan-cam-driver` an.

Auf ctrlX OS (ctrlX CORE oder ctrlX IPC) nutzt LumiScan Cam Driver den [ctrlX Data Layer](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/ctrlx-data-layer.html).

Auf einem PC mit Windows 11 oder Ubuntu 24.04 nutzt LumiScan Cam Driver [LumiScan Keryx](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/keryx.html).

Knotenadressen, Typen und Aufrufmuster sind auf beiden gleich. LumiScan Cam Driver bietet:

- [ready/request-Handshakes](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/handshake.html)
- [Execute-Methoden](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/execute.html)
- einen [Stream](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/streams.html), der seine Ergebnisse veröffentlicht (experimentell)

Wie Adressen aufgebaut sind, wie Funktionen aufgerufen werden, die Statuscodes und die Werkzeuge sind in [LumiScan Keryx](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/index.html) beschrieben.

## Adressen {#addresses}

Jede Operation bietet einen Knoten `ready` und einen Knoten `request` für den Handshake. Die meisten Operationen bieten außerdem einen Knoten `execute`, der die Operation mit einem einzelnen Schreibvorgang ausführt. Siehe [Eine Methode ausführen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html).

**Tabelle 1. Tabelle 2: Adressen der Funktionalitäten**

| Funktionalität | Zugriff | Adresse |
| --- | --- | --- |
| Capture | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/capture/ready` |
| Capture | Beschreibbar | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/capture/request` |
| Capture | Nur schreiben (Methode) | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/capture/execute` |
| Save | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/save/ready` |
| Save | Beschreibbar | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/save/request` |
| Save | Nur schreiben (Methode) | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/save/execute` |
| Load | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/load/ready` |
| Load | Beschreibbar | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/load/request` |
| Load | Nur schreiben (Methode) | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/load/execute` |
| Remove | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/remove/ready` |
| Remove | Beschreibbar | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/remove/request` |
| Remove | Nur schreiben (Methode) | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/remove/execute` |
| List Images | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/list-images/ready` |
| List Images | Beschreibbar | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/list-images/request` |
| List Images | Nur schreiben (Methode) | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/list-images/execute` |
| Connect Camera | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/connect-camera/ready` |
| Connect Camera | Beschreibbar | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/connect-camera/request` |
| Disconnect Camera | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/disconnect-camera/ready` |
| Disconnect Camera | Beschreibbar | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/disconnect-camera/request` |
| Reset | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/reset/ready` |
| Reset | Beschreibbar | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/reset/request` |
| Status | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/status/code` |
| Status | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/status/text` |
| Set Camera IP | Schreibgeschützt | `hdvisionsystems/lumiscan-cam-driver/system/force-ip/ready` |
| Set Camera IP | Beschreibbar | `hdvisionsystems/lumiscan-cam-driver/system/force-ip/request` |

> [!NOTE]
> Connect Camera, Disconnect Camera und Reset haben keinen Knoten `execute`. Sie können mehrere Sekunden dauern, sodass ein wartender Methodenaufruf meist aufgeben würde, bevor die Kamera den Erfolg meldet. Verwenden Sie für diese drei bitte den ready/request-Handshake.

Die Adressen des experimentellen Bild-Streams, alle unter `<camera name>/control/publish/`, sind in [Bilder streamen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#addresses) aufgeführt.

## Verbindungsschritte {#connection-steps}

1. Start, mit der Kamera verbinden:

   a. Voraussetzung: Die Kamera ist physisch angeschlossen, aber in der Software noch nicht verbunden (XXX/connect-camera/ready = False)

   b. Prüfen Sie XXX/connect-camera/ready = True
      > [!NOTE]
      > Wurde noch kein Bild aufgenommen (package-id ist null), ist **save/ready** **false**.
      - Wird zwischen zwei Aufrufen der Funktion Save kein neues Bild aufgenommen, sendet das Programm trotzdem dieselbe Datei mit demselben Dateinamen.\*

      - Ist die Einstellung korrekt und wurde bereits ein Bild aufgenommen, sendet das Programm das Bild an den konfigurierten Server.

        \\\*Derzeit wird das Bild so benannt:\
        **\<camera_serial>\_\<time stamp in seconds>.<6-digit in seconds>.png**.
        > [!NOTE]
        > Um nicht jedes Mal die gesamte Adresse zu wiederholen, wird in diesem Abschnitt der **unveränderliche Teil** mit der übergeordneten Adresse durch **XXX** ersetzt.\
        > Die Adresse **`hdvisionsystems/lumiscan-cam-driver/<camera name>/control/connect-camera/ready`** wird also als **XXX/connect-camera/ready** geschrieben.

        Entsprechend wird die Adresse **`hdvisionsystems/lumiscan-cam-driver/<camera name>/control/connect-camera/request`** als **XXX/connect-camera/request** geschrieben.
        > [!NOTE]
        > Ist der Wert false, ist die Voraussetzung nicht erfüllt, oder **es wurde keine Kamera gefunden.\
        > Prüfen Sie, ob die Kamera-IP im selben lokalen Netzwerk liegt wie die ctrlX CORE oder der PC.**
        > [!NOTE]
        > Wenn XXX/capture/ready = False:

      - Die Kamera könnte sich in einem Fehlerzustand befinden, nicht gestartet sein oder noch ein Bild aufnehmen.

      - Prüfen Sie den Statuscode für weitere Informationen.
        > [!NOTE]
        > Wenn XXX/capture/ready = True:

        i. Stellen Sie sicher, dass immer nur ein Prozess auf XXX/connect-camera/request zugreift.

        ii. Prüfen Sie, ob Sie dieselbe Data-Layer-Version wie die Kameraanwendung verwenden.

        iii. Kontaktieren Sie HD Vision Systems.

   c. Setzen Sie XXX/connect-camera/request = True

   d. Prüfen Sie XXX/connect-camera/ready = False
      > [!NOTE]
      > Wenn die Anwendung CamDriver nicht erkannt hat, dass sich die Variable geändert hat:

      i. Stellen Sie sicher, dass immer nur ein Prozess auf XXX/connect-camera/request zugreift.

      ii. Prüfen Sie, ob Sie dieselbe Data-Layer-Version wie die Kameraanwendung verwenden.

      iii. Kontaktieren Sie HD Vision Systems.

   e. Setzen Sie XXX/connect-camera/request = False

   f. Prüfen Sie `<camera name>/device-info/is-connected` = True ----→ Die Kamera ist initialisiert und bereit, ein Bild aufzunehmen
      > [!NOTE]
      > Verlassen Sie sich hier nicht auf XXX/status/code. Eine fehlgeschlagene Verbindung zeigt `-10000` nur etwa 100 ms lang; dann ist der Status wieder `0` (ready), obwohl die Kamera weiterhin nicht verbunden ist.

2. Bild aufnehmen

   a. Voraussetzung: Die Kamera ist gestartet (XXX/connect-camera/ready = False)

   b. Prüfen Sie XXX/capture/ready = True

   c. Setzen Sie XXX/capture/request = True

   d. Prüfen Sie XXX/capture/ready = False. Das Capture läuft bereits.

      \\\* Die Bedeutung aller Statuscode-Werte ist in der Tabelle [Werte des Statuscodes](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#status-code-values) erklärt.

   e. Setzen Sie XXX/capture/request = False

   f. Prüfen Sie XXX/status/code (Kamera) = 0 ---→ Die Bildaufnahme war erfolgreich
      > [!NOTE]
      > Ein fehlgeschlagenes Capture lässt XXX/status/code auf `3` (waitingForClient), nicht auf seinem Fehlercode, und XXX/capture/ready bleibt False, bis ein Reset erfolgreich ist. Um den Fehlercode des Capture zu lesen, nehmen Sie stattdessen mit `control/capture/execute` auf. Siehe [Wann eine Funktionalität läuft](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html#when-a-functionality-runs).

   g. Das Bild ist aufgenommen; Sie können es unter der Adresse `hdvisionsystems/lumiscan-cam-driver/<camera name>/output/image` abrufen

3. Kamera trennen

   a. Voraussetzung: Die Kamera ist gestartet und nimmt nicht auf (XXX/disconnect-camera/ready = True (intern wird XXX/connect-camera/ready = False, XXX/capture/ready = True geprüft))

   b. Prüfen Sie XXX/disconnect-camera/ready = True

   c. Setzen Sie XXX/disconnect-camera/request = True

   d. Prüfen Sie XXX/disconnect-camera/ready = False

   e. Setzen Sie XXX/disconnect-camera/request = False

   f. Prüfen Sie `<camera name>/device-info/is-connected` = False ---→ Die Kamera ist getrennt

   g. Die Kamera ist freigegeben. Um sie erneut zu verwenden, führen Sie Connect Camera aus.

## Bilddateien speichern {#saving-image-files}

Für das Speichern von Bildern, die mit dem CamDriver aufgenommen wurden, stehen folgende Optionen zur Verfügung:

- Intern auf dem Systemspeicher
- USB-Speichergerät oder SD-Karte am Gerät (nur die Dateisysteme FAT32 oder EXT4 werden unterstützt) (ab LumiScan CamDriver 1.2.0) (ctrlX OS)
- über einen Samba-Server (freigegebener Windows-Ordner) (ab LumiScan CamDriver 1.0.1)

> [!NOTE]
> Beachten Sie, dass keine Bilder gespeichert werden, wenn die Einstellung nicht oder falsch konfiguriert wurde.

**So konfigurieren Sie ein USB-Speichergerät oder eine SD-Karte (ctrlX OS):**

1. **Schließen Sie das Speichergerät an oder stecken Sie die SD-Karte ein**
2. **Melden Sie sich an der ctrlX-OS-Weboberfläche an**
3. **Wählen Sie Settings**
4. **Wählen Sie Storage Devices**
5. **Wählen Sie in der Liste das Speichergerät, das Sie angeschlossen haben und verwenden möchten.**
6. **Klicken Sie auf die Option mount**

> [!NOTE]
> Verwendet das Speichergerät kein FAT32- oder EXT4-Dateisystem, können Sie es nicht einbinden. Stattdessen wird Ihnen angeboten, das Laufwerk mit einem dieser Dateisysteme zu formatieren. Beachten Sie, dass dabei alle vorhandenen Daten auf dem Speichergerät gelöscht werden.

![mount](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/mount.png)

7. **Wählen Sie im Dialogfeld** **`For data exchange`** **und bestätigen Sie mit einem Klick auf mount**
8. **Der Pfad Ihres Speichergeräts wird in der rechten Spalte angezeigt (z. B.** **`/media/sdb1`****). Notieren Sie sich diesen Pfad.**

![path](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/path.png)

![mountDataExchange](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/mountDataExchange.png)

9. **Sie können die CamDriver-App so konfigurieren, dass sie diesen Pfad verwendet, wie im Abschnitt** [Beispielinhalt der Anwendungs-Einstellungsdatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html) **beschrieben**

So konfigurieren Sie einen externen **Samba**-Speicherordner:

1. Wählen Sie den Ordner, den Sie freigeben möchten.

2. Klicken Sie mit der rechten Maustaste darauf.

3. Wählen Sie **Properties.**

4. Wählen Sie die Registerkarte **Sharing**.

5. Gehen Sie zu **Advanced Sharing.**

   ![ex storage 3](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/ex_storage_3.png)

   ![ex storage 1](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/ex_storage_1.png)

6. Legen Sie ein Windows- oder Samba-Benutzerkonto mit Passwort an.
   > [!NOTE]
   > Für den Zugriff auf den freigegebenen Ordner benötigen Sie ein Windows- oder Samba-Benutzerkonto mit Passwort. **Verwenden Sie aus Sicherheitsgründen bitte nicht Ihr reguläres Benutzerprofil**.\
   > Die Anwendung unterstützt derzeit nur das Speichern des Passworts im Klartext.

7. Klicken Sie auf **Apply**.

8. Klicken Sie auf **OK.**

9. Schließen Sie das Fenster **Advanced Sharing**.

10. Prüfen Sie, ob Sie mit dem konfigurierten Benutzerkonto auf den Ordner zugreifen können.

    So legen Sie ein Konto an:

    a. Klicken Sie auf **Permissions**

    b. Fügen Sie einen Benutzer hinzu

    c. Konfigurieren Sie die Berechtigungen für diesen Benutzer.

       ![ex storage 4](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/ex_storage_4.png)

       ![ex storage 5](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/ex_storage_5.png)
       > [!NOTE]
       > Nach dem Anlegen eines externen freigegebenen Speichers müssen Sie die entsprechenden Änderungen in den Einstellungen in **lumiscan-cam-driver.json** vornehmen. Siehe Abschnitt [Speichereinstellungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html#storage-settings) für weitere Informationen dazu.
       > [!NOTE]
       > Prüfen Sie nach dem Neustart des Programms, ob ein Bild im freigegebenen Ordner liegt. Ist keines vorhanden, prüfen Sie das Protokoll auf Hinweise zu fehlerhaften Einstellungen.

11. Starten Sie das Programm neu.

12. Rufen Sie **Connect Camera** auf.

13. Rufen Sie **Capture** auf.

14. Rufen Sie **Save** auf.

## Bilder laden {#loading-images}

Um Bilddateien zu laden, gehen Sie wie folgt vor:

1. **Speicher einrichten: Führen Sie die Schritte 1–10 im Abschnitt** [Bilddateien speichern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#saving-image-files) **aus, um den Speicherort für das Laden von Bildern zu konfigurieren.**
2. **Führen Sie Connect Camera aus.**
3. **Verwenden Sie den Befehl List Images, um die gespeicherten Bilder anzuzeigen.**
4. **Setzen Sie** **`input/image-index`**, **um das gewünschte Bild anzugeben.**
5. **Führen Sie Load aus, um das Bild in den Data Layer zu übertragen.**
   - **Simulationsmodus: Ist er aktiviert, lädt ein Aufruf von Capture ein Bild aus dem konfigurierten Speicherordner und springt für den nächsten Capture-Befehl automatisch zum nächsten Bild.**

> [!NOTE]
> Weitere Informationen zum Simulationsmodus finden Sie in [Beispielinhalt einer Kameradatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/camera-example-file-content-example.html), wo das Feld **id** erklärt wird.

## Werte des Statuscodes {#status-code-values}

Der aktuelle Status eines Kameramoduls wird auf `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/status/code` als Zahl und auf `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/status/text` als zugehöriger Name veröffentlicht. Er meldet den Ausgang der letzten Operation, egal ob diese Operation mit dem Handshake oder mit einer `execute`-Methode gestartet wurde.

**Tabelle 2. Tabelle 3: Beschreibung der Statuscode-Werte**

| Statuscode-Nummer | String | Bedeutung |
| --- | --- | --- |
| 0 | "ready" | Die letzte Funktionalität wurde erfolgreich ausgeführt, die Anwendung ist bereit, die nächste Funktionalität auszuführen. |
| 1 | "settingUp" | Das Modul oder die Funktion wird noch eingerichtet. |
| 2 | "running" | Die Funktion läuft gerade. |
| 3 | "waitingForClient" | Es wird auf den Client gewartet (in der Regel darauf, dass XXX/request zurückfällt). Auch das Ende eines über den Handshake angeforderten Capture, das fehlgeschlagen ist: siehe [Wann eine Funktionalität läuft](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html#when-a-functionality-runs). |
| -1 | "undefinedError" | Etwas ist schiefgegangen, und es gibt dafür keinen eigenen Fehlercode. |
| -2 | "invalidSetting" | Die angegebene Einstellungsdatei konnte nicht geladen werden. |
| -3 | "invalidInput" | Eines der Eingabefelder war ungültig, oder ein Capture wurde angefordert, während der Bild-Stream läuft. Der zweite Fall speichert keinen Fehler: Stoppen Sie den Stream und nehmen Sie erneut auf. Siehe [Capture, während der Stream läuft](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#capture-while-streaming). |
| -4 | "missingLicense" | Stellen Sie sicher, dass die richtige Lizenz installiert ist. Siehe [Voraussetzungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/requirements.html). |
| -5 | "restartRequired" | Die Einstellungsdateien wurden auf dem Data Layer geändert: Starten Sie die Anwendung neu. Siehe [Einstellungen auf dem Data Layer](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html#restart-required). |
| -10000 | "failedToConnectToCamera" | Beim Verbinden mit der Kamera ist ein Problem aufgetreten; stellen Sie sicher, dass die Kamera angeschlossen ist. |
| -10001 | "pixelFormatNotSupported" | Ungültiges Pixelformat: Tippfehler im Pixeltyp, oder die Kamera unterstützt dieses Pixelformat nicht. |
| -10002 | "couldNotSetPixelType" | Das Pixelformat konnte nicht gesetzt werden. Die Kamera läuft noch; stoppen Sie sie und setzen Sie es erneut. |
| -10003 | "couldNotSetExposureTime" | Die Belichtungszeit liegt außerhalb des zulässigen Bereichs. Erfragen Sie den zulässigen Wertebereich beim Kamerahersteller. |
| -10004 | "couldNotCaptureImage" | Dieses Problem kann mehrere Ursachen haben: \* Die Kamera ist möglicherweise getrennt; verbinden Sie sie erneut. Tritt das häufig auf, kann es sich um einen Kommunikationsfehler durch schlechte Verbindungsqualität handeln. \* Verwenden Sie unbedingt ein „Foil Shielded Twisted Pair"-Kabel. \* ctrlX OS: Prüfen Sie die MTU-Größe in den Einstellungen der ctrlX-Weboberfläche. Sie sollte auf 8000 oder 9000 gesetzt sein.\\\*<br> Können Sie die MTU-Größe nicht ändern, wechseln Sie zu einem Ethernet-Port, der eine große MTU-Größe unterstützt. (Hinweis: Seit 1.16 bzw. 1.18 unterstützt ctrlX das Ändern der MTU.) \* PC: Prüfen Sie die Einstellung der MTU-Größe (Jumbo Frames) des Netzwerkadapters, an dem die Kamera angeschlossen ist. Sie sollte auf 8000 oder 9000 gesetzt sein. |
| -10005 | "noImageTaken" | Es gibt noch kein Bild, mit dem gearbeitet werden kann. Nehmen Sie ein Bild auf, bevor Sie es speichern. |
| -10006 | "saveImageFailed" | Prüfen Sie, ob: \* **ip**, **username**, **password** in der Einstellung korrekt konfiguriert sind, \* die IP von der ctrlX CORE oder dem PC aus erreichbar ist, \* Ihre Samba-Freigabe (freigegebener Ordner) genügend freien Speicherplatz hat. |
| -10007 | "loadImageFailed" | Die ausgewählte Bilddatei konnte nicht geladen werden. Prüfen Sie, ob die Datei noch im Speicherordner vorhanden und lesbar ist. |
| -10008 | "noImageToLoad" | Im Speicherordner liegt kein Bild zum Laden. Verwenden Sie List Images, um zu prüfen, was gespeichert ist. |
| -10009 | "imageIndexOutOfRange" | Der Wert von **index-of-image-to-load** verweist auf kein vorhandenes Bild. Verwenden Sie List Images, um zu prüfen, wie viele Bilder gespeichert sind. |
| -10010 | "removeImageFailed" | Die ausgewählte Bilddatei konnte nicht entfernt werden. Prüfen Sie, ob der Speicherordner beschreibbar ist. |
| -10011 | "producerInitFailed" | Der GenTL-Producer konnte nicht gestartet werden. Prüfen Sie, ob der für diese Kamera konfigurierte Producer installiert ist und sein Pfad korrekt ist. |
| -10012 | "softwareTriggerFailed" | `control/trigger/execute` hat die Kamera im Software-Trigger-Modus vorgefunden, aber die Kamera hat weder `TriggerSoftware` noch `SoftwareTrigger` (noch den Namen aus ihrem Feature-Mapping) oder hat den Befehl abgelehnt. Siehe [Software-Trigger](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html#software-trigger). |

## MTU-Größe ändern (ctrlX OS) {#mtu-size-change}

Dieser Abschnitt gilt für ctrlX OS. Auf einem PC stellen Sie die MTU-Größe (Jumbo Frames) in den Einstellungen des Netzwerkadapters ein, an dem die Kamera angeschlossen ist.

\\\* Wie Sie die MTU-Größe ändern, steht im nächsten Abschnitt [MTU-Größe ändern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#mtu-size-change).

So ändern Sie die MTU-Größe für die Kamera:

1. Melden Sie sich an der ctrlX-OS-Weboberfläche an.

2. Gehen Sie zu **Home.**

3. Wählen Sie **Settings.**

4. Wählen Sie **Network Interfaces.**

   ![s1](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/s1.png)

   ![s11](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/s11.png)

   ![s3ninterf](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/s3ninterf.png)
   > [!NOTE]
   > Die Nummer des aktuell verwendeten Ethernet-Ports finden Sie neben dem Port-Eintrag auf dem ctrlX-Gerät. In diesem Beispiel ist es XF12.

   ![xf12](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/xf12.png)

5. Wählen Sie den aktuell verwendeten Ethernet-Port Ihres ctrlX-Geräts.

7. Klappen Sie **Advanced Settings** auf.

   ![s4nix12](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/s4nix12.png)

   ![s5](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/s5.png)

8. Geben Sie im Feld MTU den gewünschten Wert ein (siehe Statuscode **-10004** in [Werte des Statuscodes](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#status-code-values)).

9. Klicken Sie zur Bestätigung auf **Save**.

10. Eine Meldung bestätigt die Änderung auf dem Bildschirm.

11. Sobald die Änderungen gespeichert sind, können Sie das Programm schließen.

## GenICam-Features {#genicam-features}

So bearbeiten Sie GenICam-Features:

a. Stellen Sie sicher, dass die Kamera, die Sie konfigurieren möchten, wie in [Verbindungsschritte](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#connection-steps) beschrieben verbunden ist.

b. Unter `hdvisionsystems/lumiscan-cam-driver/<cameraname>/features` finden Sie eine Reihe von Unterknoten, die Knoten enthalten. Sie entsprechen den GenICam-Feature-Kategorien und den einzelnen darin enthaltenen Features. Namen, Werte, Schreibrechte und Beschreibungen dieser Knoten werden direkt von der jeweiligen Kamera übernommen. Sie können sich also an den Beschreibungen in der Benutzeroberfläche orientieren.

Weitere Informationen zu diesen Features finden Sie in der Dokumentation Ihres Kameraherstellers.

## IP-Konfiguration der Kamera erzwingen {#force-ip-configuration-of-camera}

![s6](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/s6.png)

![s7](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/s7.png)

Die IP-Konfiguration einer Kamera kann auf bestimmte Werte gesetzt werden. Das ist besonders nützlich, wenn die aktuelle Konfiguration fehlerhaft ist. Die hier beschriebene Methode funktioniert auch, wenn die Kamera normalerweise nicht verbunden oder erkannt wird, solange sie über dieselbe Netzwerkverbindung erreichbar bleibt.

Eine solche Situation kann auftreten, wenn die konfigurierte Subnetz-ID der Kamera nicht mit der Subnetz-ID der ctrlX CORE oder des PCs übereinstimmt. (Die Subnetz-ID ist ein Teil der konfigurierten IP-Adresse. Die Subnetzmaske legt fest, welcher Teil der IP-Adresse die Subnetz-ID darstellt.)

Die für das Erzwingen der IP-Konfiguration einer Kamera relevanten Data-Layer-Adressen finden Sie unter: `hdvisionsystems/lumiscan-cam-driver/system/force-ip/`

Die einzelnen Knoten sind in Tabelle 4 aufgeführt.

So erzwingen Sie die IP-Konfiguration einer Kamera:

1. Setzen Sie die gewünschte IP-Adresse, das Gateway und die Subnetzmaske sowie die MAC-Adresse der Kamera.
2. Setzen Sie das Request-Signal auf **true** und dann wieder auf **false**.

Dieser Ablauf entspricht dem [Grundkonzept des Handshakes](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html).

> [!NOTE]
> Beim Bearbeiten dieser Werte werden sie direkt in die Kamera geschrieben. Seien Sie vorsichtig beim Bearbeiten von Werten, die die Netzwerkverbindung der Kamera betreffen, da dies zu einem Verbindungsverlust führen kann. Beachten Sie, dass das Ändern dieser Werte die Bildaufnahme beeinflussen kann.

> [!NOTE]
> Wenn die CamDriver-App eine Verbindung zu einer Kamera herstellt, versetzt sie die Kamera auch in den Aufnahmemodus. Das beeinflusst, welche Knoten beschrieben werden können.

**Tabelle 3. Tabelle 4: IP-Konfiguration der Kamera erzwingen**

| Name | Beschreibung |
| --- | --- |
| gateway | Das Standard-Gateway, auf das die Kamera gesetzt wird |
| ip | Die statische IP-Adresse, auf die die Kamera gesetzt wird |
| mac address | Die MAC-Adresse der Kamera. Über diese Adresse wird die richtige Kamera identifiziert. |
| subnet | Die Subnetzmaske, auf die die Kamera gesetzt wird |
| request | Das Request-Signal; um das Erzwingen der IP zu starten, setzen Sie es auf true und dann wieder auf false |
| ready | Das Ready-Signal; es zeigt an, dass ein Request gestellt werden kann oder dass einer in Bearbeitung ist. |

## Szenario 1: Kamera, Computer und ctrlX X3 über einen Switch verbinden {#scenario-1-connect-camera-computer-ctrlx-x3-via-switch}

Dieses Szenario gilt für ctrlX OS (ctrlX CORE X3). Siehe auch [Hardware-Aufbau für ctrlX X3](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/hardware-setup-for-ctrlx-x3.html).

1. Öffnen Sie auf der ctrlX X3 `settings/NetworkInterfaces/XF10`

   a. Setzen Sie **General/MTU** auf 8000

   b. Deaktivieren Sie **IPv4/DHCP**

   c. **IPv4/Address**: Stellen Sie sicher, dass 192.168.1.1 eingetragen ist (sollte standardmäßig bereits vorhanden sein)

   d. Klicken Sie auf **save**

# Hardware-Aufbau für ctrlX X3 – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/hardware-setup-for-ctrlx-x3.html

Dieses Kapitel gilt nur für ctrlX OS: Es beschreibt, wie Sie eine Kamera an eine ctrlX CORE X3 anschließen.

## Überblick {#overview}

Die ctrlX X3 und die Kamera können mit einer der folgenden Netzwerktopologien verbunden werden:

| Szenario | Topologie | Hinweise |
| --- | --- | --- |
| [Szenario 1: Gemeinsamer Ethernet-Switch](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/hardware-setup-for-ctrlx-x3.html#scenario-1-shared-switch) | Kamera, Engineering-Computer und ctrlX X3 sind über einen Ethernet-Switch verbunden. | Diese Topologie erleichtert das Auffinden und die Wartung der ctrlX X3. Der Ethernet-Switch muss Jumbo Frames unterstützen. Das Packet Delay des Kameratreibers muss möglicherweise angepasst werden. |
| [Szenario 2: Direkte Kameraverbindung](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/hardware-setup-for-ctrlx-x3.html#scenario-2-direct-camera) | Die Kamera ist direkt an XF10 angeschlossen. Der Engineering-Computer ist an XF51 angeschlossen. | Diese Topologie kann eine stabilere Kameraverbindung bieten. Allerdings wird die ctrlX X3 von ctrlX WORKS möglicherweise nicht automatisch gefunden. Notieren Sie sich die statische Adresse, die XF51 zugewiesen ist. |

## Szenario 1: Verbindung über einen gemeinsamen Ethernet-Switch {#scenario-1-shared-switch}

1. Prüfen Sie, ob der Ethernet-Switch Jumbo Frames unterstützt.

2. Verbinden Sie die Kamera, den Engineering-Computer und den Port XF10 der ctrlX X3 mit dem Ethernet-Switch, wie unten gezeigt.

   ![x3 2](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/x3_-_2.png)

3. Konfigurieren Sie den Ethernet-Adapter des Engineering-Computers mit einer unbenutzten Adresse im Subnetz von XF10.

   Zum Beispiel:
   ```
   IP address: 192.168.1.123
   Subnet mask: 255.255.255.0
   ```
   > [!IMPORTANT]
   > Die ctrlX X3 verwendet `192.168.1.1` auf Port XF10. Weisen Sie `192.168.1.1` weder der Kamera noch dem Engineering-Computer zu. Jedes Gerät muss eine eindeutige IP-Adresse haben.

4. Fahren Sie fort mit [Kameraeinrichtung abschließen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/hardware-setup-for-ctrlx-x3.html#complete-camera-setup).

## Szenario 2: Kamera direkt an XF10 anschließen {#scenario-2-direct-camera}

In dieser Topologie ist die Kamera direkt an XF10 angeschlossen, und der Engineering-Computer verwendet XF51 für den Wartungszugriff.

> [!NOTE]
> Diese Topologie kann eine stabilere Kameraverbindung bieten. Allerdings wird die ctrlX X3 von ctrlX WORKS über XF51 möglicherweise nicht automatisch gefunden. Notieren Sie sich die statische Adresse von XF51, damit Sie die Steuerung direkt in einem Browser erreichen können.

1. Öffnen Sie auf der ctrlX X3 die folgende Seite:

   `Settings > Network Interfaces > XF51 > IPv4`

2. Fügen Sie eine statische IPv4-Adresse für XF51 hinzu und speichern Sie die Konfiguration.

   Zum Beispiel:
   ```
   IP address: 192.168.42.203
   Subnet mask: 255.255.255.0
   ```
   > [!IMPORTANT]
   > Konfigurieren Sie XF51 in einem anderen Subnetz als XF10. XF10 verwendet das Netzwerk `192.168.1.0/24`, daher kann für XF51 eine Adresse aus dem Netzwerk `192.168.42.0/24` verwendet werden. Konfigurieren Sie nicht beide Schnittstellen mit `192.168.1.1`, und legen Sie nicht beide Schnittstellen in dasselbe Subnetz.

   ![x 6](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/x_-_6.png)

3. Schließen Sie die Kamera direkt an Port XF10 an.

4. Schließen Sie den Engineering-Computer an Port XF51 an.

5. Konfigurieren Sie den mit XF51 verbundenen Ethernet-Adapter mit einer unbenutzten Adresse im selben Subnetz wie XF51.

   Zum Beispiel:
   ```
   IP address: 192.168.42.123
   Subnet mask: 255.255.255.0
   ```

6. Öffnen Sie `192.168.42.203` in einem Browser, um auf die ctrlX X3 zuzugreifen.

   ![x 7](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/x_-_7.png)

7. Fahren Sie fort mit [Kameraeinrichtung abschließen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/hardware-setup-for-ctrlx-x3.html#complete-camera-setup).

## Kameraeinrichtung abschließen {#complete-camera-setup}

Nachdem Sie eines der beiden Netzwerkszenarien abgeschlossen haben, führen Sie die folgenden Schritte aus:

1. Folgen Sie [Kamera-IP-Adresse einrichten](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/setup-camera-ip-address.html), um der Kamera eine eindeutige IP-Adresse zuzuweisen.
2. Konfigurieren Sie den LumiScan CamDriver entweder über den Data Layer oder über die Einstellungsoberfläche der ctrlX X3.

### Konfiguration über den Data Layer

![x 4](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/x_-_4.png)

![x 3](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/x_-3.png)

### Konfiguration über die Einstellungen

![x 5.1](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/x_-_5.1.png)

![x 5.2](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/x_-_5.2.png)

### Packet Delay anpassen

Das passende Packet Delay hängt von der gewählten Netzwerktopologie, der Kamera und den Netzwerkkomponenten ab.

Testen Sie verschiedene Werte für das Packet Delay und wählen Sie einen Wert, der eine stabile Bildaufnahme ohne verlorene Pakete oder Kommunikationsunterbrechungen ermöglicht. Notieren Sie den gewählten Wert als Teil der Installationskonfiguration.

# Kamerakonfiguration einrichten – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/setup-camera-configuration.html

Der Cam Driver wird mit zwei Arten von Dateien konfiguriert:

- **`lumiscan-cam-driver.json`** enthält die Anwendungseinstellungen. Hier geben Sie die Konfigurationsdateien für die Kamera an, die Sie verwenden möchten.
- **`<extra file name>`** (hier als Beispiel: camera_example.json) enthält die Konfiguration einer Kamera. Hier konfigurieren Sie die kamerarelevanten Parameter.

Auf ctrlX OS bearbeiten Sie sie in der ctrlX-OS-Weboberfläche, auf einem PC in einem Texteditor.

## Bearbeiten über die integrierte Weboberfläche (ctrlX OS) {#edit-with-built-in-website}

1. Melden Sie sich an der ctrlX-OS-Weboberfläche an.
2. Gehen Sie zu **Home.**
3. Wählen Sie **Manage app data.**

3. Klicken Sie auf die drei Punkte und wählen Sie **File View.**

   ![2a](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/2a.png)

   ![1a](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/1a.png)
   > [!NOTE]
   > Siehe auch [Beispielinhalt der Anwendungs-Einstellungsdatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html)

4. Gehen Sie zum Ordner der betreffenden Anwendung.

5. Standardmäßig gibt es zwei Dateien (Sie können später neue Dateien hinzufügen).
   - **`lumiscan-cam-driver.json`** enthält die Anwendungseinstellungen. Hier geben Sie die Konfigurationsdateien für die Kamera an, die Sie verwenden möchten.
   - **`<extra file name>`** (hier als Beispiel: camera_example.json) enthält die Konfiguration einer Kamera. Hier konfigurieren Sie die kamerarelevanten Parameter.

6. Ein Linksklick auf den gewünschten Dateinamen öffnet automatisch das Fenster JSON Settings.

![2files](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/2files.png)

![configurations](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/configurations.png)

![3a](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/3a.png)

Die Einstellungen der Anwendung LumiScan CamDriver befinden sich in der **`lumiscan-cam-driver.json`**, und hier konfigurieren Sie die allgemeinen Einstellungen der Kamera.\
Ein Beispiel für solche Einstellungen ist unten gezeigt.

Die Beschreibung der oben genannten Parameter finden Sie in der folgenden [Tabelle 5: Anwendungs-Einstellungsdatei: Beschreibung der JSON-Einstellungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html).

## Die Dateien auf einem PC bearbeiten {#edit-on-a-pc}

Auf einem PC sind die Einstellungen Dateien in dem Ordner, aus dem der Cam Driver seine Einstellungen liest (siehe [Daten hochladen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/uploading-data.html#on-a-pc)). Öffnen Sie sie in einem beliebigen Texteditor, vorzugsweise einem, der JSON gegen die Schemas im Ordner `schemas` prüft. Starten Sie den Cam Driver nach dem Speichern neu.

Siehe auch [Beispielinhalt der Anwendungs-Einstellungsdatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html).

# Beispielinhalt der Anwendungs-Einstellungsdatei – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html

> [!NOTE]
> Wenn Sie die Parameter nicht bei jeder Verbindung mit der Kamera neu setzen möchten, können Sie die Kamera auf eine bestimmte Konfiguration festlegen, indem Sie deren Namen angeben.

```json
{
    "meta": {
        "inputFileType": "LumiScan-CtrlX-Cam-Driver",
        "inputFileVersion": "0.0.1",
        "targetMachine": "CtrlX7",
        "programName": "lumiscan-cam-driver",
        "programVersion": "0.0.1"
    },
    "configurations": [
        "camera_example.json"
    ],
    "system":{
        "debug": true,
        "logLevel": "INFO"
    }
}
```

**Tabelle 1. Tabelle 5: Anwendungs-Einstellungsdatei: Beschreibung der JSON-Einstellungen**

| Parameter | Beschreibung |
| --- | --- |
| meta | Ort für Metainformationen: inputFileType und inputFileVersion sind erforderlich. |
| inputFileType | In diesem Fall muss er lauten: `LumiScan-CtrlX-Cam-Driver` |
| inputFileVersion | Derzeit wird nur Version 0.0.1 unterstützt. |
| targetMachine | Optional. Tragen Sie hier den Namen der verwendeten Maschine ein, um anzuzeigen, dass die aktuelle Anwendungskonfiguration für diese Maschine verwendet wird. |
| programName | Optional. Dieser Parameter gibt an, von welcher Anwendung die aktuelle Datei verwendet wird. In diesem Fall: `lumiscan-cam-driver` |
| programVersion | Optional. Aktuell verwendete Programmversion. |
| configurations | Dies ist eine Liste der Kamerakonfigurationsdateien.<br> Kameraseriennummern dürfen nicht doppelt vorkommen. |
| system | Konfiguration, die das Gerät betrifft, auf dem der Cam Driver läuft (ctrlX CORE oder PC). |
| debug | Zeigt detaillierte Meldungen zur Ein-/Ausgabe des Data Layer. Mögliche Werte: **`true`** oder **`false`** |
| logLevel | Ändert den Log-Level; mögliche Werte sind: TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF. |

```json
{
    "meta": {
        "inputFileType": "LumiScan-CtrlX-Cam-Driver",
        "inputFileVersion": "1.0.1",
        "targetMachine": "CtrlX7",
        "programName": "lumiscan-cam-driver",
        "programVersion": "1.0.1"
    },
    "configurations": [
        "camera_example.json"
    ],
    "system": {
        "debug": true,
        "logLevel": "TRACE",
        "storage": {
            "type":"Samba",
            "parameters": {
                "ip": "192.168.31.93",
                "remotePath": "temp",
                "domain": "domainname",
                "username": "username",
                "password": "password"
            }
        }
    }
}
```

## Speichereinstellungen {#storage-settings}

Die JSON-Einstellungen legen auch fest, wo aufgenommene Bilder gespeichert werden. Um diese Einstellungen zu konfigurieren, fügen Sie dem Abschnitt system neue Parameter hinzu. Das Beispiel unten zeigt eine Konfiguration, die Bilder auf einem Samba-Speicher ablegt. Siehe [Bilddateien speichern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#saving-image-files) für Informationen zum Einrichten eines solchen Speichers. Die hinzugefügten Einstellungen sind rot dargestellt.

Verwenden Sie die folgenden Einstellungen, um ein USB-Speichergerät oder eine SD-Karte zu konfigurieren (ctrlX OS). Beachten Sie, dass der Anfang des Pfads mit dem übereinstimmen muss, der Ihnen zuvor beim Einrichten des Speichergeräts angezeigt wurde, wie in [Bilddateien speichern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#saving-image-files) erklärt.

```json
           “storage“:{
                “type“:“Internal“,
                “parameters“: {
                    “rootPath“: “/media/sdb1/myCapturedImages“
                }
            }
```

Die Beschreibung der Speicherparameter finden Sie in der folgenden [Tabelle 6: Beschreibung der Speicherparameter](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html#storage-settings).

**Tabelle 2. Tabelle 6: Beschreibung der Speicherparameter**

| Parameter | Beschreibung |
| --- | --- |
| storage | Ist er nicht angegeben, tut die Funktion save nichts. |
| type | Typ des unterstützten externen oder internen Speichers. Mögliche Werte sind **Null**, **Internal** (interner Speicher; auf ctrlX OS auch ein USB-Speichergerät oder eine SD-Karte) und **Samba** (freigegebener Windows-Ordner) |
| rootPath | Wird nur für den Speichertyp ‚Internal' verwendet. Gibt den Ort an, an dem die Bilddateien gespeichert werden. Ist ein relativer Pfad angegeben (d. h. nicht mit / beginnend), werden die Bilder im internen Verzeichnis der Anwendung LumiScan-Cam-Driver gespeichert. Wird auf ctrlX OS ein Pfad angegeben, der mit dem Pfad eines USB-Speichergeräts oder einer SD-Karte beginnt (z. B. `/media/sdb1/myCapturedImages`), werden die Bilder auf diesem Gerät gespeichert. |
| parameters | Hier: Parameter für den Typ **Samba**. |
| ip | IP des Samba-Servers |
| domain | Domänenname des lokalen Netzwerks.<br><br>Befindet sich der Server in einer Domäne, klären Sie mit Ihrer IT-Abteilung, dass es in der Domäne keine zusätzliche Firewall gibt.<br><br>Gibt es keinen Domänennamen, tragen Sie „“ ein. |
| remotePath | Der Rest des Pfads beim Zugriff auf den freigegebenen Ordner. (Benutzer können direkt mit `//<ip>/<remotePath>` auf den Ordner zugreifen.) |
| username | Benutzername des Samba-Servers (freigegebener Windows-Ordner) |
| password | Das Passwort wird im Klartext gespeichert. Es wird daher nicht empfohlen, einen regulären Benutzer für den Zugriff auf den freigegebenen Ordner zu verwenden. |

> [!NOTE]
> Nach dem Ändern der Parameter sollte die Anwendung LumiScan CamDriver neu gestartet werden.

## Vollständige Referenz {#complete-reference}

Alle Einstellungen dieser Datei, wie sie ihr JSON-Schema `lumiscan-cam-driver.schema.json` festlegt, erzeugt für Version 2.2.1 (Beschreibungen aus dem Schema, auf Englisch):

| Einstellung | Typ | Standard | Zulässige Werte | Beschreibung |
| --- | --- | --- | --- | --- |
| `meta` | object |   |   | **Pflichtangabe.** Meta information about the application and current setting. This is mainly for information purpose and not used by the application itself |
| `meta/inputFileType` | string |   | nicht leer | **Pflichtangabe.** |
| `meta/inputFileVersion` | string |   | nicht leer | **Pflichtangabe.** |
| `meta/targetMachine` | string |   | nicht leer | **Pflichtangabe.** |
| `meta/programName` | string |   | nicht leer | **Pflichtangabe.** |
| `meta/programVersion` | string |   | nicht leer | **Pflichtangabe.** |
| `modules` | string[] |   | mindestens 1 Eintrag | **Pflichtangabe.** List of module setting files that will be loaded by the application. One camera per entry; each file is resolved next to this settings file. |
| `cameraDrivers` | object[] |   |   | GenTL producers (camera drivers) available to camera modules. Each camera references one of these by its 'driverId'. |
| `cameraDrivers[]/id` | string | `default` | nicht leer | **Pflichtangabe.** Unique id referenced by a camera module's 'driverId'. |
| `cameraDrivers[]/gentlPath` | string |   | nicht leer | **Pflichtangabe.** Path to the GenTL producer (.cti). Relative paths resolve from SNAP_COMMON; absolute paths are used as-is. For SIMULATION mode this should be a directory path. |
| `cameraDrivers[]/genTLConsumer` | string | `DEFAULT` | `DEFAULT`, `SIMULATION`, `BASLER`, `BALLUFF`, `LUCID`, `PEPPER_FUCHS` | Type of GenTL consumer. DEFAULT uses Baumer. SIMULATION loads images from directory specified in gentlPath. |
| `system` | object |   |   |   |
| `system/debug` | boolean | `false` |   | Enable debug mode for the application. |
| `system/logLevel` | string | `INFO` | `TRACE`, `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL` | Log level for the application. |
| `system/storage` | object |   |   | Configuration for storage. The storage is used to store the images when save function is called. |
| `system/storage/type` | string |   | `Samba` | **Pflichtangabe.** The storage is a Samba storage. |
| `system/storage/parameters` | object |   |   | Parameters for the storage. The parameters are different for each storage type. |
| `system/storage/parameters/ip` | string |   | nicht leer | **Pflichtangabe.** The IP address of the Samba server. |
| `system/storage/parameters/remotePath` | string |   | nicht leer | **Pflichtangabe.** Share name and path on the Samba server, without the leading host part. |
| `system/storage/parameters/domain` | string |   | nicht leer | **Pflichtangabe.** Windows/Samba domain or workgroup the user belongs to. |
| `system/storage/parameters/username` | string |   | nicht leer | **Pflichtangabe.** |
| `system/storage/parameters/password` | string |   | nicht leer | **Pflichtangabe.** |
| `system/unifiedStorage` | boolean | `false` |   | If true, all cameras will share the same storage folder. If false, each camera will have its own storage folder. |

# Beispielinhalt einer Kameradatei – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/camera-example-file-content-example.html

> [!NOTE]
> Die Kameraparameter können überschrieben werden, indem die entsprechenden Parameter im Pfad `…/input/` auf dem Data Layer gesetzt werden.

Die Einstellungen für eine bestimmte Kamera befinden sich in der **`<extra file name>.json`**, hier als Beispiel benannt: **`camera_example.json`**.\
Ein Beispiel für solche Einstellungen ist unten gezeigt.

```json
{
    "meta": {
        "inputFileType": "camera-configuration",
        "inputFileVersion": "0.0.1",
        "targetMachine": "CtrlX7",
        "programName": "lumiscan-cam-driver",
        "programVersion": "1.0.0"
    },
    "id": "camera1",
    "serial": "LX123456",
    "exposureTimeUS": 4321,
    "pixelFormat": "RGB8"
}
```

Die Beschreibung aller oben genannten Parameter finden Sie in der [Tabelle 7: Beschreibung der JSON-Einstellungen der Beispielkamera](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/camera-example-file-content-example.html#).

**Tabelle 1. Tabelle 7: Beschreibung der JSON-Einstellungen der Beispielkamera**

| Parameter | Beschreibung |
| --- | --- |
| meta | Ort für Metainformationen: inputFileType und inputFileVersion sind erforderlich. |
| inputFileType | In diesem Fall muss er lauten: `camera-configuration` |
| inputFileVersion | Derzeit wird nur Version 0.0.1 unterstützt. |
| targetMachine | Optional. Tragen Sie hier den Namen der verwendeten Maschine ein, um anzuzeigen, dass die aktuelle Anwendungskonfiguration für diese Maschine verwendet wird. |
| programName | Optional. Dieser Parameter gibt an, von welcher Anwendung die aktuelle Datei verwendet wird. In diesem Fall: `lumiscan-cam-driver` |
| programVersion | Optional. Aktuell verwendete Programmversion. |
| id | Dies ist die ID der aktuellen Kameraeinstellung.<br> Sie muss über alle Kameraeinstellungen hinweg **eindeutig** sein.<br><br>Sie ist der Name des Moduls auf dem Data Layer: `hdvisionsystems/lumiscan-cam-driver/<id>/...`. Erlaubt sind nur Kleinbuchstaben, Ziffern, `-` und `_`. Ein Modul, dessen ID einen Großbuchstaben oder ein anderes Zeichen enthält, wird nicht geladen; das Protokoll nennt die ID, die stattdessen zu schreiben ist (`Camera1` → `camera1`).<br><br>Ob die Kamera simuliert wird, hängt von ihrer Seriennummer ab (eine, die `simulation` enthält), nicht von dieser ID. |
| serial | Seriennummer der Kamera. |
| exposureTimeUS | Belichtungszeit in Mikrosekunden. |
| pixelFormat | Pixelformat des Bildes; mögliche Werte sind: RGB8, Mono8. |
| timestampSource | Quelle des Zeitstempels für jeden Frame. **Camera** verwendet den Zeitstempel der Kamera-Hardware, **System** die Systemuhr des Geräts, auf dem der Cam Driver läuft (ctrlX CORE oder PC). |
| stream.tag | Optional, experimentell. Das Tag auf den Bildern des Bild-Streams des Moduls; leer oder weggelassen: die Modul-ID. `control/publish/execute` speichert es hier, wenn es sich ändert. Siehe [Das Tag](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#tag). |

> [!NOTE]
> Nach dem Ändern der Parameter sollte die Anwendung LumiScan CamDriver neu gestartet werden.

> [!NOTE]
> Auf ctrlX OS können Sie die neue Datei auch später umbenennen, indem Sie auf die drei Punkte rechts neben dem Namen klicken und in der aufgeklappten Liste **Rename** wählen.

## Vollständige Referenz {#complete-reference}

Alle Einstellungen dieser Datei, wie sie ihr JSON-Schema `lumiscan-cam-driver-module.schema.json` festlegt, erzeugt für Version 2.2.1 (Beschreibungen aus dem Schema, auf Englisch):

| Einstellung | Typ | Standard | Zulässige Werte | Beschreibung |
| --- | --- | --- | --- | --- |
| `meta` | object |   |   | **Pflichtangabe.** |
| `meta/inputFileType` | string |   | nicht leer | **Pflichtangabe.** |
| `meta/inputFileVersion` | string |   | nicht leer | **Pflichtangabe.** |
| `meta/targetMachine` | string |   | nicht leer | **Pflichtangabe.** |
| `meta/programName` | string |   | nicht leer | **Pflichtangabe.** |
| `meta/programVersion` | string |   | nicht leer | **Pflichtangabe.** |
| `id` | string |   | Muster `^[a-zA-Z0-9_-]+$` | **Pflichtangabe.** only [a-Z], [0-9], '-' and '\_' are allowed. Unique ID of the camera configuration. This is used to identify different camera on datalayer. |
| `serial` | string | `simulation` | nicht leer | **Pflichtangabe.** Serial number of the camera. Special serial 'simulation' is used for testing without camera. This is used as default value in setting. And storage setup is required to be able to load image for simulation. |
| `exposureTimeUS` | number | `10000` | 500 … 2000000 | **Pflichtangabe.** Exposure time in microseconds. This is used as default value on datalayer and can be overwriten by the user. |
| `pixelFormat` | string |   | `Mono8`, `RGB8`, `BGR8`, `Mono12`, `RGB12`, `BGR12`, `BayerGR8`, `BayerRG8` | **Pflichtangabe.** Pixel format of the camera. Use bayer format if the camera support color and faster frame rate is required. This is used as default value on datalayer and can be overwriten by the user. |
| `exportPixelFormat` | string |   | `Mono8`, `RGB8`, `BGR8`, `Mono12`, `RGB12`, `BGR12` | Pixel format of the exported image. This is used as default value on datalayer and can be overwriten by the user. |
| `packetSize` | number | `1496` | 576 … 9000 | Size of the packet in bytes, must be multiple of 8. Please confirm it matches the configured MTU of the network. Default is 1496 bytes. This is used as default value on datalayer and can be overwriten by the user. It is only writeable only before camera is connected. |
| `packetDelay_us` | number | `0` | 0 … 12449 | Delay between packets in microseconds. Default is 0 microseconds. Increase it if image is corrupted or faild to capture image. This is used as default value on datalayer and can be overwriten by the user. |
| `timeout_ms` | number | `2000` | 100 … 10000 | Timeout in milliseconds. Default is 2000 milliseconds. How long to wait for the image to be captured before giving up. This is used as default value on datalayer and can be overwriten by the user. |
| `initialFeatureFile` | string |   |   | path to feature file with \<FEATURENAME> \<FEATURE VALUE> pairs. These values will be set after connect to camera. |
| `timestampSource` | string | `Camera` | `Camera`, `System` | Source of the timestamp for each frame. 'Camera' uses the timestamp provided by the camera hardware, while 'System' uses the system clock of the ctrlX. |
| `clearBufferBeforeCapture` | boolean | `false` |   | If true, the buffer will be cleared before capture, this is useful when the camera is running in continuous mode and we want to get the latest image. |
| `driverId` | string | `default` | nicht leer | Id of a GenTL driver defined in the app settings 'cameraDrivers' array. Defaults to 'default' (the built-in Baumer producer). |

# Neue Kamera-Einstellungsdateien anlegen – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/creating-new-camera-settings-files.html

Sie legen eine neue Datei mit Kameraeinstellungen an, indem Sie eine vorhandene unter neuem Namen kopieren, und geben dann den neuen Dateinamen in den Anwendungseinstellungen (`lumiscan-cam-driver.json`) an. Wie das geht, hängt von der Plattform ab.

## Auf ctrlX OS {#on-ctrlx-os}

Sie können eine neue Datei mit Kameraeinstellungen einfach anlegen, indem Sie eine vorhandene Datei duplizieren. Gehen Sie dazu wie folgt vor:

1. Klicken Sie auf die drei Punkte rechts neben dem Dateinamen.

2. Wählen Sie **COPY**

3. Das Fenster zum Kopieren der Datei erscheint.

4. Geben Sie den neuen Dateinamen ein.

5. Bestätigen Sie mit einem Klick auf **Copy.**

6. Die neue Kamera-Einstellungsdatei ist angelegt.

7. Nun können Sie den Namen der neu angelegten Datei in den Anwendungseinstellungen (lumiscan-cam-driver.json) angeben:

   ![copywindow](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/copywindow.png)

   ![cameraexample3dots](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/cameraexample3dots.png)

8. Speichern Sie die Änderungen.

   a. Klicken Sie mit der linken Maustaste auf den Dateinamen lumiscan-cam-driver.json.

   b. Rechts öffnet sich das Fenster JSON settings.

   c. Tragen Sie den Namen im Feld `configuration` ein.

![camdriverjson](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/camdriverjson.png)

![configurationsdet](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/configurationsdet.png)

## Auf einem PC {#on-a-pc}

Sie können eine neue Datei mit Kameraeinstellungen anlegen, indem Sie eine vorhandene im Einstellungsordner unter neuem Namen kopieren. Geben Sie dann den neuen Dateinamen im Feld `configuration` der Anwendungseinstellungen (`lumiscan-cam-driver.json`) an und starten Sie den Cam Driver neu.

### Mit einem Beispiel beginnen {#starting-from-an-example}

Der Cam Driver schreibt ein Beispiel seiner Einstellungsdateien zusammen mit ihren Schemas in einen Ordner Ihrer Wahl und beendet sich, ohne zu starten. Zum Beispiel (Windows):

```shell
lumiscan-cam-driver --generate-settings C:\work\cam-driver-settings
```

Ohne Ordner (`-g` allein) schreibt er in den aktuellen Ordner. Das Beispiel besteht aus der Anwendungs- Einstellungsdatei `lumiscan-cam-driver.json` mit einer simulierten Kamera, ihrer Moduldatei `lumiscan-cam-driver-example-module.json` und den vier Schemas in `schemas\`, mit denen ein Editor sie prüft. Vorhandene Dateien werden nie überschrieben: Liegt eine davon bereits im Ordner, wird nichts geschrieben, und der Cam Driver nennt die betreffende Datei.

Der Cam Driver nennt dann den Ordner, aus dem er seine Einstellungen liest. Unter Windows ist das standardmäßig `C:\ProgramData\HD Vision Systems GmbH\LumiScan Vision Suite\lumiscan-cam-driver\etc\lumiscan-cam-driver`. Bearbeiten Sie das Beispiel, kopieren Sie es dorthin, und starten Sie den Cam Driver.

Ein Modul kann auch auf dem Data Layer hinzugefügt werden, auf ctrlX OS und auf einem PC: siehe [Module hinzufügen und entfernen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html#adding-and-removing-modules).

# Einstellungen auf dem Data Layer – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html

## Data Layer {#data-layer}

LumiScan Cam Driver bietet seine Funktionen auf dem Data Layer unter `hdvisionsystems/lumiscan-cam-driver` an.

Auf ctrlX OS (ctrlX CORE oder ctrlX IPC) nutzt LumiScan Cam Driver den [ctrlX Data Layer](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/ctrlx-data-layer.html).

Auf einem PC mit Windows 11 oder Ubuntu 24.04 nutzt LumiScan Cam Driver [LumiScan Keryx](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/keryx.html).

Knotenadressen, Typen und Aufrufmuster sind auf beiden gleich. LumiScan Cam Driver bietet:

- [ready/request-Handshakes](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/handshake.html)
- [Execute-Methoden](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/execute.html)
- einen [Stream](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/streams.html), der seine Ergebnisse veröffentlicht (experimentell)

Wie Adressen aufgebaut sind, wie Funktionen aufgerufen werden, die Statuscodes und die Werkzeuge sind in [LumiScan Keryx](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/index.html) beschrieben.

LumiScan Cam Driver zeigt die Einstellungen, mit denen er gestartet wurde, auf dem Data Layer an, auf `hdvisionsystems/lumiscan-cam-driver/system/settings`. Sie können sie dort ohne Zugriff auf den Konfigurationsordner lesen und dort ändern: Die Anwendung prüft eine Änderung, speichert sie in ihren Einstellungsdateien und verlangt einen Neustart. `hdvisionsystems/lumiscan-cam-driver/system/control/restart/execute` startet sie neu.

Für einen Überblick über den Knoten `system` in allen LumiScan-Apps siehe [Einstellungen, Module und Neustart](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/settings-and-modules.html).

## Was der Knoten zeigt {#what-the-node-shows}

`settings` enthält ein JSON-Dokument, als Text:

- die Anwendungs-Einstellungsdatei `lumiscan-cam-driver.json`, wie sie gelesen wurde;
- in ihrer Liste `modules` den Inhalt jeder Modulkonfigurationsdatei anstelle des Dateinamens. `"$file"` nennt die Datei, aus der jedes Modul stammt;
- eine Moduldatei, die nicht gelesen werden konnte, erscheint als `{"$file": ..., "$error": ...}`, wobei `"$error"` den Grund nennt. Das ist auch der Grund, warum das Modul nicht gestartet ist;
- jeder Wert mit dem Namen `password` wird als `"***"` angezeigt.

Zum Beispiel:

```json
{
  "$schema": "schemas/lumiscan-cam-driver.schema.json",
  "meta": { ... },
  "modules": [
    {
      "$file": "lumiscan-cam-driver-example-module.json",
      "$schema": "schemas/lumiscan-cam-driver-module.schema.json",
      "id": "camera1",
      "serial": "simulation",
      "exposureTimeUS": 6000,
      ...
    }
  ],
  "system": { ... }
}
```

Kommentare in den Dateien werden nicht angezeigt.

Der Knoten zeigt die Dateien so, wie die Anwendung sie beim Start gelesen hat. Der Cam Driver liest seine Dateien nur beim Start.

## Die Einstellungen ändern {#changing-the-settings}

Lesen Sie `settings`, ändern Sie, was Sie benötigen, und schreiben Sie das gesamte Dokument zurück. Dabei gelten diese Regeln:

- Jedes Modul behält sein `"$file"`. Es muss eine der Moduldateien der Anwendung benennen: Ein Modul kann hier nicht hinzugefügt werden. Wie Sie eines hinzufügen, siehe [Module hinzufügen und entfernen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html#adding-and-removing-modules).
- Ein Modul, das in `modules` weggelassen wird, ist in `lumiscan-cam-driver.json` nicht mehr aufgeführt. Seine Datei bleibt, wo sie ist.
- `"***"` als Passwort behält das Passwort, das die Datei enthält. Jeder andere Wert ersetzt es.
- Eine Datei, deren Inhalt sich nicht ändert, wird nicht geschrieben. Eine geänderte Datei wird nur dort geändert, wo sich ihr Inhalt geändert hat: Kommentare und Layout bleiben erhalten. Ein neuer Schlüssel oder ein neues Listenelement kommt hinter das letzte vorhandene; ein entfernter Schlüssel verschwindet mit seiner Zeile, einschließlich eines Kommentars in dieser Zeile. Nur ein Objekt, das sowohl Schlüssel gewonnen als auch verloren hat, oder eine Liste, die ein Element verloren hat, wird neu geschrieben, ohne die Kommentare darin. Die vorherige Datei bleibt daneben als `<file>.bak` erhalten.
- Ein Schlüssel wie `"_comment"` ist Inhalt wie jeder andere, wird also angezeigt und behalten.

Die Anwendung prüft die Änderung, bevor etwas geschrieben wird: Die Anwendungs-Einstellungsdatei und jede geänderte Kamera-Einstellungsdatei müssen sich als die Einstellungen lesen lassen, für die sie stehen, mit den richtigen Namen und Typen. Ob die Kamera gefunden werden kann oder einen Wert annimmt, zeigt sich erst beim nächsten Start. Eine Änderung, die die Prüfung ablehnt oder die kein gültiges JSON ist, wird mit `DL_INVALID_VALUE` (ctrlX Data Layer) oder `Rejected` (LumiScan Keryx) beantwortet. Der Grund steht im Protokoll, und nichts wird geschrieben.

Eine Änderung, die nichts schreibt, antwortet mit `DL_OK` und ändert nichts.

### Neustart erforderlich {#restart-required}

Eine gespeicherte Änderung wirkt erst beim nächsten Start. Bis dahin läuft die Anwendung mit Einstellungen, die nicht mehr die ihrer Dateien sind, und stellt deshalb ihre Arbeit ein:

- `hdvisionsystems/lumiscan-cam-driver/system/restart-required` ist `true`;
- `hdvisionsystems/lumiscan-cam-driver/system/status-text` nennt die geänderten Dateien;
- jedes Modul meldet Status `-5` (`restartRequired`). Es beantwortet keinen Request, und seine `ready`-Signale sind `false`;
- jede `execute`-Methode eines Moduls antwortet mit `DL_RESOURCE_UNAVAILABLE`. Das schließt `reset` ein, das sonst einen Teil der neuen Einstellungen laden würde;
- ein laufender Bild-Stream stoppt.

Nur ein Neustart beendet diesen Zustand. Ein Reset nicht. Das Protokoll enthält die Meldung auf Fehlerebene.

Weitere Änderungen sind in der Zwischenzeit möglich. Nach einer Änderung zeigt `settings` die Dateien, wie sie gespeichert sind - das, was der nächste Start lädt, nicht das, womit die Anwendung läuft.

Konnte eine Datei nicht gespeichert werden, antwortet der Schreibvorgang mit `DL_CREATION_FAILED`. Davor geänderte Dateien bleiben geändert, sodass die Anwendung trotzdem einen Neustart benötigt. Korrigieren Sie die Dateien, und starten Sie dann neu.

## Module hinzufügen und entfernen {#adding-and-removing-modules}

Drei Methoden von `hdvisionsystems/lumiscan-cam-driver/system` verwalten Module, jede unter `control/<method>/`, wie auch `control/restart`. Jede nimmt die ID des Moduls, den Namen seiner Datei ohne `.json`, in `control/<method>/input/module-id` entgegen:

| Methode | Was sie tut |
| --- | --- |
| `create-module` | Schreibt die Moduldatei `<module-id>.json` mit dem JSON aus `control/create-module/input/content`. Die Anwendung prüft es so, wie sie eine geänderte Moduldatei prüft. Das Modul ist noch nicht aktiv, es muss also nichts neu gestartet werden. Eine vorhandene Datei wird nicht überschrieben: Ändern Sie sie über `settings`. |
| `activate-module` | Fügt `<module-id>.json`, die vorhanden sein muss, der Liste `modules` hinzu, nachdem die Anwendung das Modul geprüft hat. Es läuft ab dem nächsten Start, die Anwendung benötigt dann also einen Neustart (siehe [Neustart erforderlich](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html#restart-required)). |
| `deactivate-module` | Nimmt `<module-id>.json` aus der Liste `modules`. Die Datei bleibt erhalten, sodass `activate-module` sie wieder aufnehmen kann. Es stoppt mit dem nächsten Start, die Anwendung benötigt dann also einen Neustart. |

Jede Methode meldet auf `control/<method>/output/status-code` und `control/<method>/output/status-text`:

| Code | Bedeutung |
| --- | --- |
| 1 | Erledigt. |
| -2 | Die Eingabe oder das Modul wurde abgelehnt: `status-text` nennt den Grund. Nichts wurde geschrieben. |
| -6 | Eine Datei konnte nicht geschrieben werden. |
| -9 | `activate-module`: Es gibt keine solche Datei. `deactivate-module`: Das Modul ist nicht aktiv. |
| -10 | `create-module`: Die Datei existiert bereits. `activate-module`: Das Modul ist bereits aktiv. |

Die Methode antwortet mit `DL_OK`, wenn sie erledigt ist, mit `DL_INVALID_VALUE`, wenn sie abgelehnt hat, und mit `DL_CREATION_FAILED`, wenn eine Datei nicht geschrieben werden konnte (Namen des ctrlX Data Layer; LumiScan Keryx antwortet mit `Ok`, `Rejected` und `CreationFailed`, siehe [Ergebnisse eines Methodenaufrufs](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/status-codes.html#method-results)). Um zum Beispiel das Modul `camera2` hinzuzufügen:

1. Schreiben Sie das JSON des Moduls auf `hdvisionsystems/lumiscan-cam-driver/system/control/create-module/input/content` und `camera2` auf `control/create-module/input/module-id`, und rufen Sie dann `control/create-module/execute` auf.
2. Schreiben Sie `camera2` auf `control/activate-module/input/module-id`, und rufen Sie dann `control/activate-module/execute` auf.
3. Rufen Sie `hdvisionsystems/lumiscan-cam-driver/system/control/restart/execute` auf.

## Die Anwendung neu starten {#restarting}

`hdvisionsystems/lumiscan-cam-driver/system/control/restart/execute` beendet die Anwendung und startet sie erneut. Sie liest ihre Einstellungsdateien neu ein, wodurch auch von Hand an den Dateien vorgenommene Änderungen wirksam werden, und beendet `restart-required`.

- **Auf ctrlX OS:** Die Anwendung wird beendet, und ctrlX OS startet sie nach etwa fünf Sekunden erneut.
- **Auf einem PC:** Die Anwendung startet sich selbst erneut, sobald sie alles freigegeben hat, was sie belegt hatte. Sie verwendet dasselbe Programm, dieselben Argumente und denselben Arbeitsordner. Es ist ein neuer Prozess in derselben Konsole, und seine Ausgabe geht dorthin, wohin die des ersten ging.

Die Methode antwortet mit `DL_OK`, sobald der Neustart begonnen hat. Die Knoten der Anwendung verschwinden dann, bis sie wieder läuft: Warten Sie, bis `hdvisionsystems/lumiscan-cam-driver/system/restart-required` wieder gelesen werden kann.

> [!NOTE]
> Ein Neustart ist nicht an eine Änderung gebunden. Er startet auch eine Anwendung neu, deren Einstellungen sich nicht geändert haben.

## JSON-Schemas {#json-schemas}

Die Anwendung legt die JSON-Schemas ihrer Einstellungsdateien in ihrem Ordner `schemas` ab; diese Kopien passen immer zur installierten Version. Die Schemas von LumiScan Cam Driver 2.2.1 stehen außerdem zum Download bereit: [JSON-Schemas von LumiScan Cam Driver 2.2.1](https://docs.hdvisionsystems.com/schemas/lumiscan-cam-driver/2.2.1/index.html).

Damit ein Editor wie Visual Studio Code eine Kopie einer Einstellungsdatei prüft, die Sie auf Ihrem PC bearbeiten, lassen Sie deren Eintrag `$schema` auf das veröffentlichte Schema zeigen:

```json
{
  "$schema": "https://docs.hdvisionsystems.com/schemas/lumiscan-cam-driver/2.2.1/lumiscan-cam-driver.schema.json",
  ...
}
```

Lassen Sie den Eintrag `$schema` der Dateien auf dem Gerät so, wie die Anwendung ihn geschrieben hat.

# Daten hochladen – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/uploading-data.html

Wie die Einstellungsdateien zum Cam Driver gelangen, hängt von der Plattform ab. Auf beiden können sie auch auf dem Data Layer geändert werden, siehe [Einstellungen auf dem Data Layer](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html).

## Auf ctrlX OS {#on-ctrlx-os}

> [!NOTE]
> Die meisten Daten können direkt über die ctrlX Web UI hochgeladen werden. Verwenden Sie WebDAV nur, wenn ein direkter Upload nicht verfügbar ist oder wenn Sie auf die Ordnerstruktur der Anwendung zugreifen müssen.

![ctrlx web ui upload](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/ctrlx-web-ui-upload.png)

Das Hochladen einer Konfiguration ist optional und kann verwendet werden, um eigene Anwendungseinstellungen hochzuladen.

1. Gehen Sie auf die Website von WinSCP.

2. Laden Sie die neueste Version von WinSCP herunter und installieren Sie sie.

3. Starten Sie WinSCP.

4. Wählen Sie auf der Anmeldeseite **WebDAV** als **File protocol**.

5. Wählen Sie **TLS/SSL** für **Encryption**.

6. Geben Sie Ihren **user name** und Ihr **password** ein.

   ![WinSCP](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/WinSCP.png)

   ![dav1](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/dav1.png)

7. Navigieren Sie zu **/solutions/webdav/appdata**.

8. Die Ordnerstruktur der Anwendung wird im rechten Bereich angezeigt.

Sie können Daten und Einstellungen per Drag-and-drop in den entsprechenden Anwendungsordner ziehen.

Eine Beispielkonfiguration finden Sie in [Beispielinhalt der Anwendungs-Einstellungsdatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html).

![dav3](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/dav3.png)

![dav2](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/dav2.png)

## Auf einem PC {#on-a-pc}

Auf einem PC sind die Einstellungsdateien gewöhnliche Dateien. Kopieren Sie sie in den Ordner, aus dem der Cam Driver seine Einstellungen liest. Der Cam Driver nennt diesen Ordner, wenn er ein Beispiel seiner Einstellungen schreibt, siehe [Mit einem Beispiel beginnen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/creating-new-camera-settings-files.html#starting-from-an-example). Unter Windows ist das:

- `%APP_RESOURCE_DIR%\etc\lumiscan-cam-driver`, wenn die Umgebungsvariable `APP_RESOURCE_DIR` gesetzt ist;
- andernfalls `C:\ProgramData\HD Vision Systems GmbH\LumiScan Vision Suite\lumiscan-cam-driver\etc\lumiscan-cam-driver`.

Starten Sie den Cam Driver nach dem Ändern einer Datei neu. Eine Beispielkonfiguration finden Sie in [Beispielinhalt der Anwendungs-Einstellungsdatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html).

# Fehlerbehebung – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html

Diese Seite nennt zuerst die allgemeinen Prüfungen, die bei jedem Problem helfen. Beginnen Sie mit ihnen. Suchen Sie dann Ihr Symptom in den folgenden Kategorien: Zu jedem Problem finden Sie die Symptome, mögliche Ursachen, eine Diagnose und die Lösung. Der letzte Abschnitt nennt, was Sie an den Support senden.

## Allgemeine Prüfungen {#general-checks}

### Konfiguration {#general-configuration}

Der Cam Driver verwendet eine zweistufige Konfiguration:

- Die **App-Konfiguration** (`lumiscan-cam-driver.json`) legt fest, welche Kameramodule geladen werden.
- Jede **Kamerakonfiguration** (zum Beispiel `camera_example.json`) steht für eine Kamera.

Fehlt eine Kamerakonfiguration, ist sie ungültig oder nicht korrekt referenziert, wird die Kamera nicht geladen und erscheint nicht im Data Layer.

Die Konfigurationen finden Sie unter:

| Plattform | Ort |
| --- | --- |
| ctrlX OS | `Manage App Data > active > lumiscan-cam-driver` |
| PC (Windows) | `%APP_RESOURCE_DIR%\etc\lumiscan-cam-driver`, oder ohne `APP_RESOURCE_DIR` `C:\ProgramData\HD Vision Systems GmbH\LumiScan Vision Suite\lumiscan-cam-driver\etc\lumiscan-cam-driver` |

Auf beiden Plattformen zeigt `/hdvisionsystems/lumiscan-cam-driver/system/settings` die Dateien so, wie der Cam Driver sie beim Start gelesen hat. Eine Moduldatei, die nicht gelesen werden konnte, erscheint dort mit einem `"$error"`, das den Grund nennt. Der Cam Driver liest seine Dateien nur beim Start: Starten Sie die Anwendung neu, nachdem Sie eine Datei geändert haben. Siehe [Einstellungen auf dem Data Layer](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html#what-the-node-shows).

### Status eines Kameramoduls {#general-status}

Jedes Kameramodul meldet den Ausgang seiner letzten Operation auf `hdvisionsystems/lumiscan-cam-driver/<camera name>/control/status/code` (als Zahl) und `.../control/status/text` (als Name). Die Bedeutung jedes Werts steht in [Werte des Statuscodes](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#status-code-values).

- Ein fehlgeschlagenes `capture` über den Handshake endet bei Status `3` (`waitingForClient`), nicht bei seinem eigenen Fehlercode. `control/capture/execute` behält den eigenen Code des Capture. Siehe [Wann eine Funktionalität läuft](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html#when-a-functionality-runs).
- Ein fehlgeschlagenes `capture`, `reset`, `save` oder `load` wird gespeichert: Sein Status bleibt, bis ein `reset` erfolgreich ist. Jeder andere Fehler bleibt nur etwa 100 ms auf `control/status/code` stehen.
- Prüfen Sie mit `<camera name>/device-info/is-connected`, ob eine Kamera verbunden ist, nicht mit dem Status.

### Protokolle {#general-logs}

Besteht ein Problem weiterhin, prüfen Sie das Protokoll auf zusätzliche Fehlerinformationen:

- **ctrlX OS:** das Systemprotokoll von ctrlX OS. Lesen Sie es im Logbuch der ctrlX-Weboberfläche oder mit `journalctl`. Siehe [ctrlX Data Layer auf ctrlX OS](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/ctrlx-data-layer.html).
- **PC:** die Ausgabe des Cam Driver in seiner Konsole.

`logLevel` im Abschnitt `system` von `lumiscan-cam-driver.json` legt die Protokollstufe fest: `TRACE`, `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL` oder `OFF`. Siehe [Beispielinhalt der Anwendungs-Einstellungsdatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html).

Ein Programm, das eine `execute`-Methode immer wieder aufruft, während sie abgelehnt wird, zum Beispiel `capture/execute`, während die Kamera belegt ist, würde eine Protokollzeile pro Aufruf schreiben. Für jede Methode und jedes Ergebnis protokolliert die Anwendung die erste Ablehnung und danach höchstens eine Zeile alle zehn Sekunden, die angibt, wie viele Ablehnungen nicht einzeln protokolliert wurden, zum Beispiel "(+250 like it since the last one logged)". Das `execute`-Ergebnis selbst wird weiterhin bei jedem Aufruf zurückgegeben.

### Data Layer {#general-data-layer}

Bei Problemen, die den Data Layer selbst betreffen - den Broker von LumiScan Keryx, Knoten, die nicht gefunden werden, Methodenergebnisse - siehe [Fehlerbehebung](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/troubleshooting.html) von LumiScan Keryx.

## Konfiguration und Start {#configuration-and-start}

### Problem: Eine konfigurierte Kamera erscheint nicht im Data Layer {#faq-camera-not-in-data-layer}

**Symptome**

Für eine Kamera, die Sie konfiguriert haben, gibt es keinen Knoten `/hdvisionsystems/lumiscan-cam-driver/<module>`.

**Mögliche Ursachen**

- Die Kamerakonfiguration fehlt, ist ungültig oder in `lumiscan-cam-driver.json` nicht korrekt referenziert. Das Kameramodul wird dann nicht geladen.
- Die `id` des Moduls enthält andere Zeichen als Kleinbuchstaben, Ziffern, `-` und `_`.
- Die Datei wurde geändert, aber die Anwendung wurde nicht neu gestartet. Der Cam Driver liest seine Dateien nur beim Start.
- Die gesamte Anwendung fehlt im Data Layer, zum Beispiel weil die Lizenz fehlt (ctrlX OS) oder die Anwendung einen anderen Broker verwendet (PC).

**Diagnose**

1. Lesen Sie `/hdvisionsystems/lumiscan-cam-driver/system/settings` - erwartet: der Inhalt des Moduls in der Liste `modules`. Eine Moduldatei, die nicht gelesen werden konnte, erscheint als `{"$file": ..., "$error": ...}`; `"$error"` nennt den Grund.
2. Prüfen Sie, ob die Kamerakonfigurationsdatei in der Liste der Kamerakonfigurationsdateien in `lumiscan-cam-driver.json` eingetragen ist - erwartet: Ihr Dateiname ist aufgeführt.
3. Prüfen Sie die `id` in der Kamerakonfigurationsdatei - erwartet: nur Kleinbuchstaben, Ziffern, `-` und `_`, und eindeutig über alle Kameraeinstellungen hinweg.
4. Lesen Sie das Protokoll (siehe [Protokolle](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#general-logs)) - erwartet: kein Fehler für das Modul. Bei einer ungültigen `id` nennt das Protokoll die ID, die stattdessen zu schreiben ist.
5. Gibt es überhaupt keinen Knoten `/hdvisionsystems/lumiscan-cam-driver`, läuft die Anwendung selbst nicht.

**Lösung**

- **Wenn die Kamerakonfiguration fehlt, ungültig oder nicht referenziert ist:** Korrigieren Sie die App-Konfiguration und die Kamerakonfiguration so, dass sie korrekt aufeinander verweisen.
  1. Korrigieren Sie die Dateien, oder ändern Sie sie auf dem Data Layer über `system/settings`.
  2. Starten Sie die Anwendung neu, zum Beispiel mit `hdvisionsystems/lumiscan-cam-driver/system/control/restart/execute`.
  3. Prüfen Sie, ob `/hdvisionsystems/lumiscan-cam-driver/<module>` vorhanden ist.
- **Wenn die `id` ungültige Zeichen enthält:** Schreiben Sie die ID, die das Protokoll nennt (zum Beispiel `Camera1` → `camera1`), und starten Sie dann die Anwendung neu. Siehe [Beispielinhalt einer Kameradatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/camera-example-file-content-example.html).
- **Wenn die Anwendung im Data Layer fehlt:** Auf ctrlX OS siehe [Problem: "No valid license found, please purchase one. If you do have one, please try to restart ctrlX"](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-missing-license). Für einen PC und für andere Ursachen im Data Layer siehe [Eine App oder ein Modul fehlt im Baum](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/troubleshooting.html#app-missing).

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit dem Inhalt von `system/settings` und den Protokollzeilen vom Start der Anwendung.

### Problem: Module beantworten keinen Request, und der Status ist -5 "restartRequired" {#faq-restart-required}

**Symptome**

- `control/status/code` ist auf jedem Modul `-5` (`restartRequired`).
- `hdvisionsystems/lumiscan-cam-driver/system/restart-required` ist `true`.
- Jede `execute`-Methode eines Moduls antwortet mit `DL_RESOURCE_UNAVAILABLE` (`ResourceUnavailable` bei LumiScan Keryx), und die `ready`-Signale sind `false`.
- Ein laufender Bild-Stream stoppt.

**Mögliche Ursachen**

- Die Einstellungen wurden auf dem Data Layer geändert (`system/settings`, `activate-module`, `deactivate-module`). Bis zum nächsten Start läuft die Anwendung mit Einstellungen, die nicht mehr die ihrer Dateien sind.
- Eine geänderte Datei konnte nicht gespeichert werden: Der Schreibvorgang antwortete mit `DL_CREATION_FAILED`. Zuvor geänderte Dateien bleiben geändert, die Anwendung erfordert also trotzdem einen Neustart.

**Diagnose**

1. Lesen Sie `hdvisionsystems/lumiscan-cam-driver/system/restart-required` - erwartet: `true`.
2. Lesen Sie `hdvisionsystems/lumiscan-cam-driver/system/status-text` - er nennt die geänderten Dateien.
3. Lesen Sie das Protokoll - die Meldung steht auf Fehlerstufe.

**Lösung**

- **Wenn die Einstellungen auf dem Data Layer geändert wurden:**
  1. Rufen Sie `hdvisionsystems/lumiscan-cam-driver/system/control/restart/execute` auf. Ein `reset` hilft nicht.
  2. Warten Sie, bis `system/restart-required` wieder gelesen werden kann. Auf ctrlX OS endet die Anwendung, und ctrlX OS startet sie nach etwa fünf Sekunden erneut.
- **Wenn ein Schreibvorgang mit `DL_CREATION_FAILED` antwortete:** Korrigieren Sie die Dateien, und starten Sie die Anwendung dann wie oben neu.

Siehe [Neustart erforderlich](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html#restart-required).

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit dem Inhalt von `system/status-text` und `system/settings`.

### Problem: "No valid license found, please purchase one. If you do have one, please try to restart ctrlX" {#faq-missing-license}

**Symptome**

- `control/status/code` ist `-4` (`missingLicense`) mit dem Text `No valid license found, please
  purchase one. If you do have one, please try to restart ctrlX`.
- Auf ctrlX OS beendet sich die Anwendung kurz nach dem Start.
- Ab v2.2.0 protokolliert die Anwendung eine Warnung und beendet sich, wenn eine Lizenz verloren geht.

**Mögliche Ursachen**

- Es ist keine gültige Lizenz installiert, oder nicht genug für die konfigurierten Kameras: Sie benötigen eine Lizenz pro angeschlossener Kamera.
- Ein Schlüssel der Version 1 ist installiert. Ab v2.0.0 benötigt der Cam Driver die Lizenz `SWL-W-XCx-CAMDRIVERxHDVSx-V2NN`.
- Bis einschließlich v2.1.0: Die Lizenzen wurden getrennt installiert. Nur der erste Eintrag Cam Driver V2 wird gelesen.

**Diagnose**

1. Lesen Sie das Systemprotokoll von ctrlX OS (siehe [Protokolle](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#general-logs)) - es nennt den Grund, die fehlende Lizenz.
2. Öffnen Sie die Seite **Licenses** von ctrlX OS - erwartet: Lizenzen Cam Driver V2 für alle angeschlossenen Kameras. Bis einschließlich v2.1.0: ein Eintrag Cam Driver V2, der alle Kameras abdeckt.
3. Vergleichen Sie die Zahl der Lizenzen mit der Zahl der angeschlossenen Kameras - erwartet: eine Lizenz pro Kamera.

**Lösung**

- **Wenn keine oder nicht genug Lizenzen installiert sind:** Installieren Sie eine Lizenz `SWL-W-XCx-CAMDRIVERxHDVSx-V2NN` pro angeschlossener Kamera. Siehe [Voraussetzungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/requirements.html#licence).
- **Wenn ein Schlüssel der Version 1 installiert ist:** Ersetzen Sie ihn durch eine V2-Lizenz. Schlüssel der Version 1 funktionieren ab v2.0.0 nicht.
- **Wenn die Lizenzen getrennt installiert wurden (v2.1.0 und älter):** Installieren Sie alle Lizenzen gemeinsam, sodass die Seite **Licenses** einen Eintrag Cam Driver V2 zeigt, der alle Kameras abdeckt, oder aktualisieren Sie auf v2.2.0, das auch getrennt installierte Lizenzen unterstützt.
- Zu anderen Bezugswegen und Lizenzproblemen siehe die [FAQ zur Lizenzierung](https://docs.hdvisionsystems.com/de/lumiscan-licensing-de/1.0.4/faq.html) und die [Fehlerbehebung Lizenzierung](https://docs.hdvisionsystems.com/de/lumiscan-licensing-de/1.0.4/troubleshooting.html).

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit den Protokollzeilen, die die fehlende Lizenz nennen. Für Lizenzen wenden Sie sich an [licenses@hdvisionsystems.com](mailto:licenses@hdvisionsystems.com).

## Kameraverbindung {#camera-connection}

### Problem: Eine physisch angeschlossene Kamera wird nicht erkannt {#faq-camera-not-detected}

**Symptome**

Die Kamera fehlt in den Listen unter `/hdvisionsystems/lumiscan-cam-driver/system`: `found-camera-ip-addresses`, `found-camera-mac-addresses`, `found-camera-modules` und `found-camera-serials`.

**Mögliche Ursachen**

- Die Kamera ist nicht mit der ctrlX CORE oder dem PC verbunden, oder (ctrlX OS) nicht mit einem unterstützten ctrlX-Port.
- Die Kamera wird nicht mit Strom versorgt, weder extern noch über PoE.
- Die IP-Adressen der ctrlX CORE bzw. des PCs und der Kamera sind nicht korrekt konfiguriert: Die Kamera-IP muss im selben lokalen Netzwerk liegen.
- Es gibt doppelte IP-Adressen im Netzwerk.

**Diagnose**

1. Lesen Sie `found-camera-serials`, `found-camera-ip-addresses`, `found-camera-mac-addresses` und `found-camera-modules` unter `/hdvisionsystems/lumiscan-cam-driver/system` - erwartet: Die Kamera wird erkannt, ihre IP-Adresse ist korrekt, und die Seriennummer passt zum erwarteten Gerät.
2. Prüfen Sie das Kabel - erwartet: Die Kamera ist mit der ctrlX CORE oder dem PC verbunden; auf ctrlX OS mit einem unterstützten ctrlX-Port.
3. Prüfen Sie die Stromversorgung - erwartet: Die Kamera wird versorgt, extern oder über PoE.
4. Vergleichen Sie IP-Adresse und Subnetz der Kamera mit denen der ctrlX CORE bzw. des PCs - erwartet: Die Kamera liegt im selben lokalen Netzwerk.
5. Prüfen Sie das Netzwerk auf doppelte IP-Adressen - erwartet: Jedes Gerät hat eine eindeutige IP-Adresse.

**Lösung**

- **Wenn die Kamera nicht verbunden oder nicht versorgt ist:** Verbinden Sie sie mit der ctrlX CORE oder dem PC (auf ctrlX OS mit einem unterstützten ctrlX-Port), und versorgen Sie sie mit Strom. Für eine ctrlX CORE X3 siehe [Hardware-Aufbau für ctrlX X3](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/hardware-setup-for-ctrlx-x3.html#overview).
- **Wenn die IP-Adresse falsch ist:** Setzen Sie sie mit der Funktion force-ip unter `hdvisionsystems/lumiscan-cam-driver/system/force-ip/`. Sie funktioniert auch, wenn das Subnetz der Kamera nicht zu dem der ctrlX CORE oder des PCs passt, solange die Kamera über dieselbe Netzwerkverbindung erreichbar ist. Siehe [Kamera-IP-Adresse einrichten](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/setup-camera-ip-address.html).
  1. Lesen Sie die MAC-Adresse der Kamera aus `system/found-camera-mac-addresses` (gleiche Position in der Liste wie ihre Seriennummer in `system/found-camera-serials`).
  2. Setzen Sie `gateway`, `ip`, `subnet` und die MAC-Adresse der Kamera.
  3. Warten Sie, bis `ready` `true` ist, setzen Sie `request` auf `true` und dann wieder auf `false`.
  4. Wenn `ready` wieder `true` ist, prüfen Sie, ob `system/found-camera-ip-addresses` die neue Adresse zeigt. Falls nicht, setzen Sie die IP mit dem Programm des Kameraherstellers.
- **Wenn es doppelte IP-Adressen gibt:** Geben Sie jedem Gerät eine eindeutige IP-Adresse. Auf einer ctrlX CORE X3 verwendet XF10 `192.168.1.1`: Weisen Sie diese Adresse weder der Kamera noch dem Computer zu.

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit dem Inhalt der vier Listen `found-camera-…` und der Netzwerktopologie (Switch oder direkte Verbindung).

### Problem: Die Kamera verbindet sich nicht (Status -10000 "failedToConnectToCamera") {#faq-failed-to-connect-to-camera}

**Symptome**

- Nach dem Handshake `connect-camera` bleibt `/hdvisionsystems/lumiscan-cam-driver/<module>/device-info/is-connected` `false`.
- `control/status/code` zeigt `-10000` (`failedToConnectToCamera`) nur etwa 100 ms lang, dann wieder `0`, während die Kamera weiterhin nicht verbunden ist.

**Mögliche Ursachen**

- Die Kamera wird nicht erkannt, siehe [Problem: Eine physisch angeschlossene Kamera wird nicht erkannt](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-camera-not-detected).
- Die Kamera wurde abgezogen und wieder angeschlossen.
- Die Ethernet-Konfiguration, etwa Puffergrößen und Jumbo Frames, passt nicht zu den Kameraspezifikationen.
- Ein PC am selben Switch greift gleichzeitig auf die Kamera zu. Paralleler Zugriff kann die Kamerakommunikation stören.
- Mehr als ein Prozess schreibt `connect-camera/request`, sodass die Anwendung den Request verpasst.

**Diagnose**

1. Lesen Sie `<module>/device-info/is-connected` - erwartet: `true` nach `connect-camera`. Beurteilen Sie die Verbindung nicht anhand von `control/status/code`.
2. Prüfen Sie, ob die Kamera unter `/hdvisionsystems/lumiscan-cam-driver/system` erscheint - erwartet: Ihre Seriennummer steht in `found-camera-serials`.
3. Lesen Sie vor dem Request `<module>/control/connect-camera/ready` - erwartet: `true`. Ist es `false`, ist die Vorbedingung nicht erfüllt oder es wird keine Kamera gefunden: Prüfen Sie, ob die Kamera-IP im selben lokalen Netzwerk wie die ctrlX CORE oder der PC liegt.
4. Lesen Sie, nachdem Sie `connect-camera/request` auf `true` gesetzt haben, `connect-camera/ready` - erwartet: `false` (die Anwendung hat den Request erkannt).
5. Prüfen Sie, ob ein PC am selben Switch auf die Kamera zugreift - erwartet: Er tut es nicht.

**Lösung**

- **Wenn die Kamera nicht erkannt wird:** Folgen Sie [Problem: Eine physisch angeschlossene Kamera wird nicht erkannt](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-camera-not-detected).
- **Wenn die Kamera abgezogen und wieder angeschlossen wurde (ab v2.1.0):** Führen Sie den Handshake `reset` aus, der `failedToConnectToCamera` meldet, bis er erfolgreich ist, und dann `connect-camera`. `connect-camera` hat keine `execute`-Methode: Verwenden Sie den Handshake auf `/hdvisionsystems/lumiscan-cam-driver/<module>/control/connect-camera/request`. Siehe [Verbindungsschritte](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#connection-steps).
- **Wenn die Verbindung weiterhin fehlschlägt:**
  1. Trennen Sie die Kamera für etwa 30 Sekunden von der Stromversorgung und schließen Sie sie wieder an.
  2. Prüfen Sie, ob die Kamera im Data Layer erscheint.
  3. Prüfen Sie die Ethernet-Konfiguration, etwa Puffergrößen und Jumbo Frames, gemäß den Kameraspezifikationen.
- **Wenn ein PC gleichzeitig auf die Kamera zugreift:** Beenden Sie diesen Zugriff.
- **Wenn die Anwendung den Request nicht erkennt:** Stellen Sie sicher, dass immer nur ein Prozess auf `connect-camera/request` zugreift und dass Sie dieselbe Data-Layer-Version wie die Kameraanwendung verwenden.

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit der Seriennummer der Kamera, dem Wert von `device-info/is-connected` und den Protokollzeilen des Verbindungsversuchs.

## Bildaufnahme und Speichern {#image-capture-and-saving}

### Problem: Die Bildaufnahme schlägt fehl oder ist unzuverlässig (Status -10004 "couldNotCaptureImage") {#faq-could-not-capture-image}

**Symptome**

- `capture/execute` hinterlässt `control/status/code` bei `-10004` (`couldNotCaptureImage`).
- Über den Handshake endet ein fehlgeschlagenes Capture bei Status `3`, und `capture/ready` bleibt `false`, bis ein `reset` erfolgreich ist.
- Bilder lassen sich nicht zuverlässig auslösen.

**Mögliche Ursachen**

- Die Kamera ist getrennt.
- Die Kommunikation schlägt wegen schlechter Verbindungsqualität fehl.
- Die MTU-Größe des Ethernet-Ports (ctrlX OS) oder des Netzwerkadapters (PC) ist zu klein.
- Eine Netzwerkkomponente unterstützt den erforderlichen Datendurchsatz nicht.

**Diagnose**

1. Lesen Sie `<module>/device-info/is-connected` - erwartet: `true`.
2. Prüfen Sie das Kabel - erwartet: ein "Foil Shielded Twisted Pair"-Kabel.
3. Prüfen Sie die MTU-Größe - erwartet: 8000 oder 9000.
   - ctrlX OS: **Settings** > **Network Interfaces** > der verwendete Port > **Advanced Settings**.
   - PC: die MTU-Größe (Jumbo Frames) des Netzwerkadapters, an dem die Kamera angeschlossen ist.
4. Verkleinern Sie als schnellen Test die ROI - wird die Bildaufnahme dadurch stabiler, hängt das Problem wahrscheinlich mit der Netzwerkbandbreite zusammen.

**Lösung**

- **Wenn die Kamera getrennt ist:** Verbinden Sie sie erneut. Ein fehlgeschlagenes Capture wird gespeichert: Führen Sie `reset` und dann `connect-camera` mit dem Handshake aus.
- **Wenn die Verbindungsqualität schlecht ist:** Verwenden Sie ein "Foil Shielded Twisted Pair"-Kabel.
- **Wenn die MTU-Größe zu klein ist:** Setzen Sie sie auf 8000 oder 9000. Kann der Port auf ctrlX OS die MTU-Größe nicht ändern, verwenden Sie einen Ethernet-Port, der große MTU-Größen unterstützt. Siehe [MTU-Größe ändern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#mtu-size-change).
- **Wenn die Netzwerkbandbreite nicht ausreicht:** Stellen Sie sicher, dass alle Netzwerkkomponenten den erforderlichen Datendurchsatz unterstützen. Testen Sie auf einer ctrlX CORE X3 verschiedene Werte für das Packet Delay, bis die Bildaufnahme stabil ist, siehe [Kameraeinrichtung abschließen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/hardware-setup-for-ctrlx-x3.html#complete-camera-setup). Kameraparameter können mit der Software des Herstellers, über die Feature-Knoten der Kamera unter `/hdvisionsystems/lumiscan-cam-driver/<module>/features` oder in einer Feature-Datei angepasst werden, die in `cameras[].featureFiles` des Moduls aufgeführt ist. Siehe [GenICam-Features](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#genicam-features).

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit dem Inhalt von `control/status/code` und `control/status/text`, der MTU-Größe und der Netzwerktopologie.

### Problem: Ein Schreibvorgang auf execute antwortet mit "DL_TOO_MANY_OPERATIONS" oder "TooManyOperations" {#faq-dl-too-many-operations}

**Symptome**

Ein Schreibvorgang auf `<camera name>/control/<operation>/execute` antwortet mit `DL_TOO_MANY_OPERATIONS` (ctrlX Data Layer) oder `TooManyOperations` (LumiScan Keryx).

**Mögliche Ursachen**

- Die Kamera ist gerade mit einer anderen Operation belegt.
- Der Bild-Stream startet oder stoppt gerade. Nach dem Stoppen des Streams wird die Kamera erneut verbunden; bis dahin antwortet `capture/execute` mit `DL_TOO_MANY_OPERATIONS`.

**Diagnose**

1. Lesen Sie `control/status/code` - `2` (`running`): Eine andere Operation läuft.
2. Lesen Sie `control/publish/output/stream/active` und `control/capture/ready` - nach dem Stoppen des Streams wird `capture/ready` `true`, sobald die Kamera wieder verbunden ist.

**Lösung**

- **Wenn die Kamera belegt ist:** Wiederholen Sie den Aufruf. Ein abgelehnter Schreibvorgang wird nie in eine Warteschlange gestellt; derselbe Schreibvorgang gelingt, sobald die laufende Operation abgeschlossen ist.
- **Wenn der Stream startet oder stoppt:** Warten Sie, bis `capture/ready` `true` ist. Das dauert bei der von uns getesteten Kamera etwa zwei Sekunden.

`DL_RESOURCE_UNAVAILABLE` (`ResourceUnavailable`) ist ein anderes Ergebnis: Die Anwendung wird beendet - Wiederholen hilft nicht -, oder ein Neustart ist erforderlich, siehe [Problem: Module beantworten keinen Request, und der Status ist -5 "restartRequired"](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-restart-required). Siehe [execute aufrufen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html#calling-execute).

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit der aufgerufenen Operation und dem Ergebnis, mit dem sie antwortet.

### Problem: Ein Schreibvorgang auf execute antwortet mit "DL_INVALID_OPERATION_MODE", oder capture wird immer wieder abgelehnt {#faq-dl-invalid-operation-mode}

**Symptome**

- Ein Schreibvorgang auf `<camera name>/control/<operation>/execute` antwortet mit `DL_INVALID_OPERATION_MODE` (ctrlX Data Layer) oder `InvalidOperationMode` (LumiScan Keryx). Das gilt für v2.2.0 und neuer; frühere Versionen meldeten diesen Fall als `DL_TOO_MANY_OPERATIONS`.
- `capture/execute` wird immer wieder abgelehnt, auch nachdem die Kamera einmal aufgenommen hat.

**Mögliche Ursachen**

Das Signal `ready` der Operation ist `false`, die Kamera ist also nicht in einem Zustand, in dem die Operation laufen kann:

- `capture`: Die Kamera ist nicht verbunden, ein Capture-Fehler ist gespeichert (nach einem fehlgeschlagenen Capture), oder der Bild-Stream läuft.
- `save`: Es ist noch kein Bild verfügbar.
- `load`, `remove`: `<camera name>/output/image-files` ist leer.
- `trigger`: Die Kamera ist nicht verbunden.

**Diagnose**

1. Lesen Sie `<operation>/ready` - `false` nennt die fehlende Vorbedingung.
2. Lesen Sie `control/status/code` und `control/status/text` - der Statustext enthält noch die Meldung des Fehlers, der sie verursacht hat.
3. Lesen Sie `<camera name>/device-info/is-connected` - erwartet: `true`.
4. Lesen Sie `control/publish/output/stream/active` - `true`: Der Bild-Stream läuft.
5. Lesen Sie für `load` und `remove` `<camera name>/output/image-files` - erwartet: nicht leer.

**Lösung**

Wiederholen Sie nicht blind; stellen Sie zuerst die Vorbedingung her:

- **Wenn die Kamera nicht verbunden ist oder ein Capture-Fehler gespeichert ist:** Führen Sie `reset` und dann `connect-camera` mit dem Handshake aus (`reset` gibt eine getrennte Kamera zurück). Beide haben keine `execute`-Methode; ein Programm, das nur `execute` verwendet, muss sich daher über den Handshake verbinden und einen gespeicherten Fehler darüber beheben.
- **Wenn der Bild-Stream läuft:** Stoppen Sie ihn und warten Sie, bis `capture/ready` `true` ist, siehe [Problem: Capture wird abgelehnt, während der Bild-Stream läuft](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-capture-refused-streaming).
- **Wenn für `save` kein Bild verfügbar ist:** Nehmen Sie zuerst ein Bild auf oder laden Sie eines.
- **Wenn `output/image-files` leer ist:** Führen Sie zuerst `list-images` aus oder speichern Sie ein Bild.

Siehe [Wann eine Operation bereit ist](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html#when-is-an-operation-ready).

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit den Werten von `<operation>/ready`, `control/status/code` und `control/status/text`.

### Problem: Bilder werden nicht gespeichert (Status -10006 "saveImageFailed" oder -10005 "noImageTaken") {#faq-save-image-failed}

**Symptome**

- `control/status/code` ist `-10006` (`saveImageFailed`) oder `-10005` (`noImageTaken`).
- **Save** tut nichts, oder im Speicherordner liegt kein Bild.

**Mögliche Ursachen**

- `noImageTaken`: Es wurde noch kein Bild aufgenommen.
- `saveImageFailed`: Der Speicher kann nicht beschrieben werden - `ip`, `username` oder `password` in den Speichereinstellungen sind falsch, die IP ist von der ctrlX CORE oder dem PC aus nicht erreichbar, oder der freigegebene Ordner hat nicht genügend freien Speicherplatz.
- Der Speicher ist nicht oder falsch konfiguriert: Ohne einen Block `storage` im Abschnitt `system` von `lumiscan-cam-driver.json` tut **Save** nichts.
- (ctrlX OS) Das USB-Speichergerät oder die SD-Karte ist nicht eingebunden oder verwendet weder FAT32 noch EXT4.

**Diagnose**

1. Lesen Sie `output/package-identifier` - ist er null, wurde kein Bild aufgenommen, und `save/ready` ist `false`.
2. Prüfen Sie den Block `storage` im Abschnitt `system` von `lumiscan-cam-driver.json` - erwartet: ein `type` (`Internal` oder `Samba`) und seine Parameter. Siehe [Speichereinstellungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html#storage-settings).
3. Bei `Samba`: Prüfen Sie, ob `ip`, `username` und `password` korrekt sind, ob die IP von der ctrlX CORE oder dem PC aus erreichbar ist und ob Sie mit dem konfigurierten Benutzerkonto auf den Ordner zugreifen können - erwartet: Der Zugriff funktioniert, und der Ordner hat freien Speicherplatz.
4. Bei einem USB-Speichergerät oder einer SD-Karte (ctrlX OS): Prüfen Sie unter **Settings** > **Storage Devices**, ob es eingebunden ist - erwartet: Sein Pfad (zum Beispiel `/media/sdb1`) ist der Anfang von `rootPath`.
5. Lesen Sie das Protokoll - es zeigt Hinweise zu fehlerhaften Einstellungen.

**Lösung**

- **Wenn kein Bild aufgenommen wurde (`noImageTaken`):** Nehmen Sie vor dem Speichern ein Bild auf.
- **Wenn der Speicher nicht beschrieben werden kann (`saveImageFailed`):** Korrigieren Sie `ip`, `username` und `password`, machen Sie die IP erreichbar, oder schaffen Sie freien Speicherplatz im freigegebenen Ordner.
- **Wenn der Speicher nicht oder falsch konfiguriert ist:**
  1. Fügen Sie den Block `storage` hinzu oder korrigieren Sie ihn, siehe [Bilddateien speichern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#saving-image-files).
  2. Starten Sie die Anwendung neu.
  3. Rufen Sie **Connect Camera**, **Capture** und **Save** auf, und prüfen Sie, ob ein Bild im Speicherordner liegt.
- **Wenn das USB-Speichergerät oder die SD-Karte nicht eingebunden ist (ctrlX OS):** Binden Sie es unter **Settings** > **Storage Devices** mit **For data exchange** ein, und beginnen Sie `rootPath` mit dem dort angezeigten Pfad.

Ein fehlgeschlagenes `save` bleibt gespeichert, bis ein `reset` erfolgreich ist; ein `save`, bevor etwas aufgenommen wurde (`-10005`), nicht.

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit dem Block `storage` (das Passwort wird auf `system/settings` als `"*"` angezeigt) und den Protokollzeilen des fehlgeschlagenen Speicherns.

### Problem: Bilder entsprechen nicht den Erwartungen {#ts-images-not-as-expected}

**Symptome**

Die aufgenommenen Bilder sehen nicht so aus, wie Sie es nach den Kameraeinstellungen erwarten.

**Mögliche Ursachen**

- Die Kameraeinstellungen werden nicht korrekt gespeichert oder angewendet.
- Ein Wert wurde auf einen Feature-Knoten unter `features` geschrieben. Ein solcher Wert geht verloren, wenn die Kamera erneut verbunden wird.
- Die Belichtungszeit auf `input/exposure-time` und das Inter-Packet-Delay werden nicht angewendet, solange der Bild-Stream läuft.

**Diagnose**

1. Speichern Sie ein Bild mit `/hdvisionsystems/lumiscan-cam-driver/<module>/control/save/execute` oder dem Handshake `save` (`control/save/request`), und sehen Sie es sich an - erwartet: Es passt zu den Einstellungen.
2. Prüfen Sie, wo die Kamera-Features gesetzt werden - erwartet: in einer Feature-Datei, die in `cameras[].featureFiles` des Moduls aufgeführt ist und bei jedem Verbinden der Kamera angewendet wird.
3. Lesen Sie `control/publish/output/stream/active` - `true`: Der Stream läuft, und die Belichtungszeit wird nicht angewendet.

**Lösung**

- **Wenn die Einstellungen nicht gespeichert oder angewendet werden:** Wenn die Kamera es unterstützt, exportieren Sie die Kamerakonfiguration, zum Beispiel im GenICam-Format, und importieren Sie sie in LumiScan, um die Einstellungen konsistent zu halten.
- **Wenn ein auf einen Feature-Knoten geschriebener Wert verloren ging:** Tragen Sie das Feature in eine Feature-Datei ein, die in `cameras[].featureFiles` des Moduls aufgeführt ist. Siehe [GenICam-Features](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#genicam-features).
- **Wenn der Bild-Stream läuft:** Stoppen Sie den Stream, ändern Sie die Kamera-Features, und starten Sie den Stream dann erneut.

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit einem gespeicherten Bild, der Kamerakonfiguration und den Feature-Dateien.

## Bild-Stream (experimentell) {#image-stream}

### Problem: Capture wird abgelehnt, während der Bild-Stream läuft {#faq-capture-refused-streaming}

**Symptome**

- `control/capture/execute` antwortet mit `DL_INVALID_OPERATION_MODE`, solange der Stream läuft, und mit `DL_TOO_MANY_OPERATIONS`, während der Stream startet oder stoppt.
- Ein Capture-Request über den Handshake endet mit Status `-3` (`invalidInput`) und dem Text `capture refused: the image stream (experimental) is active`.
- `control/capture/ready` ist `false`.

**Mögliche Ursachen**

- Der experimentelle Bild-Stream läuft. Der Stream und `capture` nutzen die Kamera auf unterschiedliche Weise und laufen daher nie gleichzeitig.
- Der Stream wurde gerade gestoppt, und die Kamera wird erneut verbunden.

**Diagnose**

1. Lesen Sie `control/publish/output/stream/active` - `true`: Der Stream läuft.
2. Lesen Sie nach dem Stoppen des Streams `control/capture/ready` - erwartet: `true` nach etwa zwei Sekunden.

**Lösung**

- **Wenn Sie ein Capture benötigen:** Stoppen Sie den Stream. Ein `reset` ist nicht nötig: Die Ablehnung speichert keinen Fehler.
  1. Schreiben Sie `false` auf `control/publish/input/enable`.
  2. Rufen Sie `control/publish/execute` auf.
  3. Warten Sie, bis `control/capture/ready` wieder `true` ist. Das dauert bei der von uns getesteten Kamera etwa zwei Sekunden, weil die Kamera nach dem Stream erneut verbunden wird.
- **Wenn Sie während des Streamings einzelne Bilder benötigen:** Nehmen Sie sie aus `control/publish/output/stream/frame`, statt den Stream zu stoppen, oder wenden Sie `keep-latest-output` an und lesen Sie `output/image`, wenn sich `output/package-identifier` ändert.

Siehe [Capture, während der Stream läuft](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#capture-while-streaming).

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit den Werten von `control/publish/output/stream/active` und `control/capture/ready`.

### Problem: Der Bild-Stream liefert keine Bilder oder weniger als erwartet {#ts-stream-missing-images}

**Symptome**

Ihr Programm erhält auf `control/publish/output/stream/frame` keine Bilder oder weniger als erwartet. Ein verworfenes Bild erscheint als Lücke in den Frame-Nummern (`sequence`).

**Mögliche Ursachen**

- Der Stream läuft nicht: Die Eingaben wurden geschrieben, aber `control/publish/execute` wurde nicht aufgerufen; der Stream konnte nicht starten; oder der Cam Driver wurde neu gestartet - nach einem Start ist der Stream aus.
- `frames` bleibt bei `0`: Der Cam Driver triggert die Kamera nicht von selbst.
- `frames` wächst langsamer als die Zahl der gesendeten Trigger: Die Kamera ignoriert Trigger, die schneller kommen, als sie Bilder aufnehmen kann.
- `lost-frames` oder `incomplete-frames` wachsen: Bilder gingen im Netzwerk verloren.
- `published-frames` entspricht `frames`, aber Ihr Programm erhält weniger: Ihr Abonnent fällt weit zurück, und der Data Layer verwirft Bilder.

**Diagnose**

1. Lesen Sie `control/publish/output/stream/active` - erwartet: `true`.
2. Vergleichen Sie die Zähler unter `/hdvisionsystems/lumiscan-cam-driver/<module>/control/publish/output/stream/statistics`: `frames`, `lost-frames`, `incomplete-frames` und `published-frames` - erwartet: `frames` wächst mit jedem Trigger, `lost-frames` und `incomplete-frames` bleiben bei `0`, und `published-frames` entspricht `frames`.
3. Vergleichen Sie die `sequence`-Nummern, die Ihr Programm erhält - erwartet: keine Lücken.

**Lösung**

- **Wenn der Stream nicht läuft:** Verbinden Sie die Kamera, setzen Sie `control/publish/input/enable` auf `true` und rufen Sie `control/publish/execute` auf. Tun Sie das nach jedem Start des Cam Driver. Bleibt `control/publish/output/stream/active` `false`, steht der Grund im Protokoll; der Start wird erst wieder versucht, wenn `control/publish/execute` erneut aufgerufen wird. Siehe [Einen Stream betreiben](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#running-a-stream).
- **Wenn `frames` bei `0` bleibt:** Triggern Sie die Kamera per Hardware oder mit `control/trigger/execute`, oder schalten Sie ihren Trigger-Modus aus. Siehe [Die Kamera triggern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#triggering).
- **Wenn `frames` langsamer wächst als die Trigger:** Triggern Sie seltener, verkürzen Sie die Belichtung, oder setzen Sie `TriggerOverlap` der Kamera in einer Feature-Datei auf einen Overlap, den sie unterstützt, etwa `PreviousFrame`. Siehe [Für die höchste Bildrate: TriggerOverlap](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#trigger-overlap).
- **Wenn `lost-frames` oder `incomplete-frames` wachsen:** Prüfen Sie das Netzwerk wie in [Problem: Die Bildaufnahme schlägt fehl oder ist unzuverlässig (Status -10004 "couldNotCaptureImage")](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-could-not-capture-image) beschrieben.
- **Wenn Ihr Programm weniger Bilder erhält als `published-frames`:** Stellen Sie sicher, dass Ihr Abonnent jedes Bild schnell verarbeitet.

Siehe auch [Ein Stream liefert nichts](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/troubleshooting.html#stream-nothing).

**Wenn das Problem weiterhin besteht**

Senden Sie die unter [Informationen für den Support](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#support-information) genannten Informationen an den Support, zusammen mit den Werten der Zähler unter `control/publish/output/stream/statistics` und der Angabe, wie die Kamera getriggert wird.

## Informationen für den Support {#support-information}

Besteht ein Problem weiterhin, senden Sie Folgendes an den Customer Success von HD Vision Systems unter [customer.success@hdvisionsystems.com](mailto:customer.success@hdvisionsystems.com) oder +49 6221 6721905. Für Lizenzen wenden Sie sich an [licenses@hdvisionsystems.com](mailto:licenses@hdvisionsystems.com).

- Die Version des LumiScan Cam Driver.
- Die Plattform: ctrlX OS und seine Version auf einer ctrlX CORE oder einem ctrlX IPC, oder einen PC mit Windows 11 oder Ubuntu 24.04 und LumiScan Keryx.
- Das Protokoll: auf ctrlX OS das Systemprotokoll von ctrlX OS (Logbuch der ctrlX-Weboberfläche oder `journalctl`), auf einem PC die Konsolenausgabe des Cam Driver.
- Datum und Uhrzeit, zu denen der Fehler aufgetreten ist.
- Den Data-Layer-Status des betroffenen Moduls: `control/status/code`, `control/status/text`, `device-info/is-connected` und das Ergebnis, mit dem ein `execute`-Aufruf antwortete.
- Die Kamera: Hersteller, Modell und Seriennummer (`system/found-camera-serials`).
- Die Konfiguration: `lumiscan-cam-driver.json`, die Kamerakonfigurationsdateien und Feature-Dateien, oder den Inhalt von `hdvisionsystems/lumiscan-cam-driver/system/settings`, der jedes Passwort als `"*"` zeigt.

# FAQ – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/faq.html

Kurze Antworten auf häufige Fragen zu LumiScan Cam Driver. Jeder Eintrag verweist auf die Seite mit den Details. Probleme und Fehlermeldungen sind unter [Fehlerbehebung](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html) beschrieben.

> [!TIP]
> Jeder Eintrag hat einen festen Anker (zum Beispiel `#faq-licence-v2`). Um eine Fehlermeldung zu finden, durchsuchen Sie die Seite [Fehlerbehebung](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html) danach.

## Voraussetzungen und Einrichtung

### Welche Kameras kann ich verwenden, und wie viele pro Installation? {#faq-supported-cameras}

- **Antwort:** Der Cam Driver läuft auf einer ctrlX CORE (ctrlX OS, mit dem ctrlX Data Layer) oder auf einem PC mit Windows 11 oder Ubuntu 24.04 (mit LumiScan Keryx) und benötigt eine Ethernet-fähige, GenICam-konforme Kamera, versorgt über PoE oder ein externes Netzteil. Die Knotenadressen sind auf beiden Plattformen gleich. Er wurde mit ausgewählten Kameras von Basler, Baumer, IDS, LUCID Vision Labs, Hikvision und Balluff getestet; GenICam-Implementierungen unterscheiden sich, prüfen Sie also alle benötigten Funktionen vor dem Einsatz. Ab v2.0.0 kann eine Installation mehrere Kameras betreiben: Jede Kamera ist ein Modul mit eigener Konfiguration und Data-Layer-Adresse (zum Beispiel `hdvisionsystems/lumiscan-cam-driver/camera1`), und jede verbundene Kamera benötigt eine eigene Lizenz.
- **Mehr:** [Voraussetzungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/requirements.html), [Beschreibung](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/description.html), [ctrlX Data Layer und LumiScan Keryx](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/platforms.html)

### Wie schließe ich eine Kamera an eine ctrlX CORE X3 an? {#faq-x3-network-topology}

- **Antwort:** (ctrlX OS) Das Handbuch beschreibt zwei Topologien. Weisen Sie der Kamera nach beiden eine eindeutige IP-Adresse zu, und testen Sie Werte für das Packet Delay, bis die Bildaufnahme stabil ist.
  - Gemeinsamer Ethernet-Switch: Kamera, Engineering-Computer und Port XF10 an einem Switch, der Jumbo Frames unterstützt. XF10 verwendet `192.168.1.1`, weisen Sie diese Adresse also weder der Kamera noch dem Computer zu.
  - Direkte Verbindung: Kamera direkt an XF10, Engineering-Computer an XF51. Geben Sie XF51 eine statische IPv4-Adresse in einem anderen Subnetz als XF10 (zum Beispiel `192.168.42.203`) und notieren Sie sie, da ctrlX WORKS die X3 möglicherweise nicht automatisch findet.
- **Mehr:** [Hardware-Aufbau für ctrlX X3](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/hardware-setup-for-ctrlx-x3.html#overview)

### Wie setze ich die IP-Adresse einer Kamera? {#faq-set-camera-ip}

- **Antwort:** Verwenden Sie die Funktion force-ip unter `hdvisionsystems/lumiscan-cam-driver/system/force-ip/`. Sie funktioniert auch, wenn die Kamera normalerweise nicht erkannt wird (zum Beispiel, weil ihr Subnetz nicht zu dem der ctrlX CORE oder des PCs passt), solange sie über dieselbe Netzwerkverbindung erreichbar ist.
  - Lesen Sie die MAC-Adresse der Kamera aus `system/found-camera-mac-addresses` (gleiche Position in der Liste wie ihre Seriennummer in `system/found-camera-serials`).
  - Setzen Sie `gateway`, `ip`, `subnet` und die MAC-Adresse der Kamera.
  - Warten Sie, bis `ready` true ist, setzen Sie `request` auf true und dann wieder auf false.
  - Wenn `ready` wieder true ist, zeigt `system/found-camera-ip-addresses` die neue Adresse. Falls nicht, setzen Sie die IP mit dem Programm des Kameraherstellers.
- **Mehr:** [Kamera-IP-Adresse einrichten](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/setup-camera-ip-address.html), [IP-Konfiguration der Kamera erzwingen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#force-ip-configuration-of-camera)

## Konfiguration

### Wo liegen die Konfigurationsdateien, und wie füge ich eine Kamera hinzu? {#faq-config-files}

- **Antwort:** `lumiscan-cam-driver.json` enthält die Anwendungseinstellungen und listet die zu ladenden Kamerakonfigurationsdateien auf; jede weitere Datei (zum Beispiel `camera_example.json`) konfiguriert eine Kamera.
  - Auf ctrlX OS: Öffnen Sie in der ctrlX-OS-Weboberfläche **Home** > **Manage app data**, wählen Sie im Drei-Punkte-Menü **File View** und öffnen Sie den Ordner `lumiscan-cam-driver`. Um eine Kamera hinzuzufügen, kopieren Sie eine vorhandene Kameradatei (drei Punkte > **COPY**), geben ihr einen neuen Namen, tragen diesen Namen in die Liste der Kamerakonfigurationsdateien in `lumiscan-cam-driver.json` ein und starten die Anwendung neu.
  - Auf einem PC: Die Dateien sind gewöhnliche Dateien in dem Ordner, aus dem der Cam Driver seine Einstellungen liest; der Cam Driver nennt ihn, wenn Sie mit `--generate-settings` ein Beispiel schreiben. Unter Windows ist das `%APP_RESOURCE_DIR%\etc\lumiscan-cam-driver` oder standardmäßig `C:\ProgramData\HD Vision Systems GmbH\LumiScan Vision Suite\lumiscan-cam-driver\etc\lumiscan-cam-driver`. Kopieren Sie eine Kameradatei unter neuem Namen, tragen Sie sie in `lumiscan-cam-driver.json` ein und starten Sie den Cam Driver neu.
  - Auf beiden: `system/settings` zeigt und ändert die Dateien auf dem Data Layer, und `system/control/create-module` und `activate-module` fügen ein Kameramodul hinzu; starten Sie danach mit `system/control/restart/execute` neu.
- **Mehr:** [Kamerakonfiguration einrichten](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/setup-camera-configuration.html#edit-with-built-in-website), [Neue Kamera-Einstellungsdateien anlegen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/creating-new-camera-settings-files.html), [Module hinzufügen und entfernen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html#adding-and-removing-modules)

### Welche Einstellungen enthält eine Kamerakonfigurationsdatei? {#faq-camera-parameters}

- **Antwort:** `inputFileType` muss `camera-configuration` sein. Die Kameraeinstellungen sind `id` (muss über alle Kameraeinstellungen hinweg eindeutig sein; sie ist der Name des Moduls auf dem Data Layer und darf nur Kleinbuchstaben, Ziffern, `-` und `_` enthalten), `serial` (eine Seriennummer, die `simulation` enthält, macht die Kamera zu einer simulierten), `exposureTimeUS`, `pixelFormat` (`RGB8` oder `Mono8`), `timestampSource` (`Camera` oder `System`; ab v2.0.0 ist der Kamera-Zeitstempel der Standard) und, optional und experimentell, `stream.tag`. Parameter können auf dem Data Layer unter `…/input/` überschrieben werden. Starten Sie die Anwendung nach dem Ändern der Datei neu.
- **Mehr:** [Beispielinhalt einer Kameradatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/camera-example-file-content-example.html)

### Wie ändere ich andere GenICam-Features der Kamera? {#faq-genicam-features}

- **Antwort:** Verbinden Sie die Kamera, und bearbeiten Sie dann die Knoten unter `hdvisionsystems/lumiscan-cam-driver/<camera name>/features`. Ihre Namen, Werte, Zugriffsrechte und Beschreibungen kommen direkt von der Kamera; ziehen Sie die Dokumentation des Kameraherstellers heran. Werte werden direkt in die Kamera geschrieben, seien Sie also bei Netzwerkeinstellungen vorsichtig. Diese Funktion ist als experimentell gekennzeichnet: Werte werden nicht zwischengespeichert, und wiederholtes Setzen (zum Beispiel von einer SPS aus) kann die Kamera instabil machen und die Leistung beeinträchtigen. Ein auf einen Feature-Knoten geschriebener Wert geht verloren, wenn die Kamera erneut verbunden wird; eine Feature-Datei, die in `cameras[].featureFiles` des Moduls aufgeführt ist, wird bei jedem Verbinden der Kamera angewendet.
- **Mehr:** [GenICam-Features](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#genicam-features), [Für die höchste Bildrate: TriggerOverlap](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#trigger-overlap), [Release Notes: v2.0.0](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/release-notes/v2-0-0-2026-06-02.html)

### Wie speichere ich Bilder intern, auf USB/SD-Karte oder auf einer Samba-Freigabe? {#faq-image-storage}

- **Antwort:** Fügen Sie dem Abschnitt `system` von `lumiscan-cam-driver.json` einen Block `storage` hinzu, und starten Sie die Anwendung neu. Ohne ihn tut **Save** nichts.
  - `type`: `Null`, `Internal` (interner Speicher; auf ctrlX OS auch ein USB-Speichergerät oder eine SD-Karte) oder `Samba` (freigegebener Windows-Ordner).
  - `Internal`: `rootPath`. Ein relativer Pfad speichert im internen Verzeichnis der Anwendung. Auf ctrlX OS speichert ein Pfad, der mit dem Pfad des eingebundenen Geräts beginnt (zum Beispiel `/media/sdb1/myCapturedImages`), auf diesem Gerät; USB/SD-Geräte müssen FAT32 oder EXT4 verwenden und unter **Settings** > **Storage Devices** eingebunden sein.
  - `Samba`: `ip`, `remotePath`, `domain` (`""`, wenn es keine gibt), `username`, `password`. Das Passwort wird im Klartext gespeichert, verwenden Sie also kein reguläres Benutzerkonto.
  - Ab v2.2.0 bewirkt `unifiedStorage` (Standard `false`: ein Ordner pro Kamera) auf `true`, dass alle Kameras den Speicherordner direkt verwenden.
- **Mehr:** [Speichereinstellungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/application-settings-content-example.html#storage-settings), [Bilddateien speichern](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#saving-image-files)

## Betrieb

### Soll ich die Execute-Methode oder den ready/request-Handshake verwenden? {#faq-execute-or-handshake}

- **Antwort:** Beide führen zum selben Ergebnis. Ab v2.1.0 können `capture`, `save`, `load`, `remove` und `list-images` mit einem Schreibvorgang auf `<camera name>/control/<operation>/execute` gestartet werden, der zurückkehrt, wenn die Operation abgeschlossen ist; ab v2.3.0 wird `trigger` nur als `execute`-Methode angeboten. `connect-camera`, `disconnect-camera` und `reset` haben keinen `execute`-Knoten und müssen den Handshake verwenden. Es darf immer nur ein Prozess `request` schreiben, und in beiden Fällen prüfen Sie danach `control/status/code` und `control/status/text`. Handshake-Schritte:
  - Warten Sie, bis `ready` true ist.
  - Setzen Sie `request` auf true, und warten Sie, bis `ready` auf false wechselt: Die Anwendung hat den Request erkannt.
  - Setzen Sie `request` auf false, warten Sie, bis die Operation abgeschlossen ist, und lesen Sie ihren Ausgang auf `control/status/code`.
  - Ein fehlgeschlagenes `capture` über den Handshake endet bei Status `3` (`waitingForClient`), nicht bei seinem eigenen Fehlercode, und `capture/ready` bleibt false, bis ein `reset` erfolgreich ist. `capture/execute` behält den eigenen Code des Capture.
- **Mehr:** [Eine Methode ausführen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html#choosing-between-the-two), [Wann eine Funktionalität läuft](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/general-concept-of-handshake.html#when-a-functionality-runs), [Handshake](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/handshake.html)

### Wo finde ich das aufgenommene Bild, und wie kann ich es ansehen? {#faq-image-output}

- **Antwort:** Das Bild wird auf `hdvisionsystems/lumiscan-cam-driver/<camera name>/output/image` zusammen mit Breite, Höhe und Pixeltyp veröffentlicht, unabhängig davon, wie das Capture gestartet wurde. Das sind Sensor-Rohdaten, die die meisten Bildbetrachter nicht anzeigen können. Ab v2.1.0 schalten Sie `<camera id>/input/preview/enable` ein, um nach jedem erfolgreichen Capture oder Load ein PNG auf `<camera id>/output/preview/encoded-data` zu erhalten; `<camera id>/input/preview/scale` (0.0 bis 1.0) verkleinert es. Vergleichen Sie `output/package-identifier`, um zu prüfen, ob die Vorschau zum neuesten Bild gehört. Um jedes Bild zu erhalten, das die Kamera liefert, verwenden Sie den experimentellen Bild-Stream auf `<camera name>/control/publish/output/stream/frame` (ab v2.3.0).
- **Mehr:** [Beschreibung](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/description.html), [Bilder streamen (experimentell)](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html), [Release Notes: v2.1.0](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/release-notes/v2-1-0-2026-07-17.html)

### Wie funktioniert der Simulationsmodus? {#faq-simulation-mode}

- **Antwort:** Geben Sie der Kamera eine `serial`, die `simulation` enthält (zum Beispiel `simulation`); das Modul sucht dann keine echte Kamera und verbindet sich mit keiner. Ob eine Kamera simuliert wird, hängt von ihrer Seriennummer ab, nicht von ihrer `id`. Ein Aufruf von **Capture** lädt ein Bild aus dem konfigurierten Speicherordner und springt für das nächste Capture zum nächsten Bild. Seit v2.0.0 werden die Bilder aus `images/<camera id>` statt aus `images` genommen (verschieben Sie vorhandene Bilder vor dem Update), und der Ordner wird beim Verbinden eingelesen, sodass ein Aufruf von `list-images` nicht nötig ist. Ab v2.2.0 verwendet `unifiedStorage` auf `true` den Speicherordner direkt.
- **Mehr:** [Bilder laden](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/initializing-the-camera.html#loading-images), [Beispielinhalt einer Kameradatei](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/camera-example-file-content-example.html), [Release Notes: v2.0.0](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/release-notes/v2-0-0-2026-06-02.html)

### Wie erhalte ich jedes Bild statt eines pro Capture? {#faq-image-stream}

- **Antwort:** Verwenden Sie ab v2.3.0 den experimentellen Bild-Stream. Verbinden Sie die Kamera, setzen Sie ihre Features (für die höchste Bildrate `TriggerOverlap` nicht `Off`), abonnieren Sie `<camera name>/control/publish/output/stream/frame`, setzen Sie `control/publish/input/enable` auf `true` und rufen Sie `control/publish/execute` auf. Der Cam Driver triggert die Kamera nicht von selbst: Bilder kommen bei einem Hardware-Trigger, bei `control/trigger/execute` oder kontinuierlich bei ausgeschaltetem Trigger-Modus. Solange der Stream läuft, ist `capture` nicht verfügbar; nach dem Stoppen des Streams wird die Kamera erneut verbunden, was bei der von uns getesteten Kamera etwa zwei Sekunden dauert.
- **Mehr:** [Einen Stream betreiben](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html#running-a-stream), [Streams](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/streams.html)

## Fehlerbehebung {#troubleshooting}

Probleme und Fehlermeldungen sind Schritt für Schritt unter [Fehlerbehebung](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html) beschrieben:

- [Eine konfigurierte Kamera erscheint nicht im Data Layer](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-camera-not-in-data-layer)
- [Module beantworten keinen Request, und der Status ist -5 "restartRequired"](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-restart-required)
- ["No valid license found, please purchase one. If you do have one, please try to restart ctrlX"](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-missing-license)
- [Eine physisch angeschlossene Kamera wird nicht erkannt](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-camera-not-detected)
- [Die Kamera verbindet sich nicht (Status -10000 "failedToConnectToCamera")](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-failed-to-connect-to-camera)
- [Die Bildaufnahme schlägt fehl oder ist unzuverlässig (Status -10004 "couldNotCaptureImage")](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-could-not-capture-image)
- [Ein Schreibvorgang auf execute antwortet mit "DL_TOO_MANY_OPERATIONS" oder "TooManyOperations"](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-dl-too-many-operations)
- [Ein Schreibvorgang auf execute antwortet mit "DL_INVALID_OPERATION_MODE", oder capture wird immer wieder abgelehnt](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-dl-invalid-operation-mode)
- [Bilder werden nicht gespeichert (Status -10006 "saveImageFailed" oder -10005 "noImageTaken")](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-save-image-failed)
- [Bilder entsprechen nicht den Erwartungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#ts-images-not-as-expected)
- [Capture wird abgelehnt, während der Bild-Stream läuft](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#faq-capture-refused-streaming)
- [Der Bild-Stream liefert keine Bilder oder weniger als erwartet](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/how-tos/troubleshooting_cam_driver.html#ts-stream-missing-images)

## Lizenzierung und Support

### Welche Lizenz benötige ich, und warum funktioniert meine alte Lizenz nicht mehr? {#faq-licence-v2}

- **Antwort:** Ab v2.0.0 benötigt der Cam Driver die Lizenz `SWL-W-XCx-CAMDRIVERxHDVSx-V2NN`; Schlüssel der Version 1 funktionieren nicht. Sie benötigen eine Lizenz pro verbundener Kamera. Auf ctrlX OS (ctrlX CORE oder IPC) ist eine im ctrlX Store gekaufte Lizenz eine ctrlX-Lizenz und benötigt keinen LumiScan Key. Zu anderen Bezugswegen siehe die FAQ zur Lizenzierung.
- **Mehr:** [Voraussetzungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/requirements.html#licence), [FAQ zur Lizenzierung](https://docs.hdvisionsystems.com/de/lumiscan-licensing-de/1.0.4/faq.html)

### Wo finde ich weitere Antworten oder Support? {#faq-support}

- **Antwort:** Siehe die [LumiScan-FAQ](https://docs.hdvisionsystems.com/de/faq.html) der gesamten Dokumentation und für Fragen zum Data Layer selbst die [FAQ zum Data Layer](https://docs.hdvisionsystems.com/de/lumiscan-keryx-de/1.0.0/faq.html). Kontaktieren Sie den Customer Success von HD Vision Systems unter [customer.success@hdvisionsystems.com](mailto:customer.success@hdvisionsystems.com) oder +49 6221 6721905; für Lizenzen [licenses@hdvisionsystems.com](mailto:licenses@hdvisionsystems.com).
- **Mehr:** [FAQ zur Lizenzierung](https://docs.hdvisionsystems.com/de/lumiscan-licensing-de/1.0.4/faq.html)

# v2.3.0 - noch nicht veröffentlicht – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/release-notes/v2-3-0.html

**Neu:**

- **Bild-Stream (experimentell).** Eine Kamera kann ihre Bilder jetzt streamen, statt ein Bild pro Capture-Request aufzunehmen. `<camera name>/control/publish/execute` wendet die Eingaben `control/publish/input/enable` und `keep-latest-output` an. Solange der Stream läuft, veröffentlicht der Cam Driver jedes Bild, das die Kamera liefert, auf `control/publish/output/stream/frame` für einen Abonnenten, zusammen mit seiner Größe, seinem Pixelformat und seiner Lineage: der Kamera, dem Start des Streams und der Nummer des Bildes darin. Der Cam Driver triggert die Kamera nicht von selbst: Ein Bild kommt bei einem Hardware-Trigger, bei `control/trigger/execute` oder kontinuierlich, solange der Trigger-Modus der Kamera aus ist. Mit fester Rate getriggert lieferte die von uns getestete Kamera jedes Bild mit bis zu 66 Bildern pro Sekunde, gegenüber etwa 34 mit `capture/execute`, mit ihrem `TriggerOverlap` in einer Feature-Datei auf `PreviousFrame` gesetzt. `keep-latest-output` legt jedes Bild zusätzlich auf `output/image` ab und zählt es auf `output/package-identifier`, um den Preis einer Kopie pro Bild. Zähler unter `control/publish/output/stream/statistics` zeigen Bilder und Verluste.

  Jedes Bild wird auf beiden Data Layern geliefert. `setting/settings-hash` identifiziert die Einstellungen, mit denen die Bilder aufgenommen werden, und jeder Frame trägt ihn. Jeder Frame trägt außerdem das Tag des Moduls - den Kameranamen oder das Tag, das `control/publish/input/tag` vorgibt und das in der Modulkonfigurationsdatei als `stream.tag` gespeichert wird - und die Anwendungen, die die Bilder verarbeiten, behalten es in der Lineage ihrer Ergebnisse. Der Hash sagt, dass sich die Einstellungen geändert haben, nicht, was sich geändert hat; und dass er einer Änderung eines Kamera-Features folgt, wurde noch nicht mit einer echten Kamera geprüft.

  Solange der Stream läuft, ist `capture` nicht verfügbar: `capture/ready` ist `false`, `capture/execute` antwortet mit `DL_INVALID_OPERATION_MODE`, und ein Capture-Request endet mit Status `-3`, ohne einen Fehler zu speichern. Das Stoppen des Streams verbindet die Kamera erneut, sodass `capture/ready` bei der von uns getesteten Kamera nach etwa zwei Sekunden zurückkehrt. Siehe [Bilder streamen (experimentell)](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/streaming-images.html).

- **Software-Trigger.** `<camera name>/control/trigger/execute` sendet der Kamera einen Software- Trigger, solange sie im Software-Trigger-Modus ist - ihr Trigger-Modus eingeschaltet und ihre Trigger-Quelle Software, gelesen in der eigenen Schreibweise der Kamera - und tut in jedem anderen Modus nichts. Der Befehl ist der kameraeigene, `TriggerSoftware` oder `SoftwareTrigger`. Eine Kamera in diesem Modus ohne einen der beiden, oder die ihn ablehnt, meldet den neuen Status `-10012` (`softwareTriggerFailed`). Solange der Bild-Stream läuft, wird eine Kamera ohne Software- Trigger-Modus - eine simulierte Kamera oder eine Plugin-Kamera ohne `TriggerSoftware` - stattdessen durch ihren eigenen Trigger ausgelöst, ein Bild pro Aufruf. Siehe [Software-Trigger](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html#software-trigger).

- **Feature-Mappings.** Eine Kamera, die ihren Software-Trigger-Befehl, ihren Trigger-Modus oder ihre Trigger-Quelle oder deren Werte anders benennt, erhält ihre eigenen Namen in der Anwendungs-Einstellungsdatei: einen Eintrag unter `featureMappings`, benannt über die `featureMappingId` der Kamera. Das Schema listet die Schlüssel auf. Ein gemappter Name, den die Kamera nicht hat, wird als Warnung protokolliert, und die eingebauten Namen werden verwendet. Siehe [Software-Trigger](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html#software-trigger).

- **Ein Beispiel der Einstellungen, auf einem PC.** `-g, --generate-settings [folder]` schreibt die Anwendungs-Einstellungsdatei, eine Beispiel-Moduldatei und ihre Schemas in einen Ordner (standardmäßig den aktuellen), nennt den Ordner, aus dem der Cam Driver seine Einstellungen liest, und beendet sich. Vorhandene Dateien werden nie überschrieben. Siehe [Neue Kamera-Einstellungsdateien anlegen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/creating-new-camera-settings-files.html).

- **Einstellungen auf dem Data Layer.** `hdvisionsystems/lumiscan-cam-driver/system/settings` zeigt die Einstellungen, mit denen die Anwendung gestartet wurde: die Einstellungsdatei der Anwendung, jede Moduldatei eingebettet in ihre Liste `modules`, Passwörter als `***`. Ein Schreibvorgang darauf ändert die Dateien. Die Anwendung prüft die Änderung wie beim Start, speichert sie (die vorherige Datei als `.bak`) und verweigert dann jede Arbeit, bis sie neu gestartet wird: `restart-required`, Status `-5`. `hdvisionsystems/lumiscan-cam-driver/system/control/restart/execute` startet sie neu. Siehe [Einstellungen auf dem Data Layer](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/settings-on-the-data-layer.html).

**Fehlerbehebung:**

- **Der Cam Driver startet wieder auf einer ctrlX CORE.** Seit dem Umstieg auf die neue Kommandozeile lehnte er das `-p 8080` ab, das sein Snap übergibt, und beendete sich sofort. Er akzeptiert und ignoriert `-p` jetzt, und das Snap übergibt es nicht mehr.
- **Ein Programm, das ein abgelehntes `execute` immer wieder aufruft, überflutet das Protokoll nicht mehr.** Jede Ablehnung wurde als eigene Zeile geschrieben, sodass ein Programm, das `capture/execute` wiederholte, während die Kamera belegt war, etwa 11 MB Protokoll pro Minute schrieb. Für jede Methode und jedes Ergebnis wird die erste Ablehnung protokolliert, danach höchstens eine Zeile alle zehn Sekunden, die angibt, wie viele nicht einzeln protokolliert wurden.

# v2.2.0 - 2026.08.05 – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/release-notes/v2-2-0-2026-08-05.html

**Neu:**

- **Alle Kameras können jetzt einen gemeinsamen Bildordner verwenden.** Eine neue Systemeinstellung **unifiedStorage** legt fest, wo Bilder abgelegt werden. Mit dem Standard `false` speichert und lädt jede Kamera ihre Bilder in einem eigenen, nach der Kamera benannten Ordner, wie in v2.0.0 eingeführt. Auf `true` gesetzt verwenden alle Kameras den Speicherordner direkt, also die flache Struktur, die vor v2.0.0 galt. Die Einstellung gilt sowohl für gespeicherte Bilder als auch für die Bilder, die der Simulationsmodus lädt.

**Geändert:**

- **Ein abgelehntes `execute` sagt jetzt, ob Warten hilft.** Ein Schreibvorgang auf `<camera name>/control/<operation>/execute`, während das Signal `ready` der Operation `false` ist, antwortet jetzt mit `DL_INVALID_OPERATION_MODE`; `DL_TOO_MANY_OPERATIONS` bedeutet nur noch das, was es sagt: dass die Kamera mit einer anderen Operation belegt ist und derselbe Befehl gleich funktionieren wird. Beides wurde bisher gleich gemeldet, sodass ein Programm, das bei "belegt" wiederholt, endlos wiederholen konnte, zum Beispiel nach einem Capture ohne Verbindung, einem Save, bevor etwas aufgenommen wurde, oder einem erneuten Capture nach einem Capture-Fehler, den nur ein `reset` behebt. Siehe [Wann eine Operation bereit ist](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/execute-a-method.html#when-is-an-operation-ready).
- **Die Anwendung weist jetzt nach, dass sie laufen darf, indem sie ihre Lizenzen tatsächlich belegt.** Bisher fragte sie den Lizenzdienst, wie viele Lizenzen auf dem Gerät vorhanden sind. Diese Zahl zählt auch Lizenzen mit, die eine andere Anwendung bereits belegt hatte, sodass der Cam Driver mit einer Lizenz starten konnte, die gar nicht frei war, und dann fehlschlug. Er belegt jetzt beim Start die benötigten Lizenzen und verweigert den Start, wenn er sie nicht erhält, wobei er die Lizenz und die benötigte Anzahl nennt.
- **Lizenzen werden alle 30 Minuten erneuert.** Läuft eine Lizenz ab, wird sie entzogen oder gewährt der Lizenzdienst sie nicht mehr, schreibt die Anwendung eine Warnung mit dem Namen der Lizenz und beendet sich, statt ohne gültige Lizenz weiterzulaufen. Bisher blieb eine während des Betriebs verlorene Lizenz unbemerkt.

**Fehlerbehebung:**

- **Getrennt installierte Lizenzen werden jetzt alle gefunden.** Die Anwendung betrachtete bisher nur den ersten Eintrag Cam Driver V2, den ctrlX OS meldete. Ein Gerät, dessen Lizenzen nacheinander installiert worden waren, schien daher nur eine Lizenz zu haben, und ein für mehrere Kameras konfigurierter Cam Driver verweigerte den Start mit der Meldung, dass nicht genügend Lizenzen vorhanden seien.
  > [!NOTE]
  > Das betrifft **v2.1.0 und älter**. Installieren Sie bei diesen Versionen bitte alle Lizenzen gemeinsam, sodass die Seite **Licenses** von ctrlX OS **einen** Eintrag Cam Driver V2 zeigt, der alle Kameras abdeckt, statt eines Eintrags pro Lizenz. Tritt das Problem auf, meldet die Anwendung den Status `missingLicense` (Code -4) mit dem Text "No valid license found, please purchase one. If you do have one, please try to restart ctrlX" und beendet sich. Siehe [Voraussetzungen](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/requirements.html).
- **Das Beenden ist schneller.** Die Rückgabe jeder Lizenz dauerte etwa fünf Sekunden, sodass ein Cam Driver mit drei Lizenzen rund fünfzehn Sekunden länger zum Beenden brauchte als nötig.

# v2.1.0 - 2026.07.17 – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/release-notes/v2-1-0-2026-07-17.html

**Neu:**

- **Ein einfacherer Weg, eine Kamera auszulösen.** Jede Kameraoperation (capture, save, load, remove, list-images) kann jetzt mit einem einzelnen Befehl unter `<camera id>/control/<operation>/execute` gestartet werden. Der Befehl führt die Operation aus und kehrt erst zurück, wenn sie abgeschlossen ist; Sie müssen also nicht mehr auf ein "ready"-Signal warten und dann einen "request" senden. Die Ergebnisse erscheinen genau dort, wo sie vorher erschienen, und der Ausgang wird auf `status/code` und `status/text` gemeldet. Der bekannte ready/request-Handshake funktioniert weiterhin, bestehende Programme müssen also nicht geändert werden.
  > [!NOTE]
  > Connect, Disconnect und Reset werden bewusst nicht auf diese Weise angeboten. Sie können mehrere Sekunden dauern, und ein wartender Befehl würde meist aufgeben, bevor die Kamera den Erfolg meldet. Verwenden Sie für diese drei bitte weiterhin den ready/request-Handshake.
  > [!NOTE]
  > Ist die Kamera bereits mit einer anderen Operation belegt, wird der Befehl mit `DL_TOO_MANY_OPERATIONS` abgelehnt, statt in eine Warteschlange gestellt zu werden.

- **Ein anzeigbares Vorschaubild.** Schalten Sie `<camera id>/input/preview/enable` ein, und jedes erfolgreiche Capture oder Load veröffentlicht zusätzlich ein direkt anzeigbares PNG-Bild auf `<camera id>/output/preview/encoded-data`. Das ist nützlich, um zu prüfen, was die Kamera tatsächlich sieht, denn die normale Bildausgabe sind Sensor-Rohdaten, die die meisten Bildbetrachter nicht anzeigen können. Das Format wird auf `<camera id>/output/preview/encoded-format` genannt und ist derzeit immer PNG.

  Die Vorschau kann mit `<camera id>/input/preview/scale` verkleinert werden (ein Wert zwischen 0.0 und 1.0, 1.0 bedeutet volle Größe). Eine kleinere Vorschau kostet weniger Zeit pro Zyklus, um den Preis geringerer Details. Werte außerhalb des zulässigen Bereichs werden als volle Größe behandelt.

  Die Vorschau ist standardmäßig ausgeschaltet, und solange sie aus ist, kostet sie keine Zeit. Das Erzeugen einer Vorschau lässt auch nie ein Capture fehlschlagen: Kann sie nicht erzeugt werden, wird eine Warnung in das Protokoll geschrieben, und die vorherige Vorschau bleibt bestehen. Ob eine Vorschau zum neuesten Bild gehört, erkennen Sie durch Vergleich von `output/package-identifier`.

**Geändert:**

- **Reset weist jetzt nach, dass die Kamera wirklich funktioniert.** Bisher trennte Reset die Kamera nur. Trennen gelingt immer - auch bei einer Kamera, die physisch abgezogen wurde -, sodass Reset Erfolg für eine Kamera melden konnte, die tatsächlich tot war, und Bediener verständlicherweise annahmen, sie sei einsatzbereit. Reset trennt jetzt, verbindet erneut, um nachzuweisen, dass die Kamera erreichbar ist, trennt dann noch einmal und gibt eine **getrennte** Kamera zurück. Rufen Sie wie bisher danach selbst `control/connect-camera` auf. Ist die Kamera nicht erreichbar, meldet Reset `failedToConnectToCamera`, nennt die Kamera in `status/text` und meldet das Problem weiter, bis ein Reset tatsächlich gelingt. Da Reset jetzt einen vollständigen Verbindungstest durchführt, dauert es entsprechend länger als bisher.

**Fehlerbehebung:**

- **Eine Kamera, die abgezogen und wieder angeschlossen wurde, lässt sich jetzt ohne Neustart der Anwendung wiederherstellen.** Bisher verwendete der Treiber weiter die alte Verbindung zu einer Kamera, die das Netzwerk verlassen hatte, und jeder Verbindungsversuch schlug fehl, bis die Anwendung neu gestartet wurde. Reset sucht die Kamera jetzt erneut und versucht es einmal noch, was eine wieder angeschlossene Kamera zurückbringt. Die Suche erfolgt nur, nachdem ein Verbindungsversuch bereits fehlgeschlagen ist, sodass ein Reset einer funktionierenden Kamera die anderen Kameras nicht stört.
- **Falsche Bildgröße bei 12-Bit-Bildern.** Bei den 12-Bit-Formaten (mono12, bayer_rg12, rgb12, bgr12) gab `output/image/data` doppelt so viele Bytes an, wie das Bild tatsächlich enthält, und die zusätzlichen Bytes waren beliebiger Speicherinhalt. 8-Bit-Formate waren nicht betroffen.
- **Absturz beim Verbinden im Simulationsmodus.**
- **Simulierte Bilder verschiedener Kameras konnten vertauscht werden.** Das Speichern des aktuellen Bildes und das Laden eines Simulationsbildes verwenden jetzt einen nach der Kamera benannten Unterordner, sodass jede Kamera ihre eigenen Bilder behält.

# v2.0.0 - 2026.06.02 – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/release-notes/v2-0-0-2026-06-02.html

**Breaking Changes:**

- Ein neuer Lizenzschlüssel ist erforderlich: `SWL-W-XCx-CAMDRIVERxHDVSx-V2NN`. Schlüssel der Version 1 funktionieren mit diesem Release nicht.
- Der Simulationsordner hat sich geändert: Die Simulation lädt Bilder aus `images/<camera id>` statt aus `images`. Wenn Sie den Simulationsmodus verwenden, verschieben Sie Ihre vorhandenen Bilder vor dem Update in den nach der Kamera benannten Ordner.

**Neu:**

- **Mehrere Kameras gleichzeitig.** Eine Installation kann jetzt mehr als eine Kamera betreiben. Beachten Sie, dass jede verbundene Kamera eine eigene Lizenz benötigt.
- **Genauere Bild-Zeitstempel.** Der Zeitstempel der Bilder ist jetzt standardmäßig die von der Kamera selbst gemeldete Zeit, die näher am tatsächlichen Aufnahmezeitpunkt liegt. Die ctrlX-Systemuhr ist weiterhin verfügbar, wenn Sie das alte Verhalten bevorzugen (siehe **timestampSource** in Tabelle 7).
- **Kamera-IP-Adressen aus der Steuerung setzen.** Sie benötigen kein separates Werkzeug mehr, um einer Kamera die richtige Netzwerkadresse zu geben.
- **Netzwerkdetails der Kameras ohne Neustart sehen.** Die IP- und MAC-Adressen der im Netzwerk gefundenen Kameras werden jetzt direkt angezeigt, sodass für eine Prüfung kein Neustart des Cam Driver mehr nötig ist.
- **Immer das neueste Bild erhalten.** Eine neue Kameraeinstellung, **clearBufferBeforeCapture**, verwirft ältere Bilder, die noch in der Warteschlange warten, sodass ein Capture immer ein frisches Bild liefert.

**Verbessert:**

- Im Simulationsmodus wird beim Verbinden der Speicherordner nach Bildern durchsucht. Benutzer **müssen list-images nicht mehr aufrufen**.
- Die Beispieleinstellungen enthalten jetzt ein Beispielbild und verwenden standardmäßig den internen Speicher, sodass ein erster Test ohne Vorbereitung funktioniert.
- Zusätzliche Protokollmeldungen erleichtern die Prüfung, wie schnell der Cam Driver läuft.

**Fehlerbehebung:**

- Der Neustart der Anwendung konnte lange dauern, weil nach dem Beenden eine Verbindung offen blieb. Neustarts sind wieder schnell.
- Die Einstellung **inter-package-delay-us** konnte nach dem Verbinden der Kamera noch geändert werden, hatte dort aber keine Wirkung. Sie ist jetzt gesperrt, sobald die Kamera in Verwendung ist.

**Experimentell (mit Vorsicht verwenden):**

- Benutzer können GenICam-Features (Device) jetzt im Data Layer unter `lumiscan-cam-driver/<camera id>/features.` setzen.

> [!NOTE]
> Derzeit werden Features nicht zwischengespeichert. Setzt ein Benutzer (d. h. eine SPS) Feature-Werte wiederholt, kann das zu Instabilität der Kamera und Leistungseinbußen führen.

# v1.2.0 - 2025.07.01 – LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/release-notes/v1-2-0-2025-07-01.html

**Neu:**

- Unterstützung für internen Speicher, SD-Karte und USB-Speicher.
- Benutzer können gespeicherte Daten jetzt entfernen.
- Volle Kontrolle über GenICam-Features. Zusätzlicher Parameter `initialFeatureFile` in der Kamera.

**Verbessert:**

- Nach der Installation wird das Einstellungsschema im Konfigurationsverzeichnis aktualisiert.
- Unterstützung für Xenics-Kameras; die Anforderung an einige nicht benötigte GenICam-Features wurde entfernt. Hinweis: Unsere App **erwartet weiterhin**: **Width, Height, PixelFormat** und **DeviceSerialNumbe.**

**Fehlerbehebung:**

- Hohe CPU-Auslastung beim Beenden des Programms, wenn keine Lizenz erkannt wurde, was die ctrlX CORE lahmlegte.

# LumiScan Cam Driver

URL: https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/index.html

|   |   |   |
| --- | --- | --- |
| ![Zwei GenICam-Kameras an einem ctrlX CORE](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/intro/step-1.svg)<br><br>**GenICam-Kameras anschließen.** GigE-Vision-Kameras an ctrlX CORE oder PC. | ![Kamerabild, veröffentlicht als Knoten camera1/output/image](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/_images/intro/step-2.svg)<br><br>**Jedes Bild landet auf dem Data Layer.** Alle anderen LumiScan-Apps lesen es von dort. | Beispiel: camera1/output/image<br><br><br><br><br><br><br>width<br>2448<br><br><br>height<br>2048<br><br><br>pixel-type<br>RGB8<br><br><br>is-connected<br>TRUE<br><br>**Aufnahme auf Befehl.** Belichtung, Pixelformat und Trigger je Kamera. |

LumiScan Cam Driver bindet Ethernet-Kameras nach dem GenICam-Standard an und stellt ihre Bilder und Kamerafunktionen auf dem Data Layer bereit. Er findet und verbindet die Kameras, nimmt Bilder auf und stellt Belichtungszeit, Pixelformat und weitere GenICam-Merkmale ein. Alle anderen LumiScan-Apps beziehen ihre Bilder von ihm, auf ctrlX OS oder auf einem PC mit Windows 11 oder Ubuntu 24.04.

Zur Lizenzierung siehe [Lizenz](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/lumiscan-camdriver/requirements.html#licence). Fragen oder eine Fehlermeldung? Siehe die [FAQ](https://docs.hdvisionsystems.com/de/lumiscan-cam-driver-de/2.2.1/faq.html).
