> 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-es/kilo-iot-server/devices/emulated-devices.md).
# Dispositivos emulados
Crea un dispositivo emulado en Kilo IoT — ajustes preestablecidos del dispositivo, claves y tipos de datos, intervalo de reporte y el cambio a hardware real.
Un dispositivo emulado registrado en el Servidor IoT de Kilo es un gemelo digital como cualquier otro: mismo perfil, mismos paneles, mismas reglas, mismas alarmas. Lo específico es que la plataforma genera su telemetría en lugar de recibirla del hardware. Eso lo convierte en la forma de construir y demostrar una implementación antes de que exista cualquier sensor.
Esta página cubre los campos específicos del Emulador en el formulario del dispositivo y la pestaña Emulador. El flujo de registro circundante — nombrar el dispositivo, la pestaña Métricas, la pestaña Registros, guardar — es el flujo compartido documentado en [Registro de dispositivos](/kilo-docs-es/kilo-iot-server/devices/registering-devices.md).
## Requisitos previos
* **Un conector del Emulador.** Uno por organización, sin nada que configurar. Ver [Conector del Emulador](/kilo-docs-es/kilo-iot-server/connectors/emulator-connector.md).
* **Nada más.** Sin credenciales, sin identificadores de un fabricante, sin pasarela, sin cobertura de radio. Ese es el punto.
## Selección del conector
En el formulario del dispositivo, abre la **Conexión** pestaña y elige el conector del Emulador como tipo de conector. El formulario muestra entonces los campos siguientes.
| Campo | Qué hace |
| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **ID del dispositivo** | El identificador bajo el que este dispositivo emulado reporta. 1–64 caracteres, usando letras, dígitos, espacios, `.`, `_` y `-`. Debe ser **único en toda la plataforma**, no solo dentro de tu organización, así que un valor legible pero específico como `cold-room-01` funciona mejor que `sensor1`. |
| **Intervalo de envío de datos** | La frecuencia con la que el dispositivo emite una lectura, como un número más una unidad (por ejemplo, 10 minutos). Elige algo cercano a la tasa de informes del sensor real para que tus reglas se comporten de forma realista. |
| **Comandos de soporte** | Activa esto para darle al dispositivo una **Comandos y estados** pestaña, para que puedas definir y ejecutar comandos contra él exactamente como lo harías con hardware físico. Ver [Motor de Comandos de Dispositivos](/kilo-docs-es/kilo-iot-server/devices/commands.md). |
| **Usar preajuste del dispositivo** | Comienza a partir de un modelo de dispositivo real en lugar de escribir las métricas a mano. |
A diferencia de cualquier otro conector, el intervalo aquí no es una descripción de una programación que el hardware ya sigue — es la programación. La plataforma emite en él.
## Partiendo de un preajuste del dispositivo
Marcar **Usar preajuste del dispositivo** abre una lista de modelos de sensores reales. Elige el que tengas — o el que tengas encargado — y la plataforma rellena por ti las mediciones reales de ese modelo.
Un preajuste multisensor, por ejemplo, rellena su conjunto completo de lecturas — temperatura, humedad, calidad del aire y el resto — cada una con el tipo de dato correcto, y establece un intervalo de informes sensato. Es la forma más rápida de obtener un dispositivo realista, y significa que los nombres de métricas contra los que construyes paneles son los que enviará el sensor real.
> **Un preajuste reemplaza lo que ya está allí.** Seleccionar uno sobrescribe las métricas que escribiste a mano y restablece el intervalo al propio del preajuste. Elige primero el preajuste y luego ajusta.
**Los preajustes de dispositivo no son** [**plantillas de perfil de dispositivo**](/kilo-docs-es/kilo-iot-server/devices/registering-devices.md#for-lorawan-devices-lns-connector)**.** Una plantilla de perfil de dispositivo LoRaWAN configura cómo un dispositivo físico se comunica con la red — clase, banda, códec. Un preajuste de dispositivo describe qué un dispositivo emulado *mide*, y existe solo en el Emulador.
## Definición manual de métricas
Sin un preajuste — o junto a uno — usa **Añadir clave de datos del dispositivo** para definir cada medición:
* **Clave de datos del dispositivo** — el nombre de la métrica, como `temperature`. Esto es lo que usan los paneles, las reglas y los mapeos.
* **Tipo de dato** — `Float` para cualquier cosa con decimales, `Integer` para números enteros, y los otros tipos admitidos para booleanos y texto. Ver [Métricas](/kilo-docs-es/kilo-iot-server/devices/metric-templates.md) para ver cómo se normalizan los tipos en toda una implementación.
Elige el tipo de datos con intención. Una **Integer** métrica trunca los decimales: envía `1.5` y el dispositivo informa `1`. **Float**.
## Envío de valores
Una vez guardado el dispositivo, su **Emulador** pestaña enumera cada métrica con dos controles:
* **Guardar** fija un valor. El dispositivo sigue informando de ese valor en su intervalo, lo cual sirve para mantener un tanque al 8 % o un congelador a −18 °C mientras ves cómo reacciona una regla.
* **Enviar una vez** transmite una única lectura de inmediato, sin cambiar lo que el dispositivo informa después. Esta es la opción que debes usar cuando quieras disparar un umbral bajo demanda.
Enviar un valor es una **acción de escritura** — alimenta el historial, las reglas y las alarmas exactamente igual que la telemetría real. Un usuario con acceso de solo lectura puede ver un dispositivo emulado pero no puede inyectarle lecturas. Ver [Usuarios y permisos](/kilo-docs-es/kilo-iot-server/account/users-and-permissions.md).
## Ejecutar comandos contra un dispositivo emulado
Con **Comandos de soporte** activado, el dispositivo obtiene una **Comandos y estados** pestaña y se comporta como hardware controlable. Esto es lo que te permite construir y ensayar un circuito cerrado antes de que exista el equipo: una regla detecta una condición, envía un comando y la alarma registra que ocurrió — sin riesgo de accionar nada real.
Definir y ejecutar comandos funciona igual que en un dispositivo físico. Ver [Creación de comandos](/kilo-docs-es/kilo-iot-server/devices/commands/creating-commands.md) y [Ejecución de comandos](/kilo-docs-es/kilo-iot-server/devices/commands/executing-commands.md).
## Pasar a producción: cambiar a un dispositivo real
Este es el paso alrededor del cual se construye el Emulador. Cuando llegue el hardware, abre la **Conexión** pestaña del dispositivo y cambia el conector de **Emulador** al real — LoRaWAN, por ejemplo — y luego proporciona los identificadores que necesita el dispositivo físico.
Todo lo demás del dispositivo se mantiene: su nombre, su lugar en tus paneles, las reglas vinculadas a él, sus definiciones de alarmas y cadenas de escalado. Estás reemplazando la fuente de los datos, no reconstruyendo la implementación.
El cambio está deliberadamente restringido a pares que involucran al Emulador — de emulador a real, o de real de vuelta a emulador. No se ofrece el cambio directo entre dos tipos de conector físico, porque los identificadores del dispositivo y los mapeos de carga útil difieren lo suficiente como para que el mapeo tenga que reconstruirse de todos modos.
> Ir en la otra dirección es igual de útil: mueve un dispositivo real al Emulador para reproducir un problema, y luego muévelo de vuelta.
## Copiar un dispositivo emulado
Copiar un dispositivo te da una ventaja inicial sobre el registro del dispositivo, pero **no traslada la configuración del emulador**. El nuevo dispositivo se rellena previamente con el nombre original, las filas de plantilla de métricas, la selección de conexión y la configuración, e imágenes. Todo lo que lo hace *emular* hay que configurarlo de nuevo:
* **Las definiciones de señal del emulador** — las métricas que genera y sus tipos de datos.
* **El intervalo de informes**, que vuelve a su valor predeterminado en lugar del original.
* **Comandos de soporte**, que vuelve a desactivado.
* **Comandos derivados del preajuste.** Seleccionar de nuevo el preajuste original es la forma más rápida de volver.
Hasta que hagas eso, la copia no informa de nada en absoluto — es un dispositivo vinculado al Emulador con una especificación vacía. **Tampoco se trasladan los mapeos de sensores**, así que recréelos en la copia después de guardar.
Consulta [Gestión de dispositivos](/kilo-docs-es/kilo-iot-server/devices/device-management.md#copying-a-device).
## Pídele al asistente que lo haga
Todo el flujo de trabajo anterior está disponible en lenguaje natural a través del [Asistente de IA para IoT](/kilo-docs-es/kilo-iot-server/ai-assistant.md). Puede listar los preajustes de dispositivo disponibles, aprovisionar un dispositivo emulado, leer y actualizar su configuración y su intervalo, enviar una lectura puntual y poner el dispositivo en vivo sobre una conexión real **LoRaWAN** cuando llegue tu hardware. También puede mover cualquier dispositivo real al Emulador. Cambiar un dispositivo emulado a un conector Mioty, Tracker o MQTT es un paso manual en la pestaña Conexión — el asistente no lo ofrece.
## Qué sigue
* **Construye automatizaciones con datos emulados** para que estén probadas antes de la puesta en marcha. Ver [Motor de reglas](/kilo-docs-es/kilo-iot-server/rules-engine.md).
* **Ensayar una cadena de escalado** de principio a fin sin esperar a un fallo real. Ver [Alarmas](/kilo-docs-es/kilo-iot-server/alarm.md).
* **Complete el flujo de registro compartido** — información del dispositivo, Metrics, Logs. Véase [Registro de dispositivos](/kilo-docs-es/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-es/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.
