Forum Domoticz en français

Code : Tout sélectionner

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Script unifié Shelly EM - Gestion des 2 canaux avec compteurs Tempo
Version: 2.0
Date: 2025-12-23
"""

import json
import os
import time
import requests
import paho.mqtt.client as mqtt
from datetime import datetime
import logging
from typing import Optional, Dict
from logging.handlers import TimedRotatingFileHandler

# Watchdog systemd
try:
    from systemd.daemon import notify
    SYSTEMD = True
except ImportError:
    SYSTEMD = False

# ---------------- CONFIG ----------------
MQTT_BROKER = "MQTT_BROKER_IP"
MQTT_PORT = MQTT_PORT
SHELLY_ID = "SHELLY_ID"

DOMOTICZ_URL = "http://MQTT_BROKER_IP:8080"
DOMOTICZ_USER = "DOMOTICZ_USER"
DOMOTICZ_PASS = "DOMOTICZ_PASS"

# Configuration des 2 canaux
CANAUX = {
    0: {
        "topic": f"shellies/{SHELLY_ID}/emeter/0",
        "IDX_SIMPLE": IDX_CANAL0_TOTAL,      # Compteur total
        "IDX_COMPUTED": IDX_CANAL0_INSTANT,    # Compteur instantané
        "IDX_TEMPO": {
            "Bleu_HP": IDX_C0_BLEU_HP,
            "Bleu_HC": IDX_C0_BLEU_HC,
            "Blanc_HP": IDX_C0_BLANC_HP,
            "Blanc_HC": IDX_C0_BLANC_HC,
            "Rouge_HP": IDX_C0_ROUGE_HP,
            "Rouge_HC": IDX_C0_ROUGE_HC
        }
    },
    1: {
        "topic": f"shellies/{SHELLY_ID}/emeter/1",
        "IDX_SIMPLE": IDX_CANAL1_TOTAL,      # Compteur total
        "IDX_COMPUTED": IDX_CANAL1_INSTANT,    # Compteur instantané
        "IDX_TEMPO": {
            "Bleu_HP": IDX_C1_BLEU_HP,
            "Bleu_HC": IDX_C1_BLEU_HC,
            "Blanc_HP": IDX_C1_BLANC_HP,
            "Blanc_HC": IDX_C1_BLANC_HC,
            "Rouge_HP": IDX_C1_ROUGE_HP,
            "Rouge_HC": IDX_C1_ROUGE_HC
        }
    }
}

JSON_FILE = "SCRIPTS_PATH/json/shelly_em1_state.json"
TEMPO_ACTIF_FILE = "SCRIPTS_PATH/json/tempo_actif.json"

UPDATE_INTERVAL = 5    # secondes pour power/total
TEMPO_FILE_CACHE_DURATION = 30  # secondes de cache pour tempo_actif.json

# Configuration du logging
LOG_FILE = "SCRIPTS_PATH/logs/shelly_em1.log"
os.makedirs(os.path.dirname(LOG_FILE), exist_ok=True)

file_handler = TimedRotatingFileHandler(
    LOG_FILE,
    when="midnight",
    interval=30,  # 30 jours
    backupCount=3,
    encoding='utf-8'
)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))

console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
console_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))

logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# ---------------- JSON State ----------------
def load_json() -> Dict:
    """Charge l'état persistant depuis le fichier JSON"""
    default_state = {
        "canaux": {}
    }
    
    # Initialiser chaque canal
    for canal_id in CANAUX.keys():
        default_state["canaux"][canal_id] = {
            "correction": {
                "last_hc_status": None,
                "last_color": None,
                "last_active_idx": None,
                "total_at_activation": 0,
                "tempo_at_activation": 0,
                "activation_timestamp": None
            },
            "pending_energy": {
                "enabled": False,
                "accumulated": 0.0,
                "count": 0,
                "start_timestamp": None
            }
        }
    
    if not os.path.exists(JSON_FILE):
        logger.info(f"Création du fichier d'état: {JSON_FILE}")
        save_json(default_state)
        return default_state
    
    try:
        with open(JSON_FILE, "r") as f:
            state = json.load(f)
            
        # Fusionner avec defaults si structure incomplète
        for canal_id in CANAUX.keys():
            if str(canal_id) not in state.get("canaux", {}):
                state.setdefault("canaux", {})[str(canal_id)] = default_state["canaux"][canal_id]
        
        logger.info(f"✓ Fichier d'état chargé: {JSON_FILE}")
        return state
        
    except Exception as e:
        logger.error(f"Erreur lors de la lecture de {JSON_FILE}: {e}")
        return default_state

def save_json(data: Dict) -> None:
    """Sauvegarde l'état dans le fichier JSON"""
    try:
        with open(JSON_FILE, "w") as f:
            json.dump(data, f, indent=2)
    except Exception as e:
        logger.error(f"Erreur lors de l'écriture de {JSON_FILE}: {e}")

# Cache pour tempo_actif.json
tempo_actif_cache = {
    "data": None,
    "timestamp": 0
}

def load_tempo_actif() -> Optional[Dict]:
    """
    Charge les données depuis tempo_actif.json avec système de cache
    """
    global tempo_actif_cache
    
    now = time.time()
    
    # Vérifier si le cache est encore valide
    if (tempo_actif_cache["data"] is not None and 
        now - tempo_actif_cache["timestamp"] < TEMPO_FILE_CACHE_DURATION):
        logger.debug("Utilisation du cache pour tempo_actif.json")
        return tempo_actif_cache["data"]
    
    # Charger depuis le fichier
    if not os.path.exists(TEMPO_ACTIF_FILE):
        logger.error(f"Fichier {TEMPO_ACTIF_FILE} introuvable")
        return None
    
    # Retry jusqu'à 3 fois (fichier peut être en cours d'écriture)
    max_retries = 3
    for attempt in range(max_retries):
        try:
            with open(TEMPO_ACTIF_FILE, "r") as f:
                data = json.load(f)
            break
        except json.JSONDecodeError as e:
            if attempt < max_retries - 1:
                logger.debug(f"Erreur JSON (tentative {attempt+1}/{max_retries}), retry dans 0.1s...")
                time.sleep(0.1)
            else:
                logger.error(f"Erreur parsing JSON après {max_retries} tentatives: {e}")
                return None
        except Exception as e:
            if attempt < max_retries - 1:
                logger.debug(f"Erreur lecture (tentative {attempt+1}/{max_retries}), retry dans 0.1s...")
                time.sleep(0.1)
            else:
                logger.error(f"Erreur lecture après {max_retries} tentatives: {e}")
                return None
    
    try:
        # Validation des données
        if not isinstance(data, dict):
            logger.error(f"Format invalide: doit être un objet JSON")
            return None
            
        if "HC" not in data or "CouleurJour" not in data:
            logger.error(f"Données manquantes: HC ou CouleurJour absent")
            return None
        
        # Vérifier que la couleur est valide
        valid_colors = ["Bleu", "Blanc", "Rouge", "Pas d'info"]
        if data["CouleurJour"] not in valid_colors:
            logger.error(f"Couleur invalide: {data['CouleurJour']}")
            return None
        
        if data["CouleurJour"] == "Pas d'info":
            logger.warning(f"⚠️  Couleur indisponible, accumulation en attente")
        
        # Vérifier que HC est valide
        valid_hc = ["On", "Off"]
        if data["HC"] not in valid_hc:
            logger.error(f"Statut HC invalide: {data['HC']}")
            return None
        
        # Vérifier la fraîcheur du Timestamp selon HC/HP
        if "Timestamp" in data and data["Timestamp"]:
            try:
                timestamp_str = data["Timestamp"]
                timestamp = datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S")
                now_dt = datetime.now()
                age_hours = (now_dt - timestamp).total_seconds() / 3600
                
                # Durées max identiques à apply_correction
                max_hc_hours = 8.25
                max_hp_hours = 16.25
                
                # Déterminer la durée max selon HC/HP
                hc_status = data.get("HC")
                if hc_status == "On":
                    max_hours = max_hc_hours
                    period_name = "HC"
                else:
                    max_hours = max_hp_hours
                    period_name = "HP"
                
                if age_hours > max_hours:
                    logger.warning(f"⚠️  JSON trop ancien: {age_hours:.1f}h (max {period_name}: {max_hours}h)")
                    logger.warning(f"⚠️  Timestamp: {timestamp_str}, maintenant: {now_dt.strftime('%Y-%m-%d %H:%M:%S')}")
                    data["_stale"] = True
                else:
                    logger.debug(f"Timestamp OK: {age_hours:.1f}h < {max_hours}h ({period_name})")
                    data["_stale"] = False
            except ValueError:
                logger.warning(f"⚠️  Format Timestamp invalide")
                data["_stale"] = True
        else:
            logger.warning(f"⚠️  Timestamp absent")
            data["_stale"] = True
        
        # Mettre à jour le cache
        tempo_actif_cache["data"] = data
        tempo_actif_cache["timestamp"] = now
        
        logger.debug(f"tempo_actif.json: HC={data['HC']}, Couleur={data['CouleurJour']}")
        return data
        
    except Exception as e:
        logger.error(f"Erreur validation: {e}")
        return None

state = load_json()

# ---------------- Récupération Counter Domoticz ----------------
def get_counter_from_domoticz(idx: int) -> float:
    """Récupère Counter (total) depuis Domoticz"""
    try:
        url = f"{DOMOTICZ_URL}/json.htm?type=command&param=getdevices&used=true&displayhidden=1"
        response = requests.get(url, auth=(DOMOTICZ_USER, DOMOTICZ_PASS), timeout=5)
        
        if response.status_code != 200:
            logger.error(f"Erreur HTTP {response.status_code} pour IDX {idx}")
            return 0
        
        data = response.json()
        for device in data.get("result", []):
            if str(device.get("idx")) == str(idx):
                counter_str = device.get("Counter", "0 kWh")
                counter_value = float(counter_str.split()[0])
                logger.debug(f"Counter IDX {idx}: {counter_value} kWh")
                return counter_value
        
        logger.warning(f"IDX {idx} non trouvé")
        return 0
        
    except Exception as e:
        logger.error(f"Erreur récupération Counter IDX {idx}: {e}")
        return 0

def get_counter_today_from_domoticz(idx: int) -> float:
    """Récupère CounterToday depuis Domoticz"""
    try:
        url = f"{DOMOTICZ_URL}/json.htm?type=command&param=getdevices&used=true&displayhidden=1"
        response = requests.get(url, auth=(DOMOTICZ_USER, DOMOTICZ_PASS), timeout=5)
        
        if response.status_code != 200:
            logger.error(f"Erreur HTTP {response.status_code} pour IDX {idx}")
            return 0
        
        data = response.json()
        for device in data.get("result", []):
            if str(device.get("idx")) == str(idx):
                counter_today_str = device.get("CounterToday", "0 kWh")
                counter_today_value = float(counter_today_str.split()[0])
                logger.debug(f"CounterToday IDX {idx}: {counter_today_value} kWh")
                return counter_today_value
        
        logger.warning(f"IDX {idx} non trouvé")
        return 0
        
    except Exception as e:
        logger.error(f"Erreur récupération CounterToday IDX {idx}: {e}")
        return 0

# ---------------- Correction automatique ----------------
def apply_correction(canal_id: int, old_idx: int, total_debut: float, total_fin: float, current_hc_status: str) -> None:
    """
    Applique correction sur le compteur Tempo qui vient de se terminer
    Protection : vérifie durée (HC: 8h15, HP: 16h15) et même jour pour HP
    Valeurs en Wh
    """
    canal_state = state["canaux"][str(canal_id)]
    tempo_debut = canal_state["correction"]["tempo_at_activation"]
    tempo_fin_kwh = get_counter_from_domoticz(old_idx)
    tempo_fin = tempo_fin_kwh * 1000  # kWh → Wh
    
    if tempo_fin_kwh == 0:
        logger.warning(f"[Canal {canal_id}] Impossible récupérer Counter IDX {old_idx}")
        return
    
    if tempo_debut == 0:
        logger.info(f"[Canal {canal_id}] Premier cycle après démarrage IDX {old_idx}")
    
    # Vérifier cohérence temporelle
    activation_timestamp = canal_state["correction"].get("activation_timestamp")
    last_hc_status = canal_state["correction"].get("last_hc_status")
    
    if activation_timestamp:
        try:
            activation_time = datetime.fromisoformat(activation_timestamp)
            current_time = datetime.now()
            elapsed_hours = (current_time - activation_time).total_seconds() / 3600
            
            max_hc_hours = 8.25
            max_hp_hours = 16.25
            
            if last_hc_status == "On":
                max_hours = max_hc_hours
                period_name = "HC"
            else:
                max_hours = max_hp_hours
                period_name = "HP"
                # HP : vérifier même jour
                if activation_time.date() != current_time.date():
                    logger.warning(f"[Canal {canal_id}] Période HP sur jours différents")
                    logger.info(f"[Canal {canal_id}] Cycle ignoré: {elapsed_hours:.1f}h")
                    return
            
            if elapsed_hours <= max_hours:
                logger.debug(f"[Canal {canal_id}] Validation OK: {period_name} {elapsed_hours:.1f}h")
            else:
                logger.warning(f"[Canal {canal_id}] Période {period_name} trop longue: {elapsed_hours:.1f}h")
                logger.info(f"[Canal {canal_id}] Cycle ignoré")
                return
                
        except Exception as e:
            logger.error(f"[Canal {canal_id}] Erreur validation: {e}")
    
    # Calculer correction
    delta_total = total_fin - total_debut
    delta_tempo = tempo_fin - tempo_debut
    correction = delta_total - delta_tempo
    
    # Seuil minimal : 1 Wh
    if abs(correction) > 1.0:
        logger.info(f"[Canal {canal_id}] 🔧 CORRECTION IDX {old_idx}: Δtotal={delta_total:.1f} Wh, Δtempo={delta_tempo:.1f} Wh, correction={correction:+.1f} Wh")
        if send_domoticz(old_idx, 0, f"{correction:.1f}"):
            logger.info(f"[Canal {canal_id}] ✓ Correction appliquée IDX {old_idx}")
            stats["domoticz_updates"] += 1
        else:
            logger.error(f"[Canal {canal_id}] ✗ Échec correction IDX {old_idx}")
            stats["errors"] += 1
    else:
        logger.debug(f"[Canal {canal_id}] Correction négligeable: {correction:+.1f} Wh")

# ---------------- Envoi Domoticz ----------------
def send_domoticz(idx: int, nvalue: int, svalue: str, retry: int = 3) -> bool:
    """Envoie une mise à jour à Domoticz avec retry"""
    url = f"{DOMOTICZ_URL}/json.htm?type=command&param=udevice&idx={idx}&nvalue={nvalue}&svalue={svalue}"
    
    for attempt in range(retry):
        try:
            response = requests.get(url, auth=(DOMOTICZ_USER, DOMOTICZ_PASS), timeout=5)
            if response.status_code == 200:
                logger.debug(f"Domoticz: IDX={idx} svalue={svalue}")
                return True
            else:
                logger.warning(f"Domoticz HTTP {response.status_code} IDX={idx}")
        except requests.exceptions.Timeout:
            logger.warning(f"Timeout ({attempt+1}/{retry}) IDX={idx}")
        except requests.exceptions.ConnectionError:
            logger.warning(f"Connexion error ({attempt+1}/{retry}) IDX={idx}")
        except Exception as e:
            logger.error(f"Erreur Domoticz IDX={idx}: {e}")
        
        if attempt < retry - 1:
            time.sleep(0.5)
    
    return False

# ---------------- Calcul IDX actif ----------------
def get_active_idx(canal_id: int) -> Optional[int]:
    """Calcule l'IDX actif Tempo pour un canal"""
    tempo_data = load_tempo_actif()
    
    if tempo_data is None:
        return None
    
    # Vérifier si données périmées
    if tempo_data.get("_stale", False):
        logger.debug(f"[Canal {canal_id}] Données trop anciennes")
        return None
    
    tempo_color = tempo_data.get("CouleurJour")
    hc_status = tempo_data.get("HC")
    
    if tempo_color == "Pas d'info":
        logger.debug(f"[Canal {canal_id}] Couleur = Pas d'info")
        return None
    
    if tempo_color is None or hc_status is None:
        return None
    
    # Mapping couleur+HP/HC → IDX
    is_hc = str(hc_status).lower() == "on"
    
    mapping = {
        "Bleu": CANAUX[canal_id]["IDX_TEMPO"]["Bleu_HC"] if is_hc else CANAUX[canal_id]["IDX_TEMPO"]["Bleu_HP"],
        "Blanc": CANAUX[canal_id]["IDX_TEMPO"]["Blanc_HC"] if is_hc else CANAUX[canal_id]["IDX_TEMPO"]["Blanc_HP"],
        "Rouge": CANAUX[canal_id]["IDX_TEMPO"]["Rouge_HC"] if is_hc else CANAUX[canal_id]["IDX_TEMPO"]["Rouge_HP"]
    }
    
    active_idx = mapping.get(tempo_color)
    
    if active_idx is None:
        logger.warning(f"[Canal {canal_id}] Couleur inconnue: {tempo_color}")
    
    return active_idx

# Variables globales par canal
canal_data = {}
for canal_id in CANAUX.keys():
    canal_data[canal_id] = {
        "power": None,
        "total": None,
        "energy": None,
        "total_sync": None,
        "correction_applied": False,
        "last_daily_reset_date": None,
        "last_update": 0
    }

last_watchdog = 0

# Statistiques globales
stats = {
    "mqtt_messages": 0,
    "domoticz_updates": 0,
    "errors": 0,
    "start_time": time.time()
}

# ---------------- MQTT Callbacks ----------------
def on_message(client, userdata, msg):
    """Callback appelé lors de la réception d'un message MQTT"""
    global last_watchdog, stats
    
    topic = msg.topic
    payload_raw = msg.payload.decode()
    
    try:
        payload = float(payload_raw)
    except ValueError:
        logger.debug(f"Payload non numérique ignoré: {topic} = {payload_raw}")
        return
    
    stats["mqtt_messages"] += 1
    logger.debug(f"MQTT: {topic} = {payload}")
    
    # Déterminer le canal depuis le topic
    canal_id = None
    for cid, config in CANAUX.items():
        if config["topic"] in topic:
            canal_id = cid
            break
    
    if canal_id is None:
        logger.warning(f"Topic inconnu: {topic}")
        return
    
    cd = canal_data[canal_id]
    
    # Extraire le type de message
    if topic.endswith("/power"):
        cd["power"] = payload
    elif topic.endswith("/total"):
        cd["total"] = payload
    elif topic.endswith("/energy"):
        cd["energy"] = payload
    
    now = time.time()
    
    # ----- Compteurs simples -----
    if cd["power"] is not None and cd["total"] is not None and now - cd["last_update"] >= UPDATE_INTERVAL:
        if send_domoticz(CANAUX[canal_id]["IDX_SIMPLE"], 0, f"{cd['total']}"):
            stats["domoticz_updates"] += 1
        else:
            logger.error(f"[Canal {canal_id}] ✗ Échec envoi total IDX={CANAUX[canal_id]['IDX_SIMPLE']}")
            stats["errors"] += 1
            
        if send_domoticz(CANAUX[canal_id]["IDX_COMPUTED"], 0, f"{cd['power']};0"):
            stats["domoticz_updates"] += 1
        else:
            logger.error(f"[Canal {canal_id}] ✗ Échec envoi power IDX={CANAUX[canal_id]['IDX_COMPUTED']}")
            stats["errors"] += 1
            
        cd["last_update"] = now
    
    # ----- Compteurs Tempo -----
    if cd["energy"] is not None and topic.endswith("/energy"):
        # Synchroniser total avec energy
        if cd["total"] is not None:
            cd["total_sync"] = cd["total"]
            logger.debug(f"[Canal {canal_id}] Sync: total_sync={cd['total_sync']} Wh")
        
        # Charger infos tempo
        tempo_data = load_tempo_actif()
        current_hc_status = None
        current_color = None
        
        canal_state = state["canaux"][str(canal_id)]
        
        if tempo_data is not None:
            current_hc_status = tempo_data.get("HC")
            current_color = tempo_data.get("CouleurJour")
            
            # Détecter changement HC/HP
            if canal_state["correction"]["last_hc_status"] is not None and \
               canal_state["correction"]["last_hc_status"] != current_hc_status:
                
                logger.info(f"[Canal {canal_id}] 🔄 Changement: {canal_state['correction']['last_hc_status']} → {current_hc_status}")
                
                # Appliquer correction
                old_idx = canal_state["correction"]["last_active_idx"]
                
                if old_idx is not None:
                    total_debut = canal_state["correction"]["total_at_activation"]
                    total_fin = cd["total_sync"] if cd["total_sync"] is not None else cd["total"]
                    
                    if total_fin is not None:
                        apply_correction(canal_id, old_idx, total_debut, total_fin, current_hc_status)
                        cd["correction_applied"] = True
                    else:
                        logger.error(f"[Canal {canal_id}] Impossible correction: pas de total")
        
        active_idx = get_active_idx(canal_id)
        
        if active_idx is not None:
            # Vérifier valeurs en attente
            if canal_state["pending_energy"]["enabled"]:
                accumulated = canal_state["pending_energy"]["accumulated"]
                count = canal_state["pending_energy"]["count"]
                logger.info(f"[Canal {canal_id}] ✅ Envoi valeurs accumulées: {accumulated:.4f} Wh ({count} mesures)")
                
                if send_domoticz(active_idx, 0, f"{accumulated:.4f}"):
                    logger.info(f"[Canal {canal_id}] ✓ Valeurs accumulées envoyées IDX {active_idx}")
                    stats["domoticz_updates"] += 1
                    
                    # Réinitialiser
                    canal_state["pending_energy"]["enabled"] = False
                    canal_state["pending_energy"]["accumulated"] = 0.0
                    canal_state["pending_energy"]["count"] = 0
                    canal_state["pending_energy"]["start_timestamp"] = None
                else:
                    logger.error(f"[Canal {canal_id}] ✗ Échec envoi valeurs accumulées")
                    stats["errors"] += 1
            
            # Enregistrer nouvelles valeurs si changement
            if current_hc_status is not None and (
                canal_state["correction"]["last_hc_status"] != current_hc_status or
                canal_state["correction"]["last_active_idx"] != active_idx
            ):
                # Récupérer Counter actuel
                counter_value = get_counter_from_domoticz(active_idx)
                
                canal_state["correction"]["last_hc_status"] = current_hc_status
                canal_state["correction"]["last_color"] = current_color
                canal_state["correction"]["last_active_idx"] = active_idx
                total_value = cd["total_sync"] if cd["total_sync"] is not None else cd["total"]
                canal_state["correction"]["total_at_activation"] = total_value if total_value is not None else 0
                canal_state["correction"]["tempo_at_activation"] = counter_value * 1000  # kWh → Wh
                canal_state["correction"]["activation_timestamp"] = datetime.now().isoformat()
                
                if cd["total_sync"] is not None:
                    logger.info(f"[Canal {canal_id}] 📍 Nouveau cycle: IDX {active_idx}, Total_sync={cd['total_sync']:.1f} Wh")
                else:
                    logger.warning(f"[Canal {canal_id}] 📍 Nouveau cycle: IDX {active_idx}, Total={cd['total']:.1f} Wh")
            
            # Conversion energy en Wh
            energy_wh = cd["energy"] / 60
            
            # Reset 00h01
            current_time = datetime.now()
            current_date = current_time.strftime("%Y-%m-%d")
            is_reset_time = (current_time.hour == 0 and current_time.minute == 1 and 
                           cd["last_daily_reset_date"] != current_date)
            
            if is_reset_time:
                cd["last_daily_reset_date"] = current_date
                logger.info(f"[Canal {canal_id}] 🔄 00h01 - Début reset CounterToday")
            
            for name, idx in CANAUX[canal_id]["IDX_TEMPO"].items():
                if idx == active_idx:
                    # Ne pas envoyer energy_wh si correction appliquée (déjà inclus)
                    if cd["correction_applied"]:
                        logger.debug(f"[Canal {canal_id}] Pas d'envoi energy (inclus correction)")
                    else:
                        if send_domoticz(idx, 0, f"{energy_wh:.4f}"):
                            stats["domoticz_updates"] += 1
                        else:
                            stats["errors"] += 1
                else:
                    # Ne pas envoyer 0 si correction appliquée
                    if cd["correction_applied"]:
                        logger.debug(f"[Canal {canal_id}] Pas de 0 (protection correction)")
                        break
                    # Reset 00h01
                    elif is_reset_time:
                        counter_today_kwh = get_counter_today_from_domoticz(idx)
                        if counter_today_kwh != 0:
                            compensation_wh = -counter_today_kwh * 1000
                            logger.info(f"[Canal {canal_id}]    └─ Reset {name} (IDX={idx}): {counter_today_kwh:.3f} kWh → {compensation_wh:.1f} Wh")
                            if send_domoticz(idx, 0, f"{compensation_wh:.1f}"):
                                stats["domoticz_updates"] += 1
                            else:
                                stats["errors"] += 1
                    else:
                        if send_domoticz(idx, 0, "0"):
                            stats["domoticz_updates"] += 1
                        else:
                            stats["errors"] += 1
            
            # Réinitialiser flag correction
            if cd["correction_applied"]:
                logger.info(f"[Canal {canal_id}] ✓ Protection correction: reprise normale")
                cd["correction_applied"] = False
            
            save_json(state)
        else:
            # Accumulation si couleur indisponible
            energy_wh = cd["energy"] / 60
            
            if not canal_state["pending_energy"]["enabled"]:
                logger.warning(f"[Canal {canal_id}] ⏳ Début accumulation: {energy_wh:.4f} Wh")
                canal_state["pending_energy"]["enabled"] = True
                canal_state["pending_energy"]["accumulated"] = energy_wh
                canal_state["pending_energy"]["count"] = 1
                canal_state["pending_energy"]["start_timestamp"] = datetime.now().isoformat()
            else:
                canal_state["pending_energy"]["accumulated"] += energy_wh
                canal_state["pending_energy"]["count"] += 1
                logger.info(f"[Canal {canal_id}] ⏳ Accumulation: +{energy_wh:.4f} Wh → Total: {canal_state['pending_energy']['accumulated']:.4f} Wh ({canal_state['pending_energy']['count']} mesures)")
            
            save_json(state)
        
        # Réinitialiser energy
        cd["energy"] = None
    
    # Watchdog systemd
    if SYSTEMD and now - last_watchdog >= 2:
        notify("WATCHDOG=1")
        last_watchdog = now

def on_connect(client, userdata, flags, rc):
    """Callback lors de la connexion MQTT"""
    if rc == 0:
        logger.info("✓ Connecté au broker MQTT")
        for canal_id, config in CANAUX.items():
            topic = f"{config['topic']}/#"
            client.subscribe(topic)
            logger.info(f"✓ Souscription canal {canal_id}: {topic}")
    else:
        logger.error(f"✗ Échec connexion MQTT, code: {rc}")

def on_disconnect(client, userdata, rc):
    """Callback lors de la déconnexion MQTT"""
    logger.warning(f"⚠️  Déconnexion MQTT, code: {rc}")

def on_subscribe(client, userdata, mid, granted_qos):
    """Callback confirmation souscription"""
    logger.info(f"Souscription confirmée, QoS: {granted_qos}")

def print_stats():
    """Affiche les statistiques"""
    uptime = int(time.time() - stats["start_time"])
    logger.info("=" * 50)
    logger.info(f"STATISTIQUES - Uptime: {uptime}s")
    logger.info(f"Messages MQTT reçus: {stats['mqtt_messages']}")
    logger.info(f"Mises à jour Domoticz: {stats['domoticz_updates']}")
    logger.info(f"Erreurs: {stats['errors']}")
    logger.info("=" * 50)

# ---------------- Main ----------------
def main():
    """Fonction principale"""
    logger.info("=" * 50)
    logger.info("Démarrage du script Shelly EM - 2 canaux")
    logger.info("=" * 50)
    logger.info(f"Broker MQTT: {MQTT_BROKER}:{MQTT_PORT}")
    logger.info(f"Shelly ID: {SHELLY_ID}")
    logger.info(f"URL Domoticz: {DOMOTICZ_URL}")
    logger.info(f"Canaux configurés: {list(CANAUX.keys())}")
    logger.info(f"Fichier tempo: {TEMPO_ACTIF_FILE}")
    logger.info("=" * 50)
    
    # Client MQTT
    client = mqtt.Client()
    client.on_connect = on_connect
    client.on_message = on_message
    client.on_disconnect = on_disconnect
    client.on_subscribe = on_subscribe
    
    # Stats périodiques (toutes les heures)
    last_stats = time.time()
    
    try:
        logger.info("Connexion au broker MQTT...")
        client.connect(MQTT_BROKER, MQTT_PORT, 60)
        
        if SYSTEMD:
            notify("READY=1")
            logger.info("✓ Signal READY=1 envoyé à systemd")
        
        logger.info("✓ Démarrage de la boucle principale")
        
        # Boucle principale non-bloquante
        client.loop_start()
        
        while True:
            time.sleep(60)
            
            # Afficher stats toutes les heures
            if time.time() - last_stats >= 3600:
                print_stats()
                last_stats = time.time()
        
    except KeyboardInterrupt:
        logger.info("Arrêt demandé par l'utilisateur")
    except Exception as e:
        logger.error(f"Erreur fatale: {e}")
    finally:
        client.loop_stop()
        client.disconnect()
        logger.info("Script arrêté")

if __name__ == "__main__":
    main()