El verdadero reto de apagar las luces con temporizador en Home Assistant: ¿por qué la ejecución pendiente tras un reinicio puede ocurrir dos veces?
Un experimento reproducible con SQLite y una lámpara simulada analiza recuperación, acciones duplicadas, observaciones recientes y confirmaciones antiguas.
Actualizado
En el artículo anterior vimos que reiniciar Home Assistant interrumpe tanto los períodos definidos con for como las esperas que están en curso. La solución más natural parece ser guardar la hora límite y comprobar, al iniciar, qué tareas han vencido.
Pero la hora límite solo resuelve «cuándo hay que actuar». Hay una pregunta más difícil: si la acción se completó, pero el sistema no alcanzó a registrar que había terminado, ¿qué debe hacer al reiniciarse?
Si vuelve a intentarlo, puede ejecutar la acción dos veces. Si no lo hace, puede omitir una tarea que en realidad nunca se ejecutó. Guardar la hora en una entidad auxiliar no elimina por sí solo este dilema.
En este artículo usamos SQLite y una lámpara simulada para hacer un experimento de inyección de fallos y examinar las opciones en un caso de iluminación doméstica corriente. El script se ejecutó, pero no es una prueba de integración con Home Assistant ni controló dispositivos de tu casa. La máquina de estados que se presenta es una referencia de diseño, no un archivo YAML completo que se pueda pegar directamente.
Primero, distingamos dos reglas que parecen iguales
«Apagar la luz después de diez minutos» puede expresar dos requisitos distintos:
| Regla | Hecho que importa | Información que puede perderse durante la parada |
|---|---|---|
| Apagar la luz cuando la habitación lleve diez minutos seguidos desocupada | Que no haya habido nadie durante todo ese período | El sistema puede no saber si alguien entró mientras estuvo detenido |
| El usuario inicia una cuenta atrás de diez minutos; al vencer, se intenta apagar la luz | La hora límite y las condiciones en el momento de ejecutar | Puede pasarse la hora límite o quedar sin registrar el resultado de la ejecución |
Estas reglas no son intercambiables.
En la primera, recuperar una marca de tiempo anterior no demuestra que la habitación haya permanecido desocupada mientras el sistema estuvo detenido. Si no existe un historial independiente y fiable del sensor, la opción prudente es volver a observar durante un tiempo.
El experimento de este artículo trata la segunda regla: el usuario crea expresamente una tarea programada para apagar la luz y, una vez vencido el plazo, solo se intenta apagar una lámpara de prueba corriente si se obtiene una observación suficientemente reciente de que no hay nadie. No se afirma haber reconstruido la ocupación continua durante la parada.
Por qué no basta con una sola entidad auxiliar de tiempo
El input_datetime de Home Assistant permite guardar una fecha y una hora. Según la documentación oficial, si se configura un valor initial válido, comienza con ese valor; de lo contrario, recupera el estado anterior a la parada.[1]
Sirve para registrar una hora límite, pero «la hora límite era ayer a las diez de la noche» no indica si la tarea sigue vigente. Puede que ya se haya completado, que el usuario la haya cancelado o que pertenezca a una cuenta atrás anterior.
Por eso hay que representar, como mínimo, tres cosas: la identidad de la tarea, su hora límite y su estado. Por ejemplo:
id=42
due=una hora límite definida con precisión
state=pending
id distingue las tareas nuevas de las antiguas; due permite determinar cuándo se puede intentar la ejecución; state distingue entre pendiente, completada y cancelada.
En Home Assistant se puede representar información similar mediante varias entidades auxiliares, pero no se puede dar por hecho que sus actualizaciones formen una única transacción de base de datos. Si es imprescindible que «o se actualice todo o no se actualice nada», se necesita un componente con las capacidades correspondientes de persistencia y transacciones, y hay que verificar su comportamiento al recuperarse. Aquí usamos SQLite para estudiar el problema por separado de la configuración de la interfaz, no para recomendar modificar directamente la base de datos de Home Assistant.
Una ventana de interrupción imposible de ignorar
Supongamos que la hora límite ya pasó y el flujo de ejecución es este:
Leer la tarea pending
Comprobar las condiciones actuales
Enviar la orden de apagar la luz
Registrar la tarea como done
Si el programa se interrumpe después del tercer paso y antes del cuarto, puede que la luz ya esté apagada, pero la tarea siga figurando como pending en el disco. Tras reiniciar, el registro puede ser exactamente igual al de un caso en que la interrupción ocurrió antes de enviar la orden.
Invertir el orden tampoco resuelve el problema: si primero se registra done y luego se apaga la luz, una interrupción entre ambos pasos deja la tarea marcada como completada mientras la luz sigue encendida.
| Orden de registro | Ventana de interrupción | Riesgo al recuperarse |
|---|---|---|
| Marcar como completada y luego ejecutar | Después de guardar el registro de finalización y antes de la acción | Omitir la ejecución |
| Ejecutar y luego marcar como completada | Después de la acción y antes de guardar el registro de finalización | Repetir la ejecución |
Una transacción local de SQLite solo protege los registros locales: no puede incluir en la misma transacción la acción física de una lámpara remota. Para obtener garantías más fuertes, el extremo que ejecuta la acción debe admitir mecanismos como la deduplicación de solicitudes o la consulta del resultado de una operación, y el protocolo entre ambos extremos debe aprovecharlos. Un indicador dentro de la automatización no basta.
Experimento: el mismo reintento, off y toggle, produce resultados opuestos
Preparamos una lámpara simulada que empieza encendida y creamos una tarea con hora límite 600. Intentamos ejecutarla en el instante simulado 700.
El fallo se introduce después de que la lámpara recibe la acción y antes de marcar la tarea como completada. En ese punto, el script cierra la conexión a la base de datos y vuelve a abrirla para simular el estado persistente que vería el programa en su siguiente ejecución. Los tiempos son enteros introducidos para el experimento, no segundos medidos; tampoco se cortó realmente la alimentación del sistema operativo.
Al recuperarse, la tarea sigue pendiente, así que se intenta otra vez.
Resultado de esta ejecución:
crash_after_action_off calls=2 lamp_on=false
crash_after_action_toggle calls=2 lamp_on=true
Si la orden de apagar se ejecuta dos veces seguidas, la lámpara simulada termina apagada. Si la orden de alternar el estado se ejecuta dos veces, termina encendida de nuevo.
Por tanto, las tareas que admiten reintentos tras una recuperación deberían usar preferentemente operaciones que indiquen un estado final concreto, como «apagar», en lugar de «invertir el estado actual». Ese es el valor práctico de la idempotencia en este caso.
Sin embargo, esto no autoriza los reintentos ilimitados. Si el usuario enciende manualmente la luz entre dos órdenes off, la segunda puede contradecir su intención. Un dispositivo real también puede generar acciones o eventos adicionales ante órdenes repetidas. Solo verificamos la idempotencia del valor booleano de la lámpara simulada; no verificamos el comportamiento eléctrico de ningún dispositivo ni todos los efectos secundarios de las automatizaciones.
Por qué «no hay nadie» después de recuperarse puede ser un valor antiguo
Si al iniciar se lee que el sensor está en off, todavía hay que preguntarse: ¿es una observación nueva recibida después del arranque o un estado antiguo recuperado?
El experimento exige que la observación cumpla tres condiciones:
Indica expresamente que no hay nadie
La hora de recepción no es anterior a este arranque
Su antigüedad al evaluarla no supera el intervalo de vigencia definido en el modelo
El script usa 30 unidades de tiempo simulado como intervalo de vigencia solo para probar el límite; no recomienda usar 30 segundos para todos los dispositivos reales. El umbral real debe decidirse según la frecuencia con que informa el dispositivo y las consecuencias de la acción.
En el experimento se introdujeron por separado un off antiguo anterior al arranque, unknown, on y un off fuera del intervalo de vigencia. Ninguno provocó una orden de apagado. Solo se permitió la acción con un off recién recibido y aún vigente.
Esto también deja al descubierto una dificultad de la integración: algunos dispositivos solo informan cuando cambia el estado; algunas integraciones recuperan valores de una caché; y una lectura no siempre consulta directamente el dispositivo. Por tanto, no hay que suponer que un campo de tiempo cualquiera de una entidad demuestra que «el hardware acaba de confirmar de nuevo que no hay nadie». Al integrar un dispositivo concreto, hay que comprobar de dónde proceden sus datos. Si no se puede obtener una observación nueva y fiable, corresponde seguir esperando o recurrir a una intervención manual.
Ni unknown ni unavailable se convierten en «no hay nadie» por el mero hecho de «no ser on».
La confirmación de una tarea antigua no debe borrar una tarea nueva
El usuario puede fijar una hora de apagado posterior antes de que termine la primera cuenta atrás. Si entonces una devolución de llamada antigua ejecuta «poner el indicador global pending en false», puede borrar también la tarea nueva.
El experimento asigna distintos ID a las tareas y usa una actualización condicional:
UPDATE job
SET state = 'done'
WHERE id = ? AND state = 'pending';
Al crear una tarea nueva, primero se cancela la tarea pendiente anterior y luego se inserta la nueva; ambos pasos se realizan dentro de una misma transacción de SQLite. La notificación de finalización de la tarea antigua solo lleva su ID anterior, por lo que no puede marcar la tarea nueva como completada.
En el experimento, la tarea antigua tiene ID 1 y hora límite 600; la nueva tiene ID 2 y hora límite 900. Tras llegar la devolución de llamada de finalización de la tarea antigua, no hay ninguna tarea ejecutable en el instante 700, mientras que en el instante 901 todavía se puede recuperar la tarea 2.
Pero el ID solo protege el registro. No puede retirar una orden antigua que ya se envió al dispositivo. Si la solicitud antigua sigue en la red cuando se crea la tarea nueva y el dispositivo la ejecuta después, aún puede contradecir la nueva intención. Un sistema real requiere estudiar también la ejecución en serie, las reglas de cancelación y la comprobación de versiones en el extremo ejecutor. El modelo de un solo ejecutor de este artículo no resuelve los comandos concurrentes que están en tránsito por la red.
Qué puntos de comprobación hacen falta al integrarlo con Home Assistant
Además de la activación normal por tiempo, hay que prever, como mínimo, comprobaciones tras el arranque y tras la recuperación de las entidades importantes. También se puede programar una comprobación de respaldo poco frecuente para cubrir activaciones perdidas. Cada comprobación debe leer el estado de la tarea: «se activó» no equivale directamente a «debe ejecutarse».
La documentación oficial de Timer indica expresamente que activar restore permite recuperar temporizadores activos o en pausa, pero que los temporizadores vencidos durante la parada no generan un evento timer.finished al arrancar.[2] La documentación de los disparadores por estado también indica que for se reinicia cuando Home Assistant se reinicia o cuando se recargan las automatizaciones.[3]
Estos hechos justifican una comprobación al recuperarse, pero no hacen que la siguiente regla sea segura por sí sola:
La hora actual supera la antigua hora límite → apagar la luz incondicionalmente
La decisión tras recuperarse debería comprobar a la vez que la tarea sigue vigente, que el dispositivo de destino existe, que las condiciones actuales permiten la acción, que la evidencia del estado es suficientemente reciente y que no hay una intervención manual explícita que deba prevalecer.
También hay que definir cuándo dejar de intentarlo automáticamente si el reloj no es fiable, el dispositivo permanece indisponible o se acumulan fallos. Este modelo no implementa un número máximo de reintentos, esperas progresivas ni alertas. Antes de integrarlo de verdad, es imprescindible añadirlos; no se deben enviar órdenes indefinidamente.
Qué conclusiones puedes reproducir
Archivo adjunto: deadline_lab.py. Usa la biblioteca estándar de Python 3. La base de datos SQLite temporal se elimina al terminar; no necesita un token de Home Assistant ni accede a dispositivos reales.
python deadline_lab.py
En esta ejecución pasaron las aserciones de cuatro grupos de escenarios y los resultados se guardaron en deadline_results.json:
| Escenario | Hecho verificado |
|---|---|
| Cerrar y volver a abrir la base de datos, y después comprobar las condiciones | La tarea pendiente se conserva; se bloquean las observaciones antiguas, desconocidas, de presencia y caducadas; una observación nueva y válida provoca una acción |
Interrumpir después de la acción y antes de registrar la finalización; reintentar off |
Se hacen dos llamadas y la lámpara simulada termina apagada |
Interrumpir en el mismo punto; reintentar toggle |
Se hacen dos llamadas y la lámpara simulada termina encendida |
| Una tarea nueva sustituye a la antigua y después llega la confirmación de la antigua | La confirmación antigua no marca como completada la tarea nueva |
Estos cuatro resultados no demuestran persistencia ante un corte de alimentación, ni que las entidades auxiliares de Home Assistant tengan la semántica transaccional de SQLite, ni que el modelo sea correcto con varios ejecutores concurrentes. De hecho, el experimento conserva deliberadamente el intervalo en que «la acción se ejecutó, pero el estado no quedó confirmado» para mostrar por qué un registro local, por sí solo, no puede prometer una ejecución exactamente una vez.
Para una luz corriente de casa, a menudo es aceptable comprobar primero las condiciones actuales tras recuperarse, enviar de nuevo una orden explícita de apagado cuando haga falta y ofrecer una forma de cancelar la tarea. Para acciones que no se pueden repetir sin más, como cobrar dinero, abrir una cerradura o dispensar una dosis única, esa misma decisión puede ser totalmente inaceptable.
Al diseñar una tarea programada, lo que realmente hay que aclarar es esto: en el momento en que el sistema ha olvidado el resultado de la acción, ¿qué es menos aceptable para ti: omitirla o repetirla? Solo cuando eso queda definido puede tener la lógica de recuperación un objetivo verificable.
Referencias
Fecha de consulta: 2026-11-14. La página oficial mostraba Home Assistant 2026.11.1; el experimento no instaló esa versión.
- Input Datetime: recuperación del estado.
- Timer: recuperación y límites de los vencimientos durante una parada.
- State changed: comportamiento de
foral reiniciar. - Script del experimento y resultados originales: modelo de software ejecutado en este experimento y su salida.
Este artículo se investigó, redactó y verificó con ayuda de IA. El tiempo simulado, la lámpara simulada y la interrupción introducida no equivalen a una prueba en un hogar real.
Descargar el paquete completo del experimento (script, resultados y registro de ejecución)
Ilustración conceptual generada con IA, no una captura ni una fotografía del experimento.
Discussion
Share a question or your experience. Comments appear after moderation. Your email is never displayed publicly. Comment privacy
Loading comments…