« `markdown
# Domotiser son onduleur Huawei SUN2000 avec Home Assistant : Guide Technique Complet
## Introduction : Pourquoi intégrer son onduleur solaire à la domotique ?
L’installation photovoltaïque est un investissement majeur pour les foyers souhaitant optimiser leur autonomie énergétique. Pourtant, la plupart des utilisateurs se contentent d’un suivi basique via l’application **FusionSolar** de Huawei, sans exploiter pleinement les données de leur onduleur **SUN2000**. En domotisant cet équipement avec **Home Assistant**, vous pouvez :
– **Automatiser** des scénarios en fonction de la production solaire (ex : déclencher un chauffe-eau quand la production dépasse 3 kW).
– **Centraliser** les données énergétiques avec d’autres capteurs (compteurs Linky, batteries, etc.).
– **Créer des tableaux de bord** personnalisés pour un suivi en temps réel.
– **Détecter des anomalies** (ex : chute brutale de production) via des alertes automatiques.
Ce guide détaille **méthode par méthode** pour intégrer votre SUN2000 à Home Assistant, avec des exemples concrets de configuration et des pièges à éviter.
—
## Méthode 1 : Intégration via Modbus TCP (Recommandé pour les installations locales)
### Prérequis
– Un onduleur **Huawei SUN2000** (tous modèles compatibles Modbus).
– Un **routeur** avec accès au réseau local de l’onduleur.
– Un **serveur Home Assistant** (Raspberry Pi, NAS, ou machine dédiée). Pour un setup DIY optimisé, consultez notre [guide du Lab](https://solarlogik.fr/le-lab/).
– Un câble **Ethernet** (ou Wi-Fi si l’onduleur le supporte).
### Étape 1 : Activer Modbus sur l’onduleur
1. Accédez à l’interface de l’onduleur via son adresse IP locale (ex : `192.168.1.100`).
2. Dans les paramètres réseau, activez **Modbus TCP** et notez :
– **Port** (par défaut : `502`).
– **Adresse IP** de l’onduleur.
– **ID de l’esclave Modbus** (généralement `1`).
> ⚠️ **Sécurité** : Désactivez l’accès Modbus depuis l’extérieur de votre réseau local pour éviter les intrusions.
### Étape 2 : Installer l’intégration Modbus dans Home Assistant
1. Dans Home Assistant, allez dans **Paramètres > Appareils et services > Ajouter une intégration**.
2. Cherchez ** »Modbus »** et installez l’intégration officielle.
3. Configurez une nouvelle connexion avec les paramètres suivants :
« `yaml
# Configuration.yaml
modbus:
– name: sun2000
type: tcp
host: 192.168.1.100 # Remplacez par l’IP de votre onduleur
port: 502
delay: 5
timeout: 10
« `
### Étape 3 : Créer des capteurs pour les données clés
Ajoutez ces définitions dans votre fichier `configuration.yaml` pour récupérer les données essentielles :
« `yaml
sensor:
– platform: modbus
registers:
– name: « SUN2000 Puissance AC »
unit_of_measurement: « W »
slave: 1
register: 32080
count: 2
data_type: float32
scale: 0.1
precision: 1
– name: « SUN2000 Production journalière »
unit_of_measurement: « kWh »
slave: 1
register: 32114
count: 2
data_type: float32
scale: 0.1
precision: 1
– name: « SUN2000 Tension DC »
unit_of_measurement: « V »
slave: 1
register: 32016
count: 1
data_type: uint16
scale: 0.1
precision: 1
« `
> 🔍 **Explications** :
> – `register` : Adresse Modbus des données (voir [documentation Huawei](https://support.huawei.com/enterprise/fr/doc/EDOC1100138552) pour la liste complète).
> – `data_type` : Format des données (float32 pour les valeurs décimales, uint16 pour les entiers).
> – `scale` : Facteur de conversion (ex : `0.1` pour convertir des dixièmes en unités).
### Étape 4 : Visualiser les données dans un dashboard
Créez une carte **Énergie** dans Home Assistant pour afficher :
– La production instantanée.
– La production journalière.
– Le rendement des panneaux.
Exemple de code Lovelace :
« `yaml
type: energy-distribution
link_dashboard: true
« `
—
## Méthode 2 : Intégration via l’API FusionSolar (Cloud)
Si votre onduleur n’est pas accessible en local (ex : installation en 4G), vous pouvez utiliser l’**API officielle Huawei FusionSolar**.
### Prérequis
– Un compte **FusionSolar** avec accès à votre installation.
– Un **token d’API** (à générer dans les paramètres du compte).
– Un **serveur Home Assistant** avec accès internet.
### Étape 1 : Générer un token d’API
1. Connectez-vous à [FusionSolar](https://eu5.fusionsolar.huawei.com/).
2. Allez dans **Paramètres > Gestion des API** et créez un nouveau token.
3. Notez :
– **App ID**
– **App Secret**
– **Plant ID** (ID de votre installation)
### Étape 2 : Installer l’intégration HACS « Huawei Solar »
1. Installez [HACS](https://hacs.xyz/) dans Home Assistant.
2. Cherchez l’intégration ** »Huawei Solar »** et installez-la.
3. Redémarrez Home Assistant.
### Étape 3 : Configurer l’intégration
Ajoutez cette configuration dans `configuration.yaml` :
« `yaml
huawei_solar:
– username: « votre_email@domaine.com »
password: « votre_mot_de_passe »
plant_id: « 123456789 » # Remplacez par votre Plant ID
region: « eu » # ou « us », « cn », etc.
« `
> ⚠️ **Limitations** :
> – L’API cloud a un **délai de rafraîchissement** (généralement 5 minutes).
> – Huawei peut **limiter les requêtes** en cas d’usage intensif.
—
## Méthode 3 : Solution hybride avec un script Python (Pour les utilisateurs avancés)
Si vous souhaitez **personnaliser** la collecte de données (ex : calculer le rendement réel des panneaux), vous pouvez utiliser un script Python qui interroge l’onduleur via Modbus et envoie les données à Home Assistant via MQTT.
### Prérequis
– Un **broker MQTT** (ex : Mosquitto) installé sur votre réseau. Pour un guide complet, consultez notre [Guide Domotique](https://solarlogik.fr/guide-domotique/).
– Python 3 avec les bibliothèques `pymodbus` et `paho-mqtt`.
### Script Python (sun2000_mqtt.py)
« `python
from pymodbus.client import ModbusTcpClient
import paho.mqtt.client as mqtt
import time
# Configuration Modbus
MODBUS_IP = « 192.168.1.100 »
MODBUS_PORT = 502
SLAVE_ID = 1
# Configuration MQTT
MQTT_BROKER = « 192.168.1.50 » # IP de votre broker MQTT
MQTT_TOPIC = « solar/sun2000″
def read_modbus_register(client, register, count=1, data_type= »uint16 »):
response = client.read_holding_registers(register, count, slave=SLAVE_ID)
if data_type == « float32 »:
return float(response.registers[0] << 16 | response.registers[1]) * 0.1
else:
return response.registers[0] * 0.1
def main():
modbus_client = ModbusTcpClient(MODBUS_IP, port=MODBUS_PORT)
mqtt_client = mqtt.Client("sun2000_mqtt")
mqtt_client.connect(MQTT_BROKER)
while True:
try:
# Lire les données Modbus
power_ac = read_modbus_register(modbus_client, 32080, 2, "float32")
daily_yield = read_modbus_register(modbus_client, 32114, 2, "float32")
# Publier sur MQTT
mqtt_client.publish(f"{MQTT_TOPIC}/power_ac", power_ac)
mqtt_client.publish(f"{MQTT_TOPIC}/daily_yield", daily_yield)
time.sleep(30) # Rafraîchissement toutes les 30 secondes
except Exception as e:
print(f"Erreur : {e}")
time.sleep(60)
if __name__ == "__main__":
main()
```
### Configuration Home Assistant pour MQTT
Ajoutez ces capteurs dans `configuration.yaml` :
```yaml
mqtt:
sensor:
- name: "SUN2000 Puissance AC (MQTT)"
state_topic: "solar/sun2000/power_ac"
unit_of_measurement: "W"
device_class: power
- name: "SUN2000 Production journalière (MQTT)"
state_topic: "solar/sun2000/daily_yield"
unit_of_measurement: "kWh"
device_class: energy
```
---
## Automatisations avancées avec Home Assistant
Une fois votre onduleur intégré, voici des exemples d'**automatisations** pour optimiser votre consommation :
### 1. Déclencher un chauffe-eau quand la production dépasse 2 kW
```yaml
automation:
- alias: "Chauffe-eau solaire"
trigger:
platform: numeric_state
entity_id: sensor.sun2000_puissance_ac
above: 2000
condition:
condition: time
after: "08:00:00"
before: "18:00:00"
action:
service: switch.turn_on
target:
entity_id: switch.chauffe_eau
```
### 2. Alerte en cas de chute brutale de production
```yaml
automation:
- alias: "Alerte production solaire anormale"
trigger:
platform: numeric_state
entity_id: sensor.sun2000_puissance_ac
below: 500
for:
minutes: 10
condition:
condition: sun
after: sunrise
before: sunset
action:
service: notify.mobile_app_votre_telephone
data:
message: "⚠️ Production solaire anormalement basse !"
```
### 3. Optimiser la recharge d'une batterie domestique
Si vous avez une batterie (ex : **LG Chem**, **Pylontech**), vous pouvez prioriser la recharge quand la production solaire est maximale. Pour en savoir plus sur les solutions de stockage, consultez notre [Guide Solaire 2026](https://solarlogik.fr/guide-2026/).
```yaml
automation:
- alias: "Recharge batterie en heures solaires"
trigger:
platform: numeric_state
entity_id: sensor.sun2000_puissance_ac
above: 3000
action:
service: switch.turn_on
target:
entity_id: switch.recharge_batterie
```
---
## Problèmes courants et solutions
| Problème | Cause possible | Solution |
|----------|----------------|----------|
| **Modbus ne répond pas** | Port 502 bloqué par le routeur | Vérifiez les règles du pare-feu et autorisez le port 502. |
| **Données incohérentes** | Adresse Modbus incorrecte | Consultez la [documentation Huawei](https://support.huawei.com/) pour les bonnes adresses. |
| **API FusionSolar en erreur** | Token expiré ou limite de requêtes atteinte | Régénérez le token et réduisez la fréquence des requêtes. |
| **Lenteur dans Home Assistant** | Trop de capteurs Modbus interrogés | Limitez le nombre de registres lus et augmentez le `delay` dans la config Modbus. |
---
## Conclusion : Vers une maison 100% autonome et intelligente
Domotiser son onduleur **Huawei SUN2000** avec Home Assistant n'est pas seulement une question de confort : c'est une **étape clé** vers l'autonomie énergétique. En combinant :
- **Données solaires en temps réel** (via Modbus ou MQTT).
- **Automatisations intelligentes** (chauffe-eau, batteries, etc.).
- **Tableaux de bord personnalisés**,
vous transformez votre installation photovoltaïque en un **système dynamique**, capable de s'adapter à votre consommation et aux conditions météo.
### Et demain ?
Les innovations en **hygroélectricité** (production d'électricité à partir de l'humidité de l'air) ou les **micro-réseaux locaux** pourraient révolutionner la gestion de l'énergie. Pour rester à la pointe, explorez nos recherches dans la section [R&D (Futur)](https://solarlogik.fr/r-d/).
🚀 **Prochaine étape** : Intégrez votre compteur Linky à Home Assistant pour une vision **360°** de votre consommation et production d'énergie !
```