Passer au contenu

Onduleur Salicru et Home Assistant : intégration Modbus TCP

22/11/2026
Illustration d’un onduleur Salicru relié à Home Assistant par Modbus TCP, avec le titre ÇA MARCHE !

Un onduleur, ou alimentation sans interruption (ASI/UPS), maintient les équipements alimentés pendant une coupure. Selon sa technologie, il améliore aussi les caractéristiques de l’énergie fournie. Pour protéger un NAS, un ordinateur ou le réseau domestique, surveiller un voyant ne suffit pas : le niveau de batterie, la charge, le mode de fonctionnement et les défauts sont bien plus utiles.

Ce guide explique comment intégrer un onduleur Salicru dans Home Assistant avec Modbus TCP. La communication passe par le réseau Ethernet local et par l’intégration Modbus déjà présente dans Home Assistant. Cet exemple ne nécessite ni intégration personnalisée ni HACS. Nimbus a servi à comparer les mesures, mais Home Assistant interroge directement l’onduleur.

Notre matériel de référence est un Salicru SLC-1000-TWIN RT3, avec le firmware de l’onduleur 00.01.15485 et le firmware IoT 02.02.000. La configuration a été validée sous Home Assistant Core 2026.10.1 en octobre 2026. Elle fournit 18 entités utiles : huit mesures numériques, le mode, trois indicateurs de présence ou d’alimentation et six alarmes sélectionnées. Trois entités supplémentaires contiennent les valeurs brutes du mode et des mots d’état. Ce résultat est vérifié sur notre exemplaire, pas sur tous les produits Salicru.

Nous parlons ici d’un onduleur de secours pour équipements informatiques, pas d’un onduleur photovoltaïque. Les captures montrent notre installation à environ 230 V/50 Hz. Ce sont des valeurs mesurées, pas des réglages à reproduire sur un autre appareil ou une autre installation électrique.

Étape 0. Redémarrer l’IoT interne depuis l’écran de l’onduleur

Pour suivre ce guide avec un Salicru SLC-1000-TWIN RT3, commencez par redémarrer le module de communication. Sur l’écran LCD de l’onduleur, sélectionnez Control → Reinicio IoT interno (redémarrage de l’IoT interne), puis confirmez. Lorsque l’écran affiche « Hecho » (terminé), attendez que le module soit de nouveau joignable sur le réseau. Vérifiez ensuite le modèle et l’adresse IP, puis activez Modbus TCP.

La communication avec le module est momentanément interrompue pendant le redémarrage. Si vous utilisez une autre variante, vérifiez que cette fonction figure dans son menu et renseignez-vous sur ses effets.

Sur notre appareil, ce redémarrage nous a permis de poursuivre à deux occasions. Le portail HTTPS est redevenu accessible après une erreur de connexion et Modbus a répondu sur le port 502 après le redémarrage décrit à l’étape 4.

Prérequis avant de commencer

  • Un onduleur Salicru doté d’un serveur Modbus TCP accessible, intégré ou fourni par un accessoire compatible, et sa table de registres.
  • Une connexion Ethernet et un accès réseau de Home Assistant vers l’onduleur.
  • Un accès légitime aux réglages de l’onduleur et aux fichiers de configuration de Home Assistant.
  • Une sauvegarde et un éditeur pour configuration.yaml et les fichiers de packages.
  • Des bases en YAML : indentation avec des espaces, sans tabulations.
  • Le temps de vérifier les mesures avant de les utiliser dans des automatisations de protection.

Cette configuration ne nécessite ni USB, ni serveur NUT, ni interrogation du cloud. L’onduleur, Home Assistant et les équipements réseau nécessaires doivent toutefois rester opérationnels. Pour recevoir une notification pendant une coupure, vérifiez aussi leur alimentation et le chemin de notification : disposer de capteurs locaux ne garantit pas qu’un message puisse sortir du logement.

Étape 1. Vérifier le modèle exact et la compatibilité Modbus

Consultez l’étiquette et le menu d’identification. Relevez le modèle exact, la puissance nominale, les versions de firmware et le matériel de communication. Une prise Ethernet ne prouve pas la présence de Modbus TCP, de SNMP ou d’une API de supervision. Le port IoT intégré et une carte réseau optionnelle peuvent proposer des services et des tables différents.

Matériel ou méthodeÉléments disponiblesVérifications nécessaires
Notre SLC-1000-TWIN RT3Modbus TCP intégré et entités de ce guide fonctionnels sur notre exemplaire.Comportement de votre matériel et de votre firmware.
Famille RT3 / IQ14700L’annexe comporte une colonne 1–3 kVA malgré la couverture 4–10 kVA.Application des registres à votre modèle et à votre liaison.
Carte de communication optionnelleLes fonctions dépendent de la carte et de son firmware.Modèle de carte, port TCP, Unit ID et table propre.
Autre Salicru / USBAutre protocole ou NUT éventuellement nécessaire.Prise en charge réelle du pilote et des variables ; ne pas copier ce YAML à l’aveugle.

Les références utilisées sont le manuel RT3 EL22650, le manuel de connectivité EL28450 et la table Modbus IQ14700. Vérifiez la colonne correspondant au matériel, pas uniquement le titre du document. Ces références constructeur peuvent s’ouvrir en espagnol : ce sont bien les documents utilisés pour nos essais.

USB/NUT constitue une autre méthode. La liste de compatibilité NUT mentionne la famille RT3 avec usbhid-ups expérimental, mais nous n’avons pas testé cet exemplaire en USB. L’intégration NUT de Home Assistant nécessite un serveur NUT opérationnel ; elle ne convertit pas directement l’USB en Modbus.

Étape 2. Identifier l’adresse IP et la stabiliser

Repérez l’onduleur dans la liste des clients du routeur ou consultez son adresse Ethernet sur l’écran ou le portail local. Tous les exemples utilisent 192.168.1.50, une adresse fictive. Remplacez-la par celle de votre onduleur. Aucune adresse du guide ne correspond au réseau domestique de nos essais.

Si l’appareil utilise DHCP, une réservation dans le routeur permet de conserver la même adresse. Cette réservation ne se confond pas avec une adresse statique configurée manuellement dans l’onduleur. Notre portail indiquait DHCP et nous n’avons pas modifié ce réglage pour obtenir une réponse. La réservation est une recommandation de pérennité, pas une modification réalisée pendant l’essai.

Assurez-vous que Home Assistant atteint cette adresse. Si les appareils sont sur des VLAN différents, contrôlez le routage et les règles pour ce destinataire et ce port. N’ouvrez pas tous les ports et ne désactivez pas globalement le pare-feu. Un test réussi depuis un ordinateur ne prouve pas que Home Assistant dispose du même accès réseau.

Si l’adresse IP est correcte mais que le portail reste inaccessible

Ouvrez https://IP_ONDULEUR/if/login avec l’adresse confirmée dans le routeur. Si ERR_CONNECTION_RESET apparaît, vérifiez que le module est revenu sur le réseau après le redémarrage de l’étape 0. Pour un avertissement de certificat, consultez l’étape 3.

Étape 3. Activer Modbus TCP et vérifier l’enregistrement

Sur notre IoT setting portal, accessible à https://IP_ONDULEUR avec nos identifiants, l’option se trouve dans Settings → Network → Access Control → Modbus TCP. Nous sommes passés de Disable à Enable, avons enregistré puis rechargé la page. Nous n’avons pas modifié le délai d’attente, la whitelist, CORS, HTTP ou le débogage distant pour obtenir une lecture.

Le manuel RT3 décrit aussi Modbus TCP dans les réglages du LCD, désactivé par défaut. Nous avons vérifié que l’écran physique l’indiquait activé. Les menus peuvent varier : suivez le manuel du modèle et utilisez votre accès légitime, sans essayer des mots de passe ou des codes PIN par défaut au hasard.

Le journal a enregistré Modbus TCP enabled. Cet événement confirme le changement, mais la mention Operational ne teste pas l’écoute TCP. Un paramètre activé et un service TCP accessible ne sont pas la même vérification.

Si le navigateur bloque le portail

Le certificat de notre appareil utilisait un nom différent de l’adresse saisie et un émetteur non reconnu. Kaspersky le bloquait explicitement. Une exception limitée à l’appareil identifié, correctement enregistrée, a supprimé ce blocage antivirus, mais un avertissement distinct du navigateur subsistait. L’exception ne corrige pas le certificat. Vérifiez la destination avant toute action ; n’installez pas d’autorité inconnue et ne désactivez pas la protection de tout le réseau.

Une page blanche n’indique pas nécessairement un problème d’identifiants. Chez nous, un JavaScript indispensable ne se chargeait pas : recevoir le HTML avec HTTP 200 ne suffisait pas à rendre l’application fonctionnelle. Nous n’avons pas établi que toutes les réinitialisations de connexion antérieures avaient la même cause.

Étape 4. Résoudre le refus de connexion sur le port 502

C’était notre principal blocage. Enable restait enregistré, le LCD indiquait Modbus actif et le journal confirmait l’activation, mais TCP 502 renvoyait toujours connexion refusée. Un second appareil du réseau obtenait la même réponse. Il n’était donc pas justifié de tout attribuer au navigateur ou à l’antivirus du premier ordinateur.

L’échec se produisait avant l’envoi de la requête Modbus. Changer le registre ou l’Unit ID ne pouvait pas résoudre ce refus TCP. Nous n’avons pas balayé des adresses ou des unités, mis à jour le firmware ni modifié les filtres par tâtonnement.

Ce qui a fonctionné : redémarrer l’IoT interne depuis le LCD physique

Nous avons arrêté proprement le PC et le NAS avant l’intervention. Sur le LCD physique de l’onduleur, nous avons utilisé Control → Reinicio IoT interno (redémarrage de l’IoT interne). L’écran a confirmé « Hecho » (terminé). Après vérification que Modbus restait activé, la même lecture minimale a enfin répondu.

L’action n’a pas été effectuée dans le navigateur. Redémarrer le module IoT ne revient ni à redémarrer ou arrêter tout l’onduleur, ni à restaurer les paramètres d’usine. Nous n’avons observé aucune coupure des sorties sur notre appareil. Cette observation ne garantit pas le même résultat avec un autre modèle, matériel ou firmware.

N’en faites pas une étape obligatoire pour tous les Salicru. Avant d’utiliser un menu de contrôle, identifiez précisément la fonction dans la documentation et préparez les équipements protégés à une éventuelle interruption. Arrêtez-vous si le menu ou ses effets ne sont pas clairs. Nous avons observé une séquence avant/après, pas démontré la cause interne du blocage.

Étape 5. Effectuer une lecture documentée, sans écriture

Sous Windows, cette commande vérifie l’accès au port TCP 502 depuis cet ordinateur. Remplacez l’adresse fictive :

Test-NetConnection -ComputerName 192.168.1.50 -Port 502

TcpTestSucceeded: True prouve l’accès TCP, pas la justesse des données Modbus. Notre première requête valide utilisait Unit ID 1, fonction FC03, adresse PDU 43 et un registre de 16 bits. La valeur brute était 500. La table indique des dixièmes de hertz : 500 × 0,1 = 50,0 Hz, également affichés par Nimbus.

L’exemple ModScan du manuel affiche les adresses avec un décalage de +1. C’est une convention de présentation, pas une règle pour tous les clients. Nous avons utilisé 43 dans la PDU et 43 dans Home Assistant. Vérifiez si votre documentation compte à partir de zéro, de un ou ajoute un préfixe comme 40001.

Test Python facultatif : une requête FC03, sans nouvelle tentative

Enregistrez ce code sous lectura_salicru.py sur un ordinateur équipé de Python 3. Il dérive de notre outil testé : FC03, registre 43, un mot, TCP 502, hôte et Unit ID explicites. Il vérifie l’en-tête et la longueur sans test de batterie ni fonction d’écriture. Les messages de diagnostic et clés JSON conservent leurs libellés espagnols d’origine ; la requête et les valeurs brutes sont indépendantes de la langue.

"""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 première commande affiche uniquement la préparation, sans connexion réseau. L’ajout de --ejecutar envoie une requête. Le résultat respuesta_fc03 indique une réponse de protocole valide, pas la validation de toute la table. Conservez les exceptions et valeurs incohérentes pour les analyser. N’utilisez pas cette lecture fixe sur un autre modèle sans justification documentaire.

Étape 6. Configurer le premier capteur Home Assistant

Pour cet appareil, nous utilisons l’intégration Modbus native dans un package YAML, comme dans notre installation fonctionnelle. Aucune intégration personnalisée n’est nécessaire. Sauvegardez d’abord la configuration et préservez les autres réglages.

6.1. Charger un dossier de packages

Si vous découvrez les packages ou souhaitez comprendre comment regrouper la configuration d’un appareil dans un seul fichier, consultez notre guide pour organiser Home Assistant avec les packages (en espagnol). Il complète cet exemple pour conserver ensemble les capteurs et les modèles du Salicru.

Dans configuration.yaml, ajoutez cette structure uniquement si elle n’est pas déjà configurée :

homeassistant:
  packages: !include_dir_named packages

Si la clé homeassistant: existe, insérez packages dans cette section en conservant les autres options. Ne créez pas une seconde clé homeassistant. Si vos packages sont chargés autrement, respectez votre organisation. Chez nous, !include_dir_named packages était déjà présent.

Créez le dossier packages à côté de configuration.yaml, puis le fichier salicru_modbus.yaml à l’intérieur. Ce fichier contient directement modbus: puis template:, sans clé supplémentaire portant le nom du package. Consultez la documentation officielle des packages.

6.2. Commencer par la fréquence de sortie

modbus:
  - name: salicru_rt3
    type: tcp
    host: 192.168.1.50
    port: 502
    timeout: 3
    message_wait_milliseconds: 200
    sensors:
      - name: Salicru Fréquence de sortie
        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

Remplacez l’IP et vérifiez le port TCP et l’Unit ID. type: tcp désigne Modbus TCP avec en-tête MBAP, pas RTU sur TCP. input_type: holding sélectionne FC03. device_address correspond à l’Unit ID ; d’anciennes configurations utilisent slave. La fréquence documentée occupe deux octets : uint16 lit donc un mot, sans ajouter de count pour ce type.

L’interrogation se fait toutes les 60 secondes, avec 200 ms entre les messages. Il s’agit de notre configuration fonctionnelle, pas d’une exigence universelle du constructeur. Cette cadence n’est pas une capture d’événements en temps réel et ne garantit pas la détection de chaque microcoupure.

6.3. Valider, redémarrer Core et vérifier l’entité

Utilisez la vérification disponible dans Outils de développement → YAML de votre version. Corrigez indentation, clés dupliquées et options invalides avant de redémarrer. Redémarrez Home Assistant Core, pas l’onduleur. Les exemples correspondent à Core 2026.10.1 ; consultez la documentation Modbus pour une autre version.

Après le démarrage, ouvrez Outils de développement → États, recherchez salicru et vérifiez sensor.salicru_frequence_de_sortie. Un identifiant peut différer si le nom existait déjà ou a été modifié. N’utilisez pas « Définir l’état » pour faire apparaître la valeur attendue : cela ne prouve aucune communication avec l’onduleur.

Étape 7. Ajouter les mesures testées et le mode

Une fois la première mesure cohérente, remplacez le contenu du même package par la version complète ci-dessous. Ne conservez pas simultanément un package minimal et un package complet avec le même hub et les mêmes entités. N’ajoutez pas non plus un second bloc modbus: dans le fichier principal.

GrandeurPDUTypeÉchelle / unitéValidation
Fréquence de sortie43uint16× 0,1 Hz500 → 50,0 Hz ; correspond à Nimbus.
Tension de sortie59uint16× 0,1 VProche de Nimbus ; mesures non simultanées.
Charge de l’onduleur63uint16*× 1 %Valeurs variables cohérentes, sans étalonnage.
Niveau de batterie64uint16*× 1 %100 % ; correspond à Nimbus.
Tension de batterie68uint16× 0,1 V39,4 V ; correspond à Nimbus.
Tension d’entrée33uint16× 0,1 VRépond et s’actualise dans HA ; cohérence de grandeur vérifiée.
Fréquence d’entrée29uint16× 0,1 Hz50 Hz, cohérents avec les captures de référence.
Courant de sortie41uint16× 0,1 A0,4–0,7 A dans HA ; environ 0,6–0,7 A dans Nimbus.
Mode62uint16*Code3 = secteur observé ; autres transitions non testées.

* Champs d’un octet : la table décrit charge, batterie et mode sur un octet. Dans nos réponses FC03, le byte utile se trouve dans l’octet faible d’un mot de 16 bits, avec octet fort à zéro. C’est le format observé ici, pas une garantie pour tous les firmwares. En YAML, gardez le point décimal, même si l’interface affiche des virgules.

Codes de mode : documenté ne signifie pas transition testée

CodeSignificationÉtat de vérification
0Mise sous tensionDocumenté uniquement.
1Veille / StandbyDocumenté uniquement.
2BypassDocumenté uniquement.
3Secteur / LineObservé sur notre exemplaire.
4BatterieDocumenté ; aucune coupure provoquée.
5Test de batterieDocumenté ; aucun test lancé.
6RéservéNe pas inventer un mode.
7ConvertisseurDocumenté uniquement.
8ECODocumenté uniquement.

L’exemple utilise des noms et des identifiants d’entité en français. Les captures proviennent de notre installation, où certains noms sont en catalan. Pour un second onduleur, utilisez des noms de hub et d’entités ainsi que des unique_id distincts.

Package complet : 18 entités utiles

Le bloc comprend huit mesures, le code brut du mode, deux mots d’état bruts, le mode en texte et neuf capteurs binaires. Les alarmes partagent les mêmes mots d’origine : elles ne déclenchent pas neuf requêtes supplémentaires par cycle. Remplacez l’IP fictive, conservez une sauvegarde et validez avant de charger le fichier.

# Exemple pour le Salicru SLC TWIN RT3. Remplacez l’adresse IP par celle de votre onduleur.
# Surveillance locale : lecture FC03 uniquement. Autonomie à valider.
modbus:
  - name: salicru_rt3
    type: tcp
    host: 192.168.1.50
    port: 502
    timeout: 3
    message_wait_milliseconds: 200
    sensors:
      - name: Salicru Fréquence de sortie
        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 Tension de sortie
        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 Charge de sortie
        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 Niveau de batterie
        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 Tension de batterie
        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 Code de mode
        unique_id: salicru_rt3_codi_mode
        device_address: 1
        address: 62
        input_type: holding
        data_type: uint16
        precision: 0
        scan_interval: 60


      - name: Salicru Tension en entrée
        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 Fréquence en entrée
        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 Courant de sortie
        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 Registre de statut 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 Registre de statut 5
        unique_id: salicru_rt3_registre_estat_5
        device_address: 1
        address: 5
        input_type: holding
        data_type: uint16
        precision: 0
        scan_interval: 60


# Si le capteur source est indisponible, l’alarme doit aussi être indisponible.
template:
  - sensor:
      - name: Salicru Mode de fonctionnement
        default_entity_id: sensor.salicru_mode_de_fonctionnement
        unique_id: salicru_rt3_mode_sai
        icon: mdi:power-plug
        availability: "{{ is_number(states('sensor.salicru_code_de_mode')) }}"
        state: >-
          {% set modes = {0: 'Démarrage', 1: 'Veille', 2: 'Bypass',
                          3: 'En ligne', 4: 'Batterie', 5: 'Test de batterie',
                          6: 'Réservé', 7: 'Convertisseur', 8: 'ECO'} %}
          {% set code = states('sensor.salicru_code_de_mode') | int(-1) %}
          {{ modes.get(code, 'Code inconnu (' ~ code ~ ')') }}
  - binary_sensor:
      - name: Salicru Secteur présent
        default_entity_id: binary_sensor.salicru_secteur_present
        unique_id: salicru_rt3_xarxa_present
        device_class: power
        availability: "{{ is_number(states('sensor.salicru_registre_de_statut_5')) }}"
        state: "{{ (states('sensor.salicru_registre_de_statut_5') | int(0) | bitwise_and(16384)) != 0 }}"
      - name: Salicru Sortie alimentée
        default_entity_id: binary_sensor.salicru_sortie_alimentee
        unique_id: salicru_rt3_sortida_alimentada
        device_class: power
        availability: "{{ is_number(states('sensor.salicru_registre_de_statut_5')) }}"
        state: "{{ (states('sensor.salicru_registre_de_statut_5') | int(0) | bitwise_and(8)) != 0 }}"
      - name: Salicru Batterie présente
        default_entity_id: binary_sensor.salicru_batterie_presente
        unique_id: salicru_rt3_bateria_present
        availability: "{{ is_number(states('sensor.salicru_registre_de_statut_1')) }}"
        state: "{{ (states('sensor.salicru_registre_de_statut_1') | int(0) | bitwise_and(1)) != 0 }}"
      - name: Salicru Batterie faible
        default_entity_id: binary_sensor.salicru_batterie_faible
        unique_id: salicru_rt3_bateria_baixa
        device_class: battery
        availability: "{{ is_number(states('sensor.salicru_registre_de_statut_5')) }}"
        state: "{{ (states('sensor.salicru_registre_de_statut_5') | int(0) | bitwise_and(1)) != 0 }}"
      - name: Salicru Surcharge
        default_entity_id: binary_sensor.salicru_surcharge
        unique_id: salicru_rt3_sobrecarrega
        device_class: problem
        availability: "{{ is_number(states('sensor.salicru_registre_de_statut_5')) }}"
        state: "{{ (states('sensor.salicru_registre_de_statut_5') | int(0) | bitwise_and(32)) != 0 }}"
      - name: Salicru Température élevée
        default_entity_id: binary_sensor.salicru_temperature_elevee
        unique_id: salicru_rt3_temperatura_elevada
        device_class: problem
        availability: "{{ is_number(states('sensor.salicru_registre_de_statut_5')) }}"
        state: "{{ (states('sensor.salicru_registre_de_statut_5') | int(0) | bitwise_and(64)) != 0 }}"
      - name: Salicru Défaut interne
        default_entity_id: binary_sensor.salicru_defaut_interne
        unique_id: salicru_rt3_fallada_interna
        device_class: problem
        availability: "{{ is_number(states('sensor.salicru_registre_de_statut_5')) }}"
        state: "{{ (states('sensor.salicru_registre_de_statut_5') | int(0) | bitwise_and(16)) != 0 }}"
      - name: Salicru Remplacement de batterie
        default_entity_id: binary_sensor.salicru_remplacement_de_batterie
        unique_id: salicru_rt3_substitucio_bateria
        device_class: problem
        availability: "{{ is_number(states('sensor.salicru_registre_de_statut_5')) }}"
        state: "{{ (states('sensor.salicru_registre_de_statut_5') | int(0) | bitwise_and(256)) != 0 }}"
      - name: Salicru Défaut de ventilation
        default_entity_id: binary_sensor.salicru_defaut_de_ventilation
        unique_id: salicru_rt3_fallada_ventilador
        device_class: problem
        availability: "{{ is_number(states('sensor.salicru_registre_de_statut_5')) }}"
        state: "{{ (states('sensor.salicru_registre_de_statut_5') | int(0) | bitwise_and(4)) != 0 }}"

Validez de nouveau puis redémarrez Core pour charger les nouveaux registres Modbus. Ce YAML dérive structurellement de la configuration vérifiée, avec remplacement des identifiants privés de réseau et d’appareil. Aucun capteur encore incertain n’a été ajouté pour remplir le tableau de bord.

Pourquoi l’autonomie, la température et les puissances sont exclues

Le registre 66 ne fournit pas d’autonomie exploitable. Lire deux mots à partir de 66 a concaténé un zéro avec le champ suivant, documenté comme température. Leur interprétation en durée de 32 bits donnait 5,1 minutes non validées. L’ambiguïté de longueur et de chevauchement reste non résolue pour cette liaison : aucun capteur d’autonomie n’est publié.

Le registre 67 a renvoyé 306 et la table indique des kelvins. La conversion arithmétique serait 306 − 273,15 = 32,85 °C, mais le capteur et la conversion ne sont pas suffisamment recoupés dans la configuration actuelle. Les registres 39/40 ont répondu avec des valeurs candidates en W/VA, encore à confirmer ; l’indication d’application du 39 aux 1–3 kVA mérite aussi une vérification. Ces trois candidats sont absents du package.

Nous avons également rencontré 0xFFFF et des chaînes d’astérisques. Une réponse Modbus valide ne transforme pas ces données en mesures exploitables. Une batterie affichée à 100 % indique un niveau de charge, pas un état de santé ni une capacité utile démontrée.

Étape 8. Décoder les états et alarmes à partir des bits

Chaque mot Modbus contient 16 bits. Le manuel les numérote de 1 à 16, contre 0 à 15 pour les positions logicielles. La formule est 1 << (bit_du_manuel − 1). Le modèle applique bitwise_and ; un résultat non nul indique que le bit documenté est actif.

SignalRegistreBit du manuelMasque
Secteur présent51516384
Sortie alimentée548
Batterie présente111
Batterie faible511
Surcharge5632
Température élevée5764
Défaut interne5516
Remplacement de batterie59256
Défaut de ventilateur534

Pour le secteur présent, le bit 15 donne 2^(15−1) = 16384, pas 32768. Dans nos échantillons normaux, secteur, sortie alimentée et batterie présente étaient actifs, et les six alarmes sélectionnées inactives. Nous n’avons pas provoqué de défaut physique pour tester chaque transition. D’autres bits actifs non définis ne doivent devenir ni alarmes inventées, ni preuve d’absence totale de défaut.

Une perte de communication ne doit pas signifier « aucune alarme »

L’expression utilise int(0) pour éviter une erreur d’évaluation, mais ce mécanisme seul pourrait faire passer une donnée absente pour une alarme inactive. Chaque modèle contient donc availability et vérifie is_number sur son mot d’origine. Si l’origine devient unknown ou unavailable, l’entité dérivée devient indisponible. Voir l’intégration Template.

Les masques et le traitement de unknown/unavailable ont été contrôlés avec des expressions synthétiques, sans modifier les états réels ni couper l’alimentation. Nous n’avons pas testé une véritable perte de communication. Si le client Modbus conserve temporairement un ancien nombre, ce contrôle ne garantit pas sa fraîcheur. Mesurez détection et reprise avant toute décision critique.

Au démarrage, des modèles basés sur l’état peuvent rester unknown alors que les lectures Modbus sont déjà présentes. Une mise à jour forcée avant l’initialisation a généré une erreur dans nos vérifications ; après attente, les binaires se sont activés. Ne forcez pas manuellement off pour masquer une alarme indisponible ou non initialisée.

Étape 9. Créer un tableau de bord avec des cartes natives

Modifiez le tableau de bord et ajoutez une carte manuelle. Le bloc utilise un vertical-stack de quatre cartes entities natives, sans dépendance personnalisée. Préservez les autres cartes et adaptez les références si vous avez changé des identifiants. Les groupes séparent état général, mesures électriques, batterie et santé/alarmes.

type: vertical-stack
cards:
  - type: entities
    title: Salicru — État général
    show_header_toggle: false
    entities:
      - sensor.salicru_mode_de_fonctionnement
      - binary_sensor.salicru_secteur_present
      - binary_sensor.salicru_sortie_alimentee
      - sensor.salicru_charge_de_sortie
  - type: entities
    title: Salicru — Mesures électriques
    show_header_toggle: false
    entities:
      - sensor.salicru_tension_en_entree
      - sensor.salicru_frequence_en_entree
      - sensor.salicru_tension_de_sortie
      - sensor.salicru_frequence_de_sortie
      - sensor.salicru_courant_de_sortie
  - type: entities
    title: Salicru — Batterie
    show_header_toggle: false
    entities:
      - sensor.salicru_niveau_de_batterie
      - sensor.salicru_tension_de_batterie
      - binary_sensor.salicru_batterie_presente
      - binary_sensor.salicru_batterie_faible
  - type: entities
    title: Salicru — État et alarmes
    show_header_toggle: false
    entities:
      - binary_sensor.salicru_surcharge
      - binary_sensor.salicru_temperature_elevee
      - binary_sensor.salicru_defaut_interne
      - binary_sensor.salicru_remplacement_de_batterie
      - binary_sensor.salicru_defaut_de_ventilation

Les captures suivantes proviennent réellement de Home Assistant ; ce ne sont pas des maquettes. Les noms catalans et certains libellés espagnols correspondent à l’installation testée. Les capteurs auxiliaires bruts sont volontairement absents du tableau de bord : leurs mots numériques ne sont pas pratiques à consulter directement.

Carte d’état général de l’onduleur Salicru dans Home Assistant
État général : mode, présence secteur, sortie alimentée et charge.
Mesures de tension, fréquence et courant du Salicru dans Home Assistant
Mesures électriques obtenues localement par Modbus TCP.
Niveau, tension, présence et alarme de batterie du Salicru
État de la batterie au moment de la capture, sans mesure de capacité utile.
Alarmes de surcharge, température, défaut interne, batterie et ventilateur
Les alarmes sélectionnées sont normales sur cet échantillon ; leurs transitions physiques n’ont pas été provoquées.

Étape 10. Comparer les mesures et vérifier les actualisations

Nimbus et l’écran physique fournissent des références utiles, sans être nécessaires à la lecture Modbus locale. Comparez les mêmes grandeurs : fréquence de sortie avec fréquence de sortie, tension avec tension, courant avec courant. Les volts mesurent la tension ; les ampères mesurent le courant. Ne transformez pas directement un pourcentage de charge en watts sans connaître sa définition.

La première fréquence donnait 500 en brut et 50,0 Hz dans les deux systèmes. Les valeurs de batterie 100 % et 39,4 V correspondaient. La sortie se situait autour de 229 V et le courant variait avec la charge des appareils. Les mesures n’étaient pas synchronisées : Nimbus indique une date de mesure et Home Assistant dispose de sa propre interrogation à la minute.

Des écarts de quelques dixièmes de volt ou de points de charge sont compatibles avec les rafraîchissements décalés et les variations de consommation. Cela ne démontre ni une concordance parfaite ni un étalonnage. Lisez la date de la mesure Nimbus, pas uniquement l’heure de la capture. Un écart important et durable nécessite toujours de vérifier adresse, échelle et signification.

Observez plusieurs cycles. Une valeur constante ne change pas nécessairement sa date d’état à chaque lecture, et Home Assistant peut restaurer une ancienne valeur au démarrage. Nous avons observé les variations de tension et de charge ainsi que les réponses brutes. Fraîcheur et reprise doivent être validées séparément avant d’ajouter une logique d’arrêt des équipements.

Historique de la tension d’entrée du Salicru dans Home Assistant
Tension d’entrée agrégée sur cinq minutes. Les deux graphiques ont des échelles verticales différentes : ne comparez pas directement les hauteurs des variations.
Historique de la tension de sortie du Salicru dans Home Assistant
Tension de sortie agrégée sur cinq minutes ; son échelle verticale est plus resserrée que celle de l’entrée.

Étape 11. Diagnostiquer selon le symptôme

SymptômeInterprétationVérification suivante
Activé mais inaccessibleUn réglage enregistré ne teste pas le serveur.Persistance, LCD, journal et liaison ; redémarrage IoT seulement si documenté.
Connexion refusée / WinError 10061TCP non établi ; aucun registre encore décodé.IP, port, service, routage/filtre ; changer le registre ne corrige pas TCP.
TimeoutPas de réponse dans le délai ; port pas forcément fermé.Accès réseau, VLAN/filtre, service et délai. Éviter les balayages.
IP incorrecte ou modifiéeAutre appareil ou adresse absente possible.Identification locale et attribution DHCP.
Mauvais Unit IDTCP peut fonctionner mais la requête échouer.Unit ID documenté ; 1 est notre valeur testée, pas universelle.
Exception ModbusLe serveur comprend Modbus mais refuse la demande.Code exact, fonction et adresse prises en charge. Aucune écriture corrective.
500 ou 2294 affiché directementÉchelle éventuellement manquante.Unités et scale 0.1 ; ne pas convertir deux fois.
Réponse valide, valeur absurdeFormat, décalage, champ absent ou remplissage possible.Conserver les octets et vérifier table/longueur avant le capteur.
Capteur indisponiblePas de valeur exploitable selon client ou modèle.Journaux, mot d’origine, réseau, availability ; indisponible ne signifie pas normal.
Modèle unknown au démarrageInitialisation encore en attente possible.Attendre et consulter les erreurs, sans forcer un état.
Doublon ou suffixe _2Noms ou hubs déjà présents.Un seul package pour l’exemple, identifiants distincts pour un autre UPS.
Écart avec NimbusCadences de mise à jour différentes.Dates, unités et persistance de l’écart.
Autre modèle Salicru en échecLa table n’est pas universelle.Documentation exacte du modèle, de la carte et du firmware.

Les codes d’exception courants comprennent 1 (fonction non admise), 2 (adresse non valide), 3 (valeur de requête non valide) et 4 (défaillance du serveur). Leur sens général ne remplace pas la documentation du modèle. Notre script affiche le code puis s’arrête, sans essayer un autre registre.

Si la validation YAML échoue, ne redémarrez pas. Si les entités sont absentes, vérifiez le chargement des packages et si un !include attend une liste plutôt qu’un package complet. Pour revenir en arrière, restaurez le package précédent ou retirez le nouveau fichier, validez puis redémarrez Core. Un problème isolé de package ne nécessite pas automatiquement une restauration complète de Home Assistant.

Étape 12. Sécurité et limites des automatisations

  • Gardez Modbus sur un réseau local de confiance ; ne redirigez pas TCP 502 depuis Internet. Modbus TCP classique n’apporte pas l’authentification client ni le chiffrement de HTTPS.
  • Notre client ne lit que FC03 et les registres sélectionnés. D’autres clients accessibles peuvent toujours utiliser les écritures offertes par le serveur.
  • Ne partagez pas identifiants, QR d’appairage, tokens, MAC, numéros de série ou configuration domestique superflue.
  • N’exécutez pas de logiciel envoyant des commandes à l’onduleur au démarrage et ne déclenchez pas de test ou de changement d’alimentation pour voir une alarme.
  • Distinguez unknown/unavailable de on/off. Une panne de communication ne prouve pas l’absence d’alarmes.
  • N’arrêtez pas automatiquement le NAS à partir de transitions ou d’une reprise de communication non validées.

Présence secteur et mode batterie pourront servir à des notifications de coupure et de retour secteur. Ce tutoriel n’installe pas d’automatisation critique. Vérifiez d’abord transition réelle, perte et reprise de communication, délai de détection et alimentation de secours de l’hôte et du réseau. Évitez les fausses alertes de retour secteur dues à un simple redémarrage de Home Assistant ou à un état restauré.

Pour replacer les besoins de cette installation dans leur contexte, notre article Marketplace et HACS dans Home Assistant distingue ces outils ; le présent exemple utilise Modbus natif, sans ressource personnalisée. Le hub n’utilise pas de mot de passe, ce qui ne rend pas le réseau local automatiquement sûr.

Résultat obtenu et limites restantes

Avec un serveur Modbus compatible et la bonne table, Home Assistant peut superviser un onduleur localement sans interroger continuellement le cloud du fabricant. Notre RT3 fournit désormais des mesures électriques variables, le mode et des états/alarmes sélectionnés dans un tableau de bord natif. Aucune mise à jour de firmware n’a été nécessaire pour ce résultat.

L’essentiel n’était pas de multiplier les entités, mais de vérifier leur interprétation et d’écarter les données douteuses. L’autonomie reste non résolue, toutes les transitions de défaut n’ont pas été testées et un autre Salicru peut nécessiter une autre table. Commencez par une lecture documentée, vérifiez les unités puis étendez seulement lorsque les valeurs sont cohérentes. Vous disposerez ainsi d’une supervision compréhensible et maintenable.

Références primaires et version des exemples

Les exemples dérivent de la configuration validée le 13 octobre 2026 sous Core 2026.10.1. Les captures sont réelles, y compris les historiques d’entrée/sortie ajoutés ensuite ; elles ne démontrent pas la compatibilité ou le comportement en défaut d’un autre modèle. Vérifiez la documentation correspondant à votre version de Home Assistant.

Continúa leyendo

Siguiente guía relacionada · 3 min de lectura

Comment organiser Home Assistant avec les packages YAML

Un package Home Assistant permet de réunir les éléments YAML d’un même appareil ou d’un même usage. Par exemple, les capteurs de consommation, les…

Continuar con este artículo

Publications connexes

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *