Saltar al contenido

Cómo integrar un SAI Salicru en Home Assistant con Modbus TCP

22/11/2026
Miniatura de un SAI Salicru conectado a Home Assistant mediante Modbus TCP con el texto ¡FUNCIONA!

Un SAI o UPS mantiene alimentados los equipos durante una interrupción del suministro y, según su tecnología, acondiciona la energía que reciben. Si protege un NAS, el ordenador o la red de casa, interesa saber algo más que si su pantalla está encendida: qué carga soporta, cuánta batería indica, si hay alimentación externa y si comunica una avería.

En esta guía vamos a integrar un SAI Salicru en Home Assistant mediante Modbus TCP, utilizando la red local y la integración que ya incluye Home Assistant. No necesitamos HACS ni una integración personalizada para el ejemplo. Nimbus nos ha servido para contrastar mediciones, pero Home Assistant consulta directamente el SAI.

Lo hemos instalado y probado con un Salicru SLC-1000-TWIN RT3, firmware principal 00.01.15485, firmware IoT 02.02.000 y Home Assistant Core 2026.10.1. El resultado actual son 18 entidades útiles: ocho magnitudes numéricas, el modo de funcionamiento, tres señales de presencia y seis alarmas. Hay además tres sensores auxiliares para interpretar el modo y los bits. Este resultado no confirma la compatibilidad de todos los SAI Salicru.

El camino tiene dos comprobaciones separadas: conseguir que el servidor Modbus responda y confirmar que cada dato significa lo que creemos. En nuestro equipo el ajuste estaba habilitado, pero el puerto TCP seguía rechazando conexiones. Explicaremos cómo lo resolvimos y qué límites mantiene el tutorial.

Paso 0. Reinicia el IoT interno desde el SAI

Si sigues esta guía con un Salicru SLC-1000-TWIN RT3, empieza por reiniciar el módulo de comunicaciones. En la pantalla LCD del SAI, entra en Control → Reinicio IoT interno y confirma. Cuando aparezca «Hecho», espera a que el módulo vuelva a estar disponible en la red. Después, comprueba el modelo, localiza la IP y activa Modbus TCP siguiendo los pasos de la guía.

Durante el reinicio se interrumpe temporalmente la comunicación con el módulo. Si tienes otra variante del SAI, comprueba que su panel ofrece esa función y qué efecto tiene en tu equipo.

En nuestra unidad, este reinicio nos permitió avanzar en dos ocasiones distintas. El portal HTTPS volvió a abrir después de un error de conexión y Modbus respondió en el puerto 502 tras el reinicio descrito en el paso 4.

Qué necesitas antes de empezar

  • Un SAI con Modbus TCP disponible, integrado o mediante un accesorio compatible, y el mapa adecuado a ese hardware.
  • El SAI y Home Assistant accesibles por la red local. Ethernet es la conexión utilizada en este caso.
  • Acceso legítimo a los ajustes del SAI y permisos para editar la configuración de Home Assistant.
  • Una copia de seguridad y un editor de archivos, como File editor o tu acceso habitual a configuration.yaml.
  • Conocimientos básicos de YAML: sangría con espacios, listas y claves. No uses tabuladores.
  • Tiempo para comprobar las medidas antes de añadir automatizaciones que protejan equipos reales.

No hay que conectar USB, instalar NUT ni contratar Nimbus para que el cliente Modbus de este ejemplo consulte el SAI. La red, el SAI y Home Assistant sí deben estar operativos. Si quieres recibir avisos durante un corte, también debes comprobar qué equipos de red siguen alimentados; obtener sensores no demuestra que un aviso remoto pueda salir de casa en ese momento.

Si necesitas preparar el editor, tienes nuestra guía para editar Home Assistant con Visual Studio Code y Samba. Para entender la diferencia entre valores, atributos y acciones, consulta cómo interpreta Home Assistant las entidades y sus estados.

Paso 1. Comprueba el modelo y la compatibilidad Modbus

Lee la etiqueta y el menú de identificación de tu SAI. Anota el modelo exacto, la potencia, las versiones de firmware y qué interfaz de comunicaciones utiliza. Que tenga un conector Ethernet no demuestra por sí solo que ofrezca Modbus, SNMP o una API de monitorización.

SituaciónQué sabemosQué debes verificar
SLC-1000-TWIN RT3 de nuestras pruebasModbus TCP integrado ha respondido y las entidades descritas funcionan en nuestra unidad.Que tu unidad y firmware ofrezcan el mismo servicio y datos.
Familia RT3 y mapa IQ14700El anexo contiene una columna para SAI de 1–3 kVA, aunque la portada anuncia 4–10 kVA.Coincidencia del mapa con el modelo y el transporte que realmente tienes.
SAI con tarjeta adicionalLas prestaciones pertenecen también a la tarjeta y a su firmware.Modelo de tarjeta, puerto, Unit ID y mapa específico.
Otro Salicru o conexión USBPuede necesitar otro protocolo o un servidor NUT.Compatibilidad del controlador y variables de esa unidad; este YAML no es universal.

Las referencias principales son el manual RT3 EL22650, el manual de conectividad EL28450 y el mapa Modbus IQ14700. Consulta las tablas y su columna de aplicación; no te limites al título de un PDF ni copies registros de otra familia.

NUT por USB es una alternativa distinta. Su lista de compatibilidad incluye la familia RT3 con soporte experimental de usbhid-ups, pero no hemos probado el USB de esta unidad. La integración NUT de Home Assistant necesita un servidor NUT que publique datos: no transforma directamente el USB en una conexión Modbus.

Paso 2. Localiza la IP y mantén una dirección estable

Busca el SAI en la lista de clientes del router o consulta la dirección Ethernet en su pantalla o portal. Para los ejemplos utilizaremos 192.168.1.50, una IP ficticia. Sustitúyela por la de tu instalación; ninguna dirección de esta guía corresponde a la red doméstica de las pruebas.

Si el dispositivo obtiene su dirección por DHCP, una reserva en el router permite que conserve la misma IP. No confundas una reserva DHCP con asignar manualmente una IP fija dentro del SAI: son métodos diferentes. En nuestra instalación vimos DHCP en el portal; la lectura funcionó sin cambiar ese ajuste. La reserva es una recomendación para reproducibilidad, no un cambio que hayamos efectuado como parte de la prueba.

Comprueba que Home Assistant puede alcanzar esa red. Si utiliza otra VLAN, revisa el encaminamiento y las reglas para el destino y puerto concretos. No abras todos los puertos ni desactives globalmente el cortafuegos para diagnosticarlo.

Si la IP es correcta, pero el portal no abre

Abre https://IP_DEL_SAI/if/login usando la dirección confirmada en el router. Si aparece ERR_CONNECTION_RESET, comprueba que el módulo haya vuelto a la red tras el reinicio del paso 0. Si aparece un aviso de certificado, consulta el paso 3.

Paso 3. Habilita Modbus TCP y verifica que el ajuste se guarda

En nuestro IoT setting portal, entrando a https://IP_DEL_SAI con las credenciales propias, encontramos Settings → Network → Access Control → Modbus TCP. Cambiamos ese parámetro de Disable a Enable, guardamos y recargamos para comprobar que persistía. No cambiamos el timeout, la whitelist, CORS, HTTP ni la depuración remota para hacer funcionar la lectura.

El manual RT3 incluye también Modbus TCP en los ajustes del LCD y lo documenta como deshabilitado de origen. Comprobamos el estado habilitado en el panel físico. Los nombres y menús pueden variar; sigue el manual de tu variante y no pruebes PIN o contraseñas de fábrica que no correspondan a tu acceso legítimo.

El registro de eventos recogió Modbus TCP enabled. Es una confirmación adicional del cambio, pero la palabra Operational en el evento no demuestra que el servidor esté escuchando en un puerto. Ajuste habilitado y servicio accesible son comprobaciones diferentes.

Si el navegador bloquea el portal

En nuestras pruebas el certificado declaraba un nombre distinto del usado para acceder y su emisor no era reconocido. Hubo avisos del navegador y un bloqueo explícito de Kaspersky. Una excepción limitada al equipo, correctamente guardada, eliminó el bloqueo del antivirus; después quedaba el aviso independiente del navegador. Esto no reparó el certificado.

Verifica primero que estás accediendo a tu equipo. No importes autoridades desconocidas, no desactives la protección de toda la red y no interpretes una página en blanco como una contraseña incorrecta. Nosotros comprobamos que faltaba cargar JavaScript esencial: recibir el HTML con HTTP 200 no significaba tener el portal funcionando. Tampoco demostramos que todos los errores de conexión anteriores provinieran del antivirus.

Paso 4. Modbus habilitado, pero el puerto 502 rechaza conexiones

Este fue el bloqueo principal. El cambio a Enable persistía, el LCD indicaba Modbus activo y el evento confirmaba la habilitación. Sin embargo, el intento de abrir TCP al puerto 502 devolvía conexión rechazada. También lo comprobamos desde otro equipo de la misma LAN; por tanto, no era suficiente culpar al navegador del primer ordenador.

La conexión fallaba antes de enviar una petición Modbus. El Unit ID y el registro no podían explicar ese rechazo de transporte. No probamos unidades o direcciones al azar para arreglarlo, ni actualizamos firmware, ni cambiamos los filtros por intuición.

Lo que funcionó en nuestra unidad: reinicio del IoT desde el LCD

Apagamos ordenadamente el PC y el NAS antes de intervenir. Después utilizamos el panel LCD físico del SAI: Control → Reinicio IoT interno. La pantalla confirmó «Hecho». Volvimos a comprobar que Modbus seguía habilitado y repetimos la misma lectura mínima. Esta vez respondió.

Importante: no lo hicimos desde el navegador. Reiniciar el módulo IoT no es equivalente a reiniciar o apagar el SAI completo, ni a restaurar valores de fábrica. Observamos que esa operación no cortó la alimentación de las salidas en nuestra unidad, pero eso no garantiza el mismo comportamiento en todos los modelos, hardware o firmware.

No conviertas este reinicio en un paso obligatorio. Antes de accionar un menú de control, identifica exactamente la función en la documentación de tu equipo y prepara los dispositivos protegidos para una posible interrupción. Si el menú no coincide o sus efectos no están claros, detente. Nuestro resultado demuestra una secuencia antes/después, no la causa interna del bloqueo ni una solución universal.

Paso 5. Haz una primera lectura de solo lectura

Puedes comprobar conectividad TCP desde Windows con este ejemplo, cambiando la IP:

Test-NetConnection -ComputerName 192.168.1.50 -Port 502

TcpTestSucceeded: True indica que la conexión TCP se puede establecer desde ese ordenador. No valida todavía el protocolo, el Unit ID, la dirección ni las unidades del dato. Una prueba desde el PC tampoco demuestra que la Raspberry o el servidor de Home Assistant tenga la misma ruta de red.

En nuestra primera lectura válida usamos Unit ID 1, FC03, dirección PDU 43 y una palabra de 16 bits. El dato fue 500; el mapa lo expresa en décimas de hercio, por lo que 500 × 0,1 = 50,0 Hz. Lo contrastamos con la frecuencia de salida mostrada en Nimbus.

El ejemplo del manual con ModScan muestra la dirección sumando uno. Eso es una convención de presentación, no una orden para sumar uno en todos los clientes: nosotros codificamos 43 en la PDU y 43 en Home Assistant. En otro manual comprueba si la numeración empieza en cero, en uno o incluye un prefijo como 40001.

Script opcional: una sola petición FC03, sin reintentos

Si tienes Python 3 instalado, guarda el siguiente código como lectura_salicru.py. Es una adaptación del script utilizado en las pruebas. Solo permite leer el registro 43 de este ejemplo por TCP 502; no contiene funciones de escritura ni comandos de control. El argumento --ejecutar es necesario para abrir la conexión.

"""Preparación y lectura única FC03 del registro RO 43. Sin dependencias externas."""

import argparse
import datetime
import json
import socket
import struct
import time

HOST = None
PORT = 502
ADDRESS = 43
TRANSACTION = 1
TIMEOUT = 3.0


def request_frame(unit):
    if not 1 <= unit <= 255:
        raise ValueError("Unidad fuera de rango; no se admite unidad 0.")
    # La única función y dirección posibles están fijadas aquí.
    pdu = struct.pack(">BHH", 3, ADDRESS, 1)
    return struct.pack(">HHHB", TRANSACTION, 0, len(pdu) + 1, unit) + pdu


def decode_frame(frame, unit):
    if len(frame) < 7:
        raise ValueError("Cabecera incompleta.")
    transaction, protocol, length, response_unit = struct.unpack(">HHHB", frame[:7])
    if (transaction, protocol, response_unit) != (TRANSACTION, 0, unit):
        raise ValueError("La cabecera no corresponde a esta petición.")
    if len(frame) != length + 6:
        raise ValueError("Longitud de respuesta incoherente.")
    pdu = frame[7:]
    if len(pdu) == 2 and pdu[0] == 0x83:
        return {"resultado": "excepcion_modbus", "codigo": pdu[1]}
    if len(pdu) != 4 or pdu[:2] != b"\x03\x02":
        raise ValueError("No es una respuesta FC03 de un registro.")
    raw = struct.unpack(">H", pdu[2:])[0]
    return {
        "resultado": "respuesta_fc03",
        "bytes_dato_hex": pdu[2:].hex(" "),
        "valor_uint16": raw,
        "frecuencia_hz_segun_mapa_pendiente_de_contraste": raw / 10,
    }


def recv_exact(connection, count, deadline):
    data = bytearray()
    while len(data) < count:
        remaining = deadline - time.monotonic()
        if remaining <= 0:
            raise TimeoutError("Se agotó el plazo total de recepción.")
        connection.settimeout(remaining)
        part = connection.recv(count - len(data))
        if not part:
            raise ConnectionError("El servidor cerró la conexión antes de completar la respuesta.")
        data.extend(part)
    return bytes(data)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--host", required=True, help="IP local de tu SAI")
    parser.add_argument("--unit-id", type=int, choices=range(1, 256), metavar="1..255")
    parser.add_argument("--ejecutar", action="store_true", help="Abre la conexión y envía una sola petición; requiere autorización previa.")
    args = parser.parse_args()
    global HOST
    HOST = args.host
    if args.ejecutar and args.unit_id is None:
        parser.error("La ejecución requiere --unit-id; no se elige ni se busca automáticamente.")
    result = {
        "fecha_utc": datetime.datetime.now(datetime.timezone.utc).isoformat(),
        "destino": HOST,
        "puerto_candidato": PORT,
        "unit_id": args.unit_id,
        "funcion": 3,
        "direccion_pdu_decimal": ADDRESS,
        "cantidad_registros": 1,
        "modo": "ejecucion_autorizada" if args.ejecutar else "preparacion_sin_red",
    }
    request = request_frame(args.unit_id) if args.unit_id is not None else None
    if request is not None:
        result["peticion_hex"] = request.hex(" ")
    if not args.ejecutar:
        result["nota"] = "No se ha abierto ninguna conexión. El Unit ID nativo sigue pendiente de validación."
        print(json.dumps(result, ensure_ascii=False, indent=2))
        return 0
    try:
        # Una conexión, una petición, sin reintentos ni sondeo periódico.
        with socket.create_connection((HOST, PORT), timeout=TIMEOUT) as connection:
            connection.settimeout(TIMEOUT)
            connection.sendall(request)
            deadline = time.monotonic() + TIMEOUT
            header = recv_exact(connection, 7, deadline)
            transaction, protocol, length, response_unit = struct.unpack(">HHHB", header)
            if (transaction, protocol, response_unit) != (TRANSACTION, 0, args.unit_id):
                raise ValueError("Cabecera no correspondiente; se cierra la conexión.")
            if length not in (3, 5):
                raise ValueError("Longitud inesperada; se cierra la conexión sin nuevas peticiones.")
            frame = header + recv_exact(connection, length - 1, deadline)
            result["respuesta_hex"] = frame.hex(" ")
            result.update(decode_frame(frame, args.unit_id))
    except (OSError, ValueError) as error:
        result.update(resultado="lectura_no_validada", detalle=str(error))
        print(json.dumps(result, ensure_ascii=False, indent=2))
        return 1
    print(json.dumps(result, ensure_ascii=False, indent=2))
    return 0 if result["resultado"] == "respuesta_fc03" else 1


if __name__ == "__main__":
    raise SystemExit(main())
python lectura_salicru.py --host 192.168.1.50 --unit-id 1
python lectura_salicru.py --host 192.168.1.50 --unit-id 1 --ejecutar

La primera orden presenta la preparación sin abrir una conexión. La segunda envía una petición. El script conserva el dato bruto y la conversión propuesta; respuesta_fc03 es respuesta de protocolo, no garantía de compatibilidad de todos los registros. Ante una excepción, timeout o dato incoherente, interpreta el resultado antes de continuar. No lo ejecutes contra otro modelo cuyo mapa no respalde esa lectura.

Paso 6. Configura el primer sensor en Home Assistant

La integración Modbus ya forma parte de Home Assistant. Para este dispositivo configuramos el mapa en YAML. Vamos a utilizar un paquete que reúna la conexión y las plantillas en un archivo separado, igual que en la instalación probada. No hace falta sustituir el resto de tu configuración.

6.1. Habilita la carpeta packages

Si todavía no utilizas packages o quieres entender mejor cómo agrupar la configuración de un dispositivo en un solo archivo, consulta nuestra guía para organizar Home Assistant con packages. Te servirá de contexto para mantener juntos los sensores y las plantillas del Salicru antes de continuar con este ejemplo.

En configuration.yaml añade esta estructura si no existe:

homeassistant:
  packages: !include_dir_named packages

Si ya tienes una sección homeassistant:, añade packages dentro de ella conservando sus otras opciones. No crees una segunda clave homeassistant. Si ya incluyes packages mediante otro método, utiliza tu estructura actual y no combines dos mecanismos sin revisar cómo se cargan. En nuestra instalación !include_dir_named packages ya existía.

Crea la carpeta packages junto a configuration.yaml. Dentro, crea salicru_modbus.yaml. El archivo de paquete contiene las claves modbus: y, en el ejemplo completo, template:: no lleva una clave adicional con el nombre del paquete. Más información en la documentación de packages de Home Assistant.

6.2. Empieza únicamente con la frecuencia

modbus:
  - name: salicru_rt3
    type: tcp
    host: 192.168.1.50
    port: 502
    timeout: 3
    message_wait_milliseconds: 200
    sensors:
      - name: Salicru Frecuencia de salida
        unique_id: salicru_rt3_frequencia_sortida
        device_address: 1
        address: 43
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: Hz
        device_class: frequency
        state_class: measurement
        scan_interval: 60

Sustituye la IP, comprueba el puerto y el Unit ID de tu dispositivo y deja el resto solo si tu mapa coincide. type: tcp es Modbus TCP con cabecera MBAP; no lo sustituyas por RTU sobre TCP salvo que realmente utilices ese transporte. input_type: holding selecciona FC03. device_address es el Unit ID; configuraciones antiguas pueden utilizar slave.

El intervalo es de 60 segundos; no es tiempo real ni garantiza ver cualquier microcorte. La espera de 200 ms entre mensajes es la que estamos utilizando para espaciar solicitudes. No es una constante universal del fabricante. El mapa declara dos bytes para esta frecuencia, por eso utilizamos uint16; Home Assistant calcula una palabra de lectura y no necesita count para ese tipo.

6.3. Valida antes de reiniciar

Guarda una copia del archivo anterior. En Herramientas de desarrollador → YAML utiliza la comprobación de configuración disponible en tu versión. Si muestra un error de sangría, clave duplicada o tipo de dato, corrígelo antes de reiniciar. Después reinicia Home Assistant Core, no el SAI. La guía utiliza la sintaxis de Core 2026.10.1; revisa la documentación Modbus si trabajas con otra versión.

Cuando termine de arrancar, ve a Herramientas de desarrollador → Estados y busca salicru. Deberías ver sensor.salicru_frecuencia_de_salida con una lectura coherente. No uses «Establecer estado» para simular el resultado: no confirma una lectura real del SAI. Los identificadores pueden variar si ya existe una entidad con el mismo nombre o si la has renombrado.

Paso 7. Añade las medidas y el modo de funcionamiento

Una vez contrastado el primer sensor, sustituye el contenido del mismo paquete por el ejemplo completo de este apartado. No conserves a la vez el paquete mínimo y otro paquete con la conexión completa: duplicarías el hub o los sensores. Tampoco copies por separado un segundo modbus: en el archivo principal.

MagnitudPDUTipoEscala / unidadComprobación en esta unidad
Frecuencia de salida43uint16× 0,1 · HzCoincide con Nimbus: 50 Hz.
Tensión de salida59uint16× 0,1 · VLecturas próximas a Nimbus, con actualización no simultánea.
Carga63uint16*× 1 · %Lecturas coherentes; no prueba de calibración.
Batería64uint16*× 1 · %100 %, coincidente con Nimbus.
Tensión de batería68uint16× 0,1 · V39,4 V, coincidente con Nimbus.
Tensión de entrada33uint16× 0,1 · VResponde y se actualiza en HA; control de magnitud frente a Nimbus.
Frecuencia de entrada29uint16× 0,1 · Hz50 Hz, coherente con las capturas.
Corriente de salida41uint16× 0,1 · ALecturas de 0,4–0,7 A en HA; 0,6–0,7 A observados en Nimbus.
Modo62uint16*Código sin unidad3 = Línea, observado. Resto de códigos documentados, no provocados.

* Campos de un byte: el manual describe carga, batería y modo con longitud de un byte. En nuestras lecturas FC03 recibimos una palabra cuyo byte alto era cero y cuyo byte bajo contenía el valor. Este es el formato observado y utilizado, no una garantía sobre cualquier implementación o variante.

Qué significa cada código del modo

CódigoEtiqueta del mapa / ejemploObservación
0Encendido inicialDocumentado; no probado mediante transición.
1EsperaDocumentado; no provocado.
2BypassDocumentado; no provocado.
3En líneaObservado en esta unidad.
4BateríaDocumentado; no hemos cortado la red para validarlo.
5Test de bateríaDocumentado; no se ejecutó un test.
6ReservadoNo inventar un estado operativo.
7ConvertidorDocumentado; no provocado.
8ECODocumentado; no provocado.

Los nombres y los identificadores de entidad del ejemplo están en español. Las capturas son de nuestra instalación, donde algunos nombres están en catalán. Si tienes dos SAI, usa nombres de hub y de entidades y unique_id distintos para cada uno.

Paquete completo de 18 entidades útiles

Descargar el paquete completo en catalán (ZIP con el archivo YAML). Extrae salicru_modbus_ca.yaml del ZIP y guárdalo en packages. Sustituye la IP de ejemplo por la del SAI y valida la configuración antes de reiniciar. Usa este archivo en lugar del paquete en español. Las tarjetas en español requieren los IDs de la versión en español.

Incluye las ocho medidas, un código auxiliar de modo, dos palabras auxiliares de estado, el modo en texto y los nueve sensores binarios del siguiente apartado. Las alarmas derivadas comparten sus palabras de origen: no se consulta el SAI nueve veces adicionales para leer nueve bits.

# Ejemplo Salicru SLC TWIN RT3; sustituye la IP por la de tu equipo.
# Monitorización local: solo lecturas FC03; autonomía pendiente de validar.
modbus:
  - name: salicru_rt3
    type: tcp
    host: 192.168.1.50
    port: 502
    timeout: 3
    message_wait_milliseconds: 200
    sensors:
      - name: Salicru Frecuencia de salida
        unique_id: salicru_rt3_frequencia_sortida
        device_address: 1
        address: 43
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: Hz
        device_class: frequency
        state_class: measurement
        scan_interval: 60
      - name: Salicru Tensión de salida
        unique_id: salicru_rt3_tensio_sortida
        device_address: 1
        address: 59
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: V
        device_class: voltage
        state_class: measurement
        scan_interval: 60
      - name: Salicru Carga del SAI
        unique_id: salicru_rt3_carrega
        device_address: 1
        address: 63
        input_type: holding
        data_type: uint16
        precision: 0
        unit_of_measurement: '%'
        state_class: measurement
        scan_interval: 60
      - name: Salicru Nivel de batería
        unique_id: salicru_rt3_bateria
        device_address: 1
        address: 64
        input_type: holding
        data_type: uint16
        precision: 0
        unit_of_measurement: '%'
        device_class: battery
        state_class: measurement
        scan_interval: 60
      - name: Salicru Tensión de batería
        unique_id: salicru_rt3_tensio_bateria
        device_address: 1
        address: 68
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: V
        device_class: voltage
        state_class: measurement
        scan_interval: 60
      - name: Salicru Código de modo
        unique_id: salicru_rt3_codi_mode
        device_address: 1
        address: 62
        input_type: holding
        data_type: uint16
        precision: 0
        scan_interval: 60


      - name: Salicru Tensión de entrada
        unique_id: salicru_rt3_tensio_entrada
        device_address: 1
        address: 33
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: V
        device_class: voltage
        state_class: measurement
        scan_interval: 60
      - name: Salicru Frecuencia de entrada
        unique_id: salicru_rt3_frequencia_entrada
        device_address: 1
        address: 29
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: Hz
        device_class: frequency
        state_class: measurement
        scan_interval: 60
      - name: Salicru Corriente de salida
        unique_id: salicru_rt3_corrent_sortida
        device_address: 1
        address: 41
        input_type: holding
        data_type: uint16
        scale: 0.1
        precision: 1
        unit_of_measurement: A
        device_class: current
        state_class: measurement
        scan_interval: 60
      - name: Salicru Registro de estado 1
        unique_id: salicru_rt3_registre_estat_1
        device_address: 1
        address: 1
        input_type: holding
        data_type: uint16
        precision: 0
        scan_interval: 60
      - name: Salicru Registro de estado 5
        unique_id: salicru_rt3_registre_estat_5
        device_address: 1
        address: 5
        input_type: holding
        data_type: uint16
        precision: 0
        scan_interval: 60


# unavailable en el origen no debe convertirse en alarma desactivada.
template:
  - sensor:
      - name: Salicru Modo del SAI
        default_entity_id: sensor.salicru_modo_del_sai
        unique_id: salicru_rt3_mode_sai
        icon: mdi:power-plug
        availability: "{{ is_number(states('sensor.salicru_codigo_de_modo')) }}"
        state: >-
          {% set modes = {0: 'Encendido inicial', 1: 'Espera', 2: 'Bypass',
                          3: 'En línea', 4: 'Batería', 5: 'Prueba de batería',
                          6: 'Reservado', 7: 'Convertidor', 8: 'ECO'} %}
          {% set code = states('sensor.salicru_codigo_de_modo') | int(-1) %}
          {{ modes.get(code, 'Código desconocido (' ~ code ~ ')') }}
  - binary_sensor:
      - name: Salicru Red eléctrica presente
        default_entity_id: binary_sensor.salicru_red_electrica_presente
        unique_id: salicru_rt3_xarxa_present
        device_class: power
        availability: "{{ is_number(states('sensor.salicru_registro_de_estado_5')) }}"
        state: "{{ (states('sensor.salicru_registro_de_estado_5') | int(0) | bitwise_and(16384)) != 0 }}"
      - name: Salicru Salida alimentada
        default_entity_id: binary_sensor.salicru_salida_alimentada
        unique_id: salicru_rt3_sortida_alimentada
        device_class: power
        availability: "{{ is_number(states('sensor.salicru_registro_de_estado_5')) }}"
        state: "{{ (states('sensor.salicru_registro_de_estado_5') | int(0) | bitwise_and(8)) != 0 }}"
      - name: Salicru Batería presente
        default_entity_id: binary_sensor.salicru_bateria_presente
        unique_id: salicru_rt3_bateria_present
        availability: "{{ is_number(states('sensor.salicru_registro_de_estado_1')) }}"
        state: "{{ (states('sensor.salicru_registro_de_estado_1') | int(0) | bitwise_and(1)) != 0 }}"
      - name: Salicru Batería baja
        default_entity_id: binary_sensor.salicru_bateria_baja
        unique_id: salicru_rt3_bateria_baixa
        device_class: battery
        availability: "{{ is_number(states('sensor.salicru_registro_de_estado_5')) }}"
        state: "{{ (states('sensor.salicru_registro_de_estado_5') | int(0) | bitwise_and(1)) != 0 }}"
      - name: Salicru Sobrecarga
        default_entity_id: binary_sensor.salicru_sobrecarga
        unique_id: salicru_rt3_sobrecarrega
        device_class: problem
        availability: "{{ is_number(states('sensor.salicru_registro_de_estado_5')) }}"
        state: "{{ (states('sensor.salicru_registro_de_estado_5') | int(0) | bitwise_and(32)) != 0 }}"
      - name: Salicru Temperatura elevada
        default_entity_id: binary_sensor.salicru_temperatura_elevada
        unique_id: salicru_rt3_temperatura_elevada
        device_class: problem
        availability: "{{ is_number(states('sensor.salicru_registro_de_estado_5')) }}"
        state: "{{ (states('sensor.salicru_registro_de_estado_5') | int(0) | bitwise_and(64)) != 0 }}"
      - name: Salicru Fallo interno
        default_entity_id: binary_sensor.salicru_fallo_interno
        unique_id: salicru_rt3_fallada_interna
        device_class: problem
        availability: "{{ is_number(states('sensor.salicru_registro_de_estado_5')) }}"
        state: "{{ (states('sensor.salicru_registro_de_estado_5') | int(0) | bitwise_and(16)) != 0 }}"
      - name: Salicru Sustitución de batería
        default_entity_id: binary_sensor.salicru_sustitucion_de_bateria
        unique_id: salicru_rt3_substitucio_bateria
        device_class: problem
        availability: "{{ is_number(states('sensor.salicru_registro_de_estado_5')) }}"
        state: "{{ (states('sensor.salicru_registro_de_estado_5') | int(0) | bitwise_and(256)) != 0 }}"
      - name: Salicru Fallo del ventilador
        default_entity_id: binary_sensor.salicru_fallo_del_ventilador
        unique_id: salicru_rt3_fallada_ventilador
        device_class: problem
        availability: "{{ is_number(states('sensor.salicru_registro_de_estado_5')) }}"
        state: "{{ (states('sensor.salicru_registro_de_estado_5') | int(0) | bitwise_and(4)) != 0 }}"

Valida de nuevo la configuración y reinicia Core para cargar los registros nuevos. Este bloque procede del paquete funcional auditado; se han sustituido la dirección y los identificadores privados. No se han añadido sensores pendientes solo para completar una lista.

Qué hemos dejado fuera: autonomía, temperatura y potencias

El registro 66 de autonomía no nos ha dado una lectura útil. Una lectura de dos palabras desde 66 devolvió cero y el valor del campo siguiente, que el mapa identifica como temperatura. Convertir ambos directamente en 32 bits produjo unos falsos 5,1 minutos: no lo publicamos como sensor. La tabla plantea una ambigüedad de longitud y superposición que todavía no hemos resuelto para este transporte.

El registro 67 devolvió 306 y el mapa indica Kelvin; la conversión aritmética sería 306 − 273,15 = 32,85 °C. Sin contraste suficiente del sensor y de la conversión en la instalación actual, la temperatura no está incluida. Tampoco hemos incorporado los registros 39 y 40 de W/VA: respondieron, pero falta contrastar la magnitud, y la marca de aplicación de 39 para 1–3 kVA merece revisión.

Otros campos devolvieron 0xFFFF o cadenas de asteriscos. No los convertimos en mediciones. Que una petición responda no obliga a crear una entidad; una batería al 100 % tampoco acredita su capacidad útil ni su estado de envejecimiento.

Paso 8. Interpreta estados y alarmas mediante bits

Una palabra Modbus tiene 16 bits. El manual numera los bits del 1 al 16; el software trabaja con posiciones del 0 al 15. La máscara que corresponde al bit del manual es 1 << (bit − 1). Para comprobarlo, la plantilla aplica bitwise_and y mira si el resultado es distinto de cero.

EntidadRegistroBit manualMáscara
Red eléctrica presente51516384
Salida alimentada548
Batería presente111
Batería baja511
Sobrecarga5632
Temperatura elevada5764
Fallo interno5516
Sustitución de batería59256
Fallo de ventilador534

Por ejemplo, para red presente utilizamos el bit 15 del registro 5: 2^(15−1) = 16384, no 32768. Para batería presente es el bit 1 del registro 1 y la máscara vale 1. Los bits desconocidos no se convierten en alarmas inventadas.

En estado normal hemos observado red, salida alimentada y batería presente activas, y las seis alarmas seleccionadas inactivas. No hemos provocado sobrecarga, desconectado baterías ni generado fallos para demostrar las transiciones. El soporte es lectura real en estado normal más correspondencia documental. Esto no certifica que todas las alarmas posibles estén ausentes: hay otros bits cuyo significado no hemos interpretado.

La disponibilidad forma parte del sensor

La expresión de estado usa int(0) para evitar errores al evaluar, pero eso por sí solo sería peligroso: una lectura inexistente podría parecer una alarma desactivada. Por eso cada plantilla incluye availability con is_number sobre la palabra original. Si el origen pasa a unknown o unavailable, la entidad derivada debe quedar no disponible. Es el criterio de la integración Template que aplicamos en el ejemplo.

Comprobamos las máscaras y esa disponibilidad con expresiones sintéticas, sin alterar estados reales ni interrumpir el suministro. No hemos ensayado una caída real de comunicaciones. Si el cliente conserva durante un tiempo el último valor numérico, esta disponibilidad no demuestra frescura inmediata del dato. Antes de tomar decisiones críticas hay que medir detección, latencia y recuperación; no equipares «tengo un número» con «estoy comunicando ahora mismo».

Durante el arranque vimos las plantillas en unknown aunque Modbus ya tuviera datos. Las plantillas basadas en estado esperan la inicialización de Home Assistant. Forzar update_entity antes de que estuvieran listas provocó un error de inicialización; esperamos y los binarios se actualizaron. No soluciones ese estado inicial escribiendo manualmente un off.

Paso 9. Crea un panel con tarjetas nativas

En el dashboard, entra en modo edición y añade una tarjeta manual. Este bloque crea un vertical-stack con cuatro tarjetas nativas entities; no requiere Mushroom ni otros recursos personalizados. Conserva tu vista y el resto de tarjetas. Si has cambiado entity_id, adapta las referencias.

type: vertical-stack
cards:
  - type: entities
    title: Salicru — Estado general
    show_header_toggle: false
    entities:
      - sensor.salicru_modo_del_sai
      - binary_sensor.salicru_red_electrica_presente
      - binary_sensor.salicru_salida_alimentada
      - sensor.salicru_carga_del_sai
  - type: entities
    title: Salicru — Medidas eléctricas
    show_header_toggle: false
    entities:
      - sensor.salicru_tension_de_entrada
      - sensor.salicru_frecuencia_de_entrada
      - sensor.salicru_tension_de_salida
      - sensor.salicru_frecuencia_de_salida
      - sensor.salicru_corriente_de_salida
  - type: entities
    title: Salicru — Batería
    show_header_toggle: false
    entities:
      - sensor.salicru_nivel_de_bateria
      - sensor.salicru_tension_de_bateria
      - binary_sensor.salicru_bateria_presente
      - binary_sensor.salicru_bateria_baja
  - type: entities
    title: Salicru — Salud y alarmas
    show_header_toggle: false
    entities:
      - binary_sensor.salicru_sobrecarga
      - binary_sensor.salicru_temperatura_elevada
      - binary_sensor.salicru_fallo_interno
      - binary_sensor.salicru_sustitucion_de_bateria
      - binary_sensor.salicru_fallo_del_ventilador

El primer grupo resume modo, red, alimentación y carga. El segundo reúne las magnitudes eléctricas. El tercero muestra batería y su alarma de nivel bajo. El cuarto concentra las cinco alarmas restantes. No se muestran los registros auxiliares de bits en la tarjeta: son necesarios para calcular los estados, pero no aportan una lectura cómoda al usuario.

Tarjeta real del SAI Salicru con modo línea, red presente, salida alimentada y carga
Estado general: modo del SAI, presencia de red, alimentación de salida y porcentaje de carga.
Tarjeta real de tensiones y frecuencias de entrada y salida y corriente de salida del SAI Salicru
Medidas eléctricas obtenidas por Modbus TCP: tensiones, frecuencias y corriente de salida.
Tarjeta real de porcentaje y tensión de batería, batería presente y alarma de batería baja
Batería: porcentaje, tensión y dos estados binarios. La captura muestra las lecturas del momento, no un ensayo de capacidad.
Tarjeta real con alarmas de sobrecarga, temperatura elevada, fallo interno, sustitución de batería y ventilador
Salud y alarmas seleccionadas: en esta captura aparecen en estado OK. No se han provocado fallos para comprobar las transiciones.

Paso 10. Contrasta las mediciones y observa sus actualizaciones

Nimbus y la pantalla del SAI pueden servir como referencia, aunque no son necesarios para que Home Assistant consulte Modbus. Compara la misma magnitud: tensión con tensión, corriente con corriente y frecuencia de salida con frecuencia de salida. 230 V es tensión; la corriente se expresa en amperios. No conviertas el porcentaje de carga directamente en vatios sin conocer su criterio.

Nuestra primera frecuencia fue 500 en bruto y 50,0 Hz en ambos sistemas. Batería y tensión de batería mostraron 100 % y 39,4 V. La tensión de salida rondaba 229 V y la corriente variaba según la carga. Las lecturas no se obtuvieron todas al mismo instante: la medida cloud tiene su propia fecha y Home Assistant consulta cada minuto.

Vimos diferencias pequeñas de décimas de voltio y de porcentaje de carga entre capturas. Son compatibles con las distintas cadencias y con cambios de consumo, pero no proclamamos una coincidencia perfecta ni una prueba de calibración. Mira la fecha de la medida de Nimbus, no solo la hora a la que haces la captura. Una discrepancia grande y persistente sí necesita revisar dirección, escala y definición de la magnitud.

Comprueba varias actualizaciones. Un valor constante no tiene por qué cambiar su marca de estado en cada lectura; también puede existir restauración del último estado durante el arranque. En nuestras comprobaciones vimos variar tensión y carga, además de las respuestas Modbus originales. Para decisiones importantes, añade una comprobación específica de frescura y comunicación en una fase posterior.

Gráfica real de tensión de entrada del Salicru en Home Assistant, con agregado de cinco minutos
Historial de tensión de entrada en Home Assistant, agregado de cinco minutos. Su escala vertical es distinta de la gráfica de salida: no compares directamente la altura de las oscilaciones.
Gráfica real de tensión de salida del Salicru en Home Assistant alrededor de 229,5 voltios
Historial de tensión de salida, agregado de cinco minutos. Observa las cifras del eje: esta gráfica utiliza una escala vertical más estrecha que la de entrada.

Paso 11. Diagnóstico: qué revisar según el error

SíntomaQué significa o no significaQué revisar
Enable, pero no respondeEl ajuste no garantiza que el proceso escuche.Persistencia, estado LCD, eventos y transporte; contempla el reinicio IoT solo con documentación del modelo.
Conexión TCP rechazada / WinError 10061No se ha establecido TCP; aún no se está interpretando Modbus.IP, puerto, servidor activo y filtro/ruta. No corregir el registro para este error.
TimeoutNo hubo respuesta en el plazo; no equivale necesariamente a puerto cerrado.Alcance de red, VLAN, filtros, servicio y plazo. No barrer todos los puertos.
IP incorrecta o cambiadaEl cliente puede apuntar a otro equipo o a un destino ausente.Identificación local y asignación DHCP; después reserva adecuada.
Unit ID equivocadoTCP puede funcionar y la petición no atenderse o devolver excepción.Identificador documentado; 1 es el validado en nuestro caso, no un valor universal.
Excepción ModbusEl servidor ha entendido el protocolo y rechaza la operación solicitada.Código concreto; dirección/función soportadas. No ejecutar escritura para superar el rechazo.
Valor bruto 2294 o 500Puede faltar la conversión de unidades.Décimas V/Hz del mapa y scale 0.1, sin aplicarla dos veces.
Respuesta válida, valor absurdoPuede ser formato, desplazamiento, campo no soportado o relleno.Longitud y mapa; conservar bytes, excluir datos no interpretados.
Sensor unavailableNo hay dato utilizable según el cliente o la disponibilidad.Logs, origen Modbus, red y plantilla; no equipararlo a estado normal.
Plantilla unknown al arrancarPuede estar pendiente de inicialización; no prueba por sí solo un fallo del bit.Esperar arranque y revisar errores de plantilla; no falsear el estado.
Entidades duplicadas / nombre con _2Puede haber hubs repetidos o IDs ya utilizados.Un solo paquete para el ejemplo; unique_id distintos para otro SAI.
Diferencias con NimbusLa plataforma cloud y HA no son lecturas sincronizadas.Marcas temporales, actualización y magnitud; investigar si persisten.
Otro modelo no funcionaEste mapa no es una interfaz universal Salicru.Modelo, tarjeta, firmware y documentación aplicable.

Con una excepción Modbus puedes distinguir códigos como 1 (función no admitida), 2 (dirección no válida), 3 (valor de petición no válido) o 4 (fallo del dispositivo servidor). La interpretación general del protocolo no sustituye el mapa del equipo. El script informa el código y termina, sin probar otro registro automáticamente.

Si la validación YAML falla, no reinicies. Cuándo los sensores no aparezcan, comprueba que el paquete se carga y que no has mezclado un archivo de paquete con un !include que espera solo una lista. Si necesitas volver atrás, restaura el paquete anterior o retira el nuevo archivo, valida y reinicia Core; no restaures toda la instalación por un error aislado de este paquete.

Paso 12. Seguridad y automatizaciones: lo que falta antes de actuar

  • Mantén Modbus en una LAN de confianza; no redirijas TCP 502 desde Internet. Modbus TCP convencional no proporciona la autenticación y cifrado de una sesión HTTPS.
  • Este cliente solo lee FC03 y los registros seleccionados. Eso no bloquea las funciones de escritura que el servidor pueda ofrecer a otros clientes.
  • No publiques credenciales, QR de vinculación, tokens, MAC, serie ni configuraciones completas de tu casa. Los ejemplos de este artículo están anonimizados.
  • No ejecutes software que escriba órdenes al SAI durante la inicialización ni provoques tests, cambios de modo o cortes para ver una alarma.
  • Trata unavailable y unknown de forma distinta a on/off. Una ausencia de comunicación no equivale a «sin problemas».
  • No apagues automáticamente el NAS basándote en estados cuya transición y recuperación aún no hayas validado.

Red presente y modo batería son candidatos para avisos de corte y restablecimiento, pero esta guía no instala automatizaciones críticas. Antes de crearlas comprueba el comportamiento real, qué sucede si se pierde la red, cuánto tarda en detectarse y si la Raspberry y los equipos de comunicaciones siguen funcionando con el SAI. Evita avisos de restablecimiento disparados simplemente porque Home Assistant se reinicia o recupera un estado antiguo.

Si quieres separar datos sensibles de otras configuraciones, consulta nuestra guía de secrets.yaml y protección de contraseñas. Modbus no usa una contraseña en este hub, pero eso no convierte la LAN en un entorno seguro por defecto.

Resultado y límites de esta integración

Con un servidor Modbus compatible y un mapa correcto, Home Assistant puede mostrar datos locales del SAI sin consultar continuamente la nube del fabricante. En nuestro RT3 hemos pasado de un puerto que rechazaba conexiones a medidas actualizadas, modo de funcionamiento y señales de estado organizadas en un panel útil.

La parte más valiosa no fue crear cuantos más sensores mejor, sino contrastar el formato y excluir los datos dudosos. No hemos resuelto la autonomía ni validado físicamente todos los fallos; tampoco prometemos el mismo mapa para cualquier Salicru. Empieza con una lectura, verifica las unidades y amplía el paquete solo cuando los resultados tengan sentido. Así tendrás una base de monitorización que puedes explicar y mantener.

Documentación técnica y versión de los ejemplos

Ejemplos derivados de la instalación auditada el 13 de octubre de 2026, con Home Assistant Core 2026.10.1. Los enlaces técnicos son documentación primaria; las observaciones prácticas corresponden a nuestra unidad. No se ha actualizado el firmware para obtener este resultado.

Continúa leyendo

Siguiente guía relacionada · 4 min de lectura

Salicru TWIN RT3 de 1.000 VA: unboxing y uso real

El Salicru SLC-1000-TWIN RT3 es un SAI on-line de doble conversión de 1.000 VA y 1.000 W. Salicru me envió la unidad que enseño…

Continuar con este artículo