> For the complete documentation index, see [llms.txt](https://docs.kiloiot.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.kiloiot.io/kilo-docs-de/kilo-iot-server/devices/emulated-devices.md).
# Emulierte Geräte
Erstellen Sie ein emuliertes Gerät in Kilo IoT — Geräte-Presets, Daten-Schlüssel und -Typen, Meldeintervall und die Umstellung auf echte Hardware.
Ein emuliertes Gerät, das auf dem Kilo IoT Server registriert ist, ist ein Digitaler Zwilling wie jeder andere — dasselbe Profil, dieselben Dashboards, dieselben Regeln, dieselben Alarme. Das Besondere daran ist, dass die Plattform ihre Telemetrie erzeugt, statt sie von Hardware zu empfangen. Damit ist es der Weg, eine Bereitstellung aufzubauen und zu beweisen, bevor überhaupt ein Sensor existiert.
Diese Seite behandelt die emulatorspezifischen Felder im Geräteformular und auf der Registerkarte Emulator. Der umliegende Registrierungsablauf — das Benennen des Geräts, die Registerkarte Metriken, die Registerkarte Protokolle, das Speichern — ist der gemeinsame Ablauf, der beschrieben wird in [Geräte registrieren](/kilo-docs-de/kilo-iot-server/devices/registering-devices.md).
## Voraussetzungen
* **Ein Emulator-Connector.** Einer pro Organisation, ohne etwas zu konfigurieren. Siehe [Emulator-Connector](/kilo-docs-de/kilo-iot-server/connectors/emulator-connector.md).
* **Nichts weiter.** Keine Zugangsdaten, keine Herstellerkennungen, kein Gateway, keine Funkabdeckung. Darum geht es.
## Den Connector auswählen
Öffnen Sie im Geräteformular die **Verbindung** Registerkarte und wählen Sie den Emulator-Connector als Connector-Typ. Das Formular zeigt dann die folgenden Felder an.
| Feld | Wofür es verwendet wird |
| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Device ID** | Die Kennung, unter der dieses emulierte Gerät meldet. 1–64 Zeichen, mit Buchstaben, Ziffern, Leerzeichen, `.`, `_` und `-`. Sie muss **plattformweit eindeutig**, nicht nur innerhalb Ihrer Organisation, sodass ein lesbarer, aber spezifischer Wert wie `cold-room-01` besser funktioniert als `sensor1`. |
| **Sendeintervall der Daten** | Wie oft das Gerät einen Messwert sendet, als Zahl plus Einheit (zum Beispiel 10 Minuten). Wählen Sie etwas, das der Melderate des realen Sensors nahekommt, damit Ihre Regeln realistisch reagieren. |
| **Support-Befehle** | Schalten Sie dies ein, um dem Gerät eine **Befehle & Zustände** Registerkarte zu geben, sodass Sie Befehle daran genau so definieren und ausführen können wie bei physischer Hardware. Siehe [Gerätebefehle](/kilo-docs-de/kilo-iot-server/devices/commands.md). |
| **Gerätevorgabe verwenden** | Beginnen Sie mit einem echten Gerätemodell, statt Metriken von Hand einzugeben. |
Anders als bei jedem anderen Connector ist das Intervall hier keine Beschreibung eines Zeitplans, den die Hardware bereits einhält — es ist der Zeitplan. Die Plattform sendet in diesem Intervall.
## Ausgehend von einer Gerätevorgabe
Das Aktivieren **Gerätevorgabe verwenden** öffnet eine Liste echter Sensormodelle. Wählen Sie das aus, das Sie haben — oder das, das Sie bestellt haben — und die Plattform trägt die tatsächlichen Messwerte dieses Modells für Sie ein.
Eine Vorgabe für mehrere Sensoren füllt zum Beispiel ihren vollständigen Satz an Messwerten aus — Temperatur, Luftfeuchtigkeit, Luftqualität und den Rest — jeweils mit dem richtigen Datentyp, und setzt ein sinnvolles Meldeintervall. Das ist der schnellste Weg zu einem realistischen Gerät, und es bedeutet, dass die Metriknamen, gegen die Sie Dashboards bauen, genau die sind, die der echte Sensor senden wird.
> **Eine Vorgabe ersetzt, was bereits dort ist.** Wenn Sie eine auswählen, überschreibt sie die von Hand eingegebenen Metriken und setzt das Intervall auf das der Vorgabe zurück. Wählen Sie zuerst die Vorgabe aus und passen Sie dann an.
**Gerätevorgaben sind keine** [**Geräteprofilvorlagen**](/kilo-docs-de/kilo-iot-server/devices/registering-devices.md#for-lorawan-devices-lns-connector)**.** Eine LoRaWAN-Geräteprofilvorlage konfiguriert, wie ein physisches Gerät mit dem Netzwerk kommuniziert — Klasse, Band, Codec. Eine Gerätevorgabe beschreibt, was ein emuliertes Gerät *misst*, und existiert nur im Emulator.
## Metriken manuell definieren
Ohne eine Vorgabe — oder zusätzlich dazu — verwenden Sie **Gerätedatenschlüssel hinzufügen** um jede Messung zu definieren:
* **Gerätedatenschlüssel** — der Metrikname, z. B. `temperature`. Auf diesen beziehen sich Dashboards, Regeln und Zuordnungen.
* **Datentyp** — `Float` für alles mit Dezimalstellen, `Integer` für ganze Zahlen und die anderen unterstützten Typen für Booleans und Text. Siehe [Messwerte](/kilo-docs-de/kilo-iot-server/devices/metric-templates.md) dazu, wie Typen über eine Bereitstellung hinweg normalisiert werden.
Wählen Sie den Datentyp bewusst. Ein **Integer** Metriktyp schneidet Dezimalstellen ab: Senden Sie `1.5` und das Gerät meldet `1`. Wenn eine Messung Dezimalgenauigkeit benötigt, muss sie eine **Float**.
## Werte senden
Sobald das Gerät gespeichert ist, listet seine **Emulator** Registerkarte jede Metrik mit zwei Steuerelementen auf:
* **Speichern** fixiert einen Wert. Das Gerät meldet diesen Wert weiterhin in seinem Intervall, so halten Sie einen Tank bei 8 % oder einen Gefrierschrank bei −18 °C, während Sie beobachten, wie eine Regel reagiert.
* **Einmal senden** überträgt sofort eine einzelne Messung, ohne zu ändern, was das Gerät danach meldet. Das ist die richtige Wahl, wenn Sie einen Schwellwert auf Abruf auslösen wollen.
Das Senden eines Werts ist eine **Schreibaktion** — es speist Verlauf, Regeln und Alarme genau wie echte Telemetriedaten. Ein Benutzer mit Lesezugriff kann ein emuliertes Gerät ansehen, aber keine Messwerte hinein einspeisen. Siehe [Benutzer und Berechtigungen](/kilo-docs-de/kilo-iot-server/account/users-and-permissions.md).
## Befehle an einem emulierten Gerät ausführen
Mit **Support-Befehle** aktiviert, erhält das Gerät eine **Befehle & Zustände** Registerkarte und verhält sich wie steuerbare Hardware. Dadurch können Sie einen Regelkreis aufbauen und vorab einüben, noch bevor die Geräte existieren: Eine Regel erkennt einen Zustand, sendet einen Befehl und der Alarm protokolliert, dass es passiert ist — ohne das Risiko, etwas Reales auszulösen.
Befehle definieren und ausführen funktioniert genauso wie bei einem physischen Gerät. Siehe [Befehle erstellen](/kilo-docs-de/kilo-iot-server/devices/commands/creating-commands.md) und [Befehle ausführen](/kilo-docs-de/kilo-iot-server/devices/commands/executing-commands.md).
## In den Live-Betrieb gehen: auf ein echtes Gerät umschalten
Das ist der Schritt, um den der Emulator herum gebaut ist. Wenn die Hardware eintrifft, öffnen Sie die **Verbindung** Registerkarte des Geräts und ändern Sie den Connector von **Emulator** auf den realen — LoRaWAN zum Beispiel — und geben Sie dann die Kennungen an, die das physische Gerät benötigt.
Alles andere am Gerät bleibt gleich: sein Name, sein Platz auf Ihren Dashboards, die daran gebundenen Regeln, seine Alarmdefinitionen und Eskalationsketten. Sie ersetzen die Datenquelle, nicht die Bereitstellung.
Der Wechsel ist absichtlich auf Paare beschränkt, die den Emulator einbeziehen — vom Emulator zum realen Gerät oder vom realen Gerät zurück zum Emulator. Ein direkter Wechsel zwischen zwei physischen Connector-Typen wird nicht angeboten, weil sich die Gerätekennungen und Nutzlastzuordnungen so stark unterscheiden, dass die Zuordnung ohnehin neu aufgebaut werden muss.
> Der umgekehrte Weg ist genauso nützlich: Verschieben Sie ein reales Gerät auf den Emulator, um ein Problem zu reproduzieren, und verschieben Sie es dann zurück.
## Ein emuliertes Gerät kopieren
Das Kopieren eines Geräts verschafft Ihnen einen Vorsprung beim Geräteeintrag, aber **es übernimmt die Emulator-Einrichtung nicht**. Das neue Gerät ist mit dem Namen des Originals, den Zeilen der Metrikvorlage, der Verbindungsauswahl und den Einstellungen sowie den Bildern vorgefüllt. Alles, was es *emulieren lässt* muss erneut eingerichtet werden:
* **Die Signaldefinitionen des Emulators** — die Metriken, die er erzeugt, und ihre Datentypen.
* **Das Meldeintervall**, das auf seinen Standardwert statt auf den des Originals zurückgesetzt wird.
* **Support-Befehle**, das wieder auf Aus zurückgesetzt wird.
* **Aus der Vorgabe abgeleitete Befehle.** Die Vorgabe des Originals erneut auszuwählen ist der schnellste Weg zurück.
Bis Sie das tun, meldet die Kopie überhaupt nichts — es ist ein Gerät, das an den Emulator mit einer leeren Spezifikation gebunden ist. **Sensorzuordnungen werden ebenfalls nicht übernommen**, also erstellen Sie sie nach dem Speichern auf der Kopie neu.
Siehe [Geräteverwaltung](/kilo-docs-de/kilo-iot-server/devices/device-management.md#copying-a-device).
## Bitten Sie den Assistenten, es zu tun
Der gesamte obige Workflow ist in Klartext über den [IoT AI Assistant](/kilo-docs-de/kilo-iot-server/ai-assistant.md). Er kann die verfügbaren Gerätevorgaben auflisten, ein emuliertes Gerät bereitstellen, seine Konfiguration und sein Intervall lesen und aktualisieren, eine einmalige Messung senden und das Gerät bei Vorhandensein der Hardware auf eine reale **LoRaWAN** Verbindung in den Live-Betrieb überführen. Er kann auch jedes reale Gerät auf den Emulator verschieben. Das Umschalten eines emulierten Geräts auf einen Mioty-, Tracker- oder MQTT-Connector ist ein manueller Schritt auf der Registerkarte Verbindung — der Assistent bietet das nicht an.
## Wie geht es weiter
* **Automatisierungen mit emulierten Daten erstellen** sodass sie vor dem Go-live erprobt sind. Siehe [Rules Engine](/kilo-docs-de/kilo-iot-server/rules-engine.md).
* **Eine Eskalationskette einüben** Ende-zu-Ende, ohne auf einen echten Ausfall zu warten. Siehe [Alarme](/kilo-docs-de/kilo-iot-server/alarm.md).
* **Den gemeinsamen Registrierungsablauf abschließen** — Geräteinformationen, Metriken, Protokolle. Siehe [Geräte registrieren](/kilo-docs-de/kilo-iot-server/devices/registering-devices.md).
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://docs.kiloiot.io/kilo-docs-de/kilo-iot-server/devices/emulated-devices.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
