
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.yamlet 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 disponibles | Vérifications nécessaires |
|---|---|---|
| Notre SLC-1000-TWIN RT3 | Modbus TCP intégré et entités de ce guide fonctionnels sur notre exemplaire. | Comportement de votre matériel et de votre firmware. |
| Famille RT3 / IQ14700 | L’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 optionnelle | Les fonctions dépendent de la carte et de son firmware. | Modèle de carte, port TCP, Unit ID et table propre. |
| Autre Salicru / USB | Autre 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 502TcpTestSucceeded: 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 --ejecutarLa 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 packagesSi 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: 60Remplacez 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.
| Grandeur | PDU | Type | Échelle / unité | Validation |
|---|---|---|---|---|
| Fréquence de sortie | 43 | uint16 | × 0,1 Hz | 500 → 50,0 Hz ; correspond à Nimbus. |
| Tension de sortie | 59 | uint16 | × 0,1 V | Proche de Nimbus ; mesures non simultanées. |
| Charge de l’onduleur | 63 | uint16* | × 1 % | Valeurs variables cohérentes, sans étalonnage. |
| Niveau de batterie | 64 | uint16* | × 1 % | 100 % ; correspond à Nimbus. |
| Tension de batterie | 68 | uint16 | × 0,1 V | 39,4 V ; correspond à Nimbus. |
| Tension d’entrée | 33 | uint16 | × 0,1 V | Répond et s’actualise dans HA ; cohérence de grandeur vérifiée. |
| Fréquence d’entrée | 29 | uint16 | × 0,1 Hz | 50 Hz, cohérents avec les captures de référence. |
| Courant de sortie | 41 | uint16 | × 0,1 A | 0,4–0,7 A dans HA ; environ 0,6–0,7 A dans Nimbus. |
| Mode | 62 | uint16* | Code | 3 = 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
| Code | Signification | État de vérification |
|---|---|---|
| 0 | Mise sous tension | Documenté uniquement. |
| 1 | Veille / Standby | Documenté uniquement. |
| 2 | Bypass | Documenté uniquement. |
| 3 | Secteur / Line | Observé sur notre exemplaire. |
| 4 | Batterie | Documenté ; aucune coupure provoquée. |
| 5 | Test de batterie | Documenté ; aucun test lancé. |
| 6 | Réservé | Ne pas inventer un mode. |
| 7 | Convertisseur | Documenté uniquement. |
| 8 | ECO | Documenté 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.
| Signal | Registre | Bit du manuel | Masque |
|---|---|---|---|
| Secteur présent | 5 | 15 | 16384 |
| Sortie alimentée | 5 | 4 | 8 |
| Batterie présente | 1 | 1 | 1 |
| Batterie faible | 5 | 1 | 1 |
| Surcharge | 5 | 6 | 32 |
| Température élevée | 5 | 7 | 64 |
| Défaut interne | 5 | 5 | 16 |
| Remplacement de batterie | 5 | 9 | 256 |
| Défaut de ventilateur | 5 | 3 | 4 |
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_ventilationLes 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.




É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.


Étape 11. Diagnostiquer selon le symptôme
| Symptôme | Interprétation | Vérification suivante |
|---|---|---|
| Activé mais inaccessible | Un réglage enregistré ne teste pas le serveur. | Persistance, LCD, journal et liaison ; redémarrage IoT seulement si documenté. |
| Connexion refusée / WinError 10061 | TCP non établi ; aucun registre encore décodé. | IP, port, service, routage/filtre ; changer le registre ne corrige pas TCP. |
| Timeout | Pas 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ée | Autre appareil ou adresse absente possible. | Identification locale et attribution DHCP. |
| Mauvais Unit ID | TCP peut fonctionner mais la requête échouer. | Unit ID documenté ; 1 est notre valeur testée, pas universelle. |
| Exception Modbus | Le 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 absurde | Format, décalage, champ absent ou remplissage possible. | Conserver les octets et vérifier table/longueur avant le capteur. |
| Capteur indisponible | Pas 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émarrage | Initialisation encore en attente possible. | Attendre et consulter les erreurs, sans forcer un état. |
| Doublon ou suffixe _2 | Noms ou hubs déjà présents. | Un seul package pour l’exemple, identifiants distincts pour un autre UPS. |
| Écart avec Nimbus | Cadences de mise à jour différentes. | Dates, unités et persistance de l’écart. |
| Autre modèle Salicru en échec | La 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
- Salicru IQ14700 : registres et définition des bits d’alarme.
- Salicru EL22650 : réglages du LCD RT3.
- Salicru EL28450 : IoT intégré et connectivité Nimbus.
- Intégration Modbus de Home Assistant.
- Intégration Template de Home Assistant.
- Packages de configuration Home Assistant.
- Compatibilité matérielle NUT pour étudier une solution USB.
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
