Commander un poêle à granulés MCZ

Entraide Home Assistant
1

Bonjour à tous,

Je me lance dans ce nouveau projet: piloter mon poêle MCZ de A à Z via Home Assistant.

Principales caractéristiques du poêle:

  • Protocole de communication: RF 433 MHz
  • Installation initiale: pilotage via la télécommande MCZ
  • Modes de pilotage:
    • 1: manuel: allumage / extinction / niveau de puissance / niveau de ventilation manuel
    • 2: automatique: allumage / extinction définis par des plages horaires, régulation puissance et ventilation automatique en fonction de la température (sonde de température intégrée à la télécommande)
    • 3: auto-ECO: allumage / extinction / niveau de puissance / niveau de ventilation automatique en fonction de la température
  • La partie soft pour les différentes régulations est intégrée à la télécommande

Matériel

Plan de bataille:

  • Pilotage en mode manuel via Home assistant
    • Récupérer les trames émises par la télécommande (picoscope + récepteur 433 MHz)
    • décodage et reconstruction du signal pour émission (Matlab)
    • Envoyer le signal reconstruit via un Arduino pour vérification [Arduino + émetteur 433 MHz)
    • Intégration sur Home assistant avec pilotage d’un émetteur 433 MHz via les ports GPIO du Raspberry supportant Home assistant
  • Pilotage en mode auto-ECO via Home assistant
    • Automatisation des stratégies de régulation en fonction de:
      • Températures pièces et extérieur
      • Présence dans la maison

Avancement:

  • Récupération des trames à l’aide d’un picoscope connecté au récepteur 433 MHz → OK
  • Décodage et reconstruction du signal → OK
    • MCZ utilise un code Manchester avec les caractéristiques suivantes:
      • 1 trame répétée 5 fois
      • Les trames sont séparées par 9 bit à 0 (000000000)
      • Chaque trame contient 7 messages de 24 bit (12 bit Manchester)
      • Chaque message est précédé par une synchronisation sur 3 bit (011)
      • Le PulseLength est de 415 microseconde
        Voici un exemple pour une trame de 7 messages:
        image
  • Test via Arduino → OK
    • Les codes reconstruit envoyés sur le transmetteur via l’Arduino permette bien de commander le poêle

J’en suis maintenant à l’étape tant attendue de l’intégration sous Home Assistant, et je galère !
L’objectif est bien de commander le poêle via l’émetteur, lui même commandé en envoyant les code via les sorties GPIO du Raspberry Pi 4 utilisé pour hébergé Home assistant.

  • J’ai commencé par m’intéresser à la platform rpi_rf
    • Celle-ci permet de transmettre des codes radio, les codes sont rentrés en décimale et la platforme transforme ces codes selon un protocole définit comme ceci (ici):
      image
    • 6 protocoles préétablis sont proposés:
      image
    • Les options proposées par la platform rpi_rf sont les suivantes:
      image
      image656×503 10.8 KB
    • Pour emmètre un code correspondant à mon besoin, le protocole adapté serait donc:
      • pulselength: 415
      • sync_low: 1 / sync_high: 2
      • zero_low: 1 / zero_high: 1
      • one_high: 1 / one_low: 1
    • Autant dire que rien ne va, ce protocole n’est pas proposé et la platforme ne permet pas d’adapté l’ensemble des paramètres. De plus, il faudrait aussi pouvoir indiquer le sens de commande (low/high pour un bit Manchester 0 et high/low pour un bit Manchester à 1) mais ce paramètre n’est pas pris en charge…
    • … Cependant je ne perd pas totalement espoir avec cette solution car en fouillant un peu dans le GitHub j’ai vu que le code était très complet et suffisamment flexible pour faire le job, malheureusement je ne sais absolument pas comment exploité ce code autrement que via la platform rpi_rf qui elle limite beaucoup les possibilités…
    • J’ai tout de même tenté d’intégrer la partie du script qui m’intéresse dans un python script mais l’intégration python script d’Home Assistant est encore une fois trèèèss restrictive et ne permet pas l’importation de la bibliothèque nécessaire pour commander directement les ports GPIO:
from RPi import GPIO
  • La seconde option : platform rpi_gpio
    • Cette platforme permet de piloter les sorties GPIO du Raspberry, l’idée serait donc de
      • Créer un switch
      • Créer un script pour piloter ce switch 
length_pulse = 415/1000000
code="0111001100110010...10100110010101011"
for bit in code:
    if bit== "1":
        hass.services.call('switch', 'turn_on', { 'entity_id': 'switch.emeteur_radio_433'}, False)
        time.sleep(length_pulse)
    elif bit== "0":
        hass.services.call('switch', 'turn_off', { 'entity_id': 'switch.emeteur_radio_433'}, False)
        time.sleep(length_pulse)
hass.services.call('switch', 'turn_off', { 'entity_id': 'switch.emeteur_radio_433'}, False)
time.sleep(1)

Malheureusement je me suis confronté à une nouvelle difficulté, chaque requête de service nécessite environ 5 ms … hors on souaite envoyé un code cadencé à 5 us … 1000 fois plus vite que l’envoi d’une seule requête :sweat_smile:

En fouillant un peu dans le GitHub j’ai vu que le code associé à rpi_gpio est très simpliste et ne me permettra pas de faire ce que je veux…

Mes interrogations
Connaissez vous un moyens d’envoyer des commandes sur les ports GPIO à une fréquence élevée (> 1/0.000415 Hz) ?
Je pense qu’il faut trouver un moyen d’attaquer directement le port GPIO, sans passer par Home Assistant pour chaque commande High/low car trop lent. Malheureusement pour moi l’encapsulation de l’OS Hassio dans le Raspberry est encore une blackbox, les commandes linux autorisées sur Hassio ont l’air d’être très limitées aussi…
En tout cas on est très loin des limites matériel, le RPi est largement capable de générer ce signal, un Arduino nano y arrive sans problème :slight_smile:

Toutes mes excuses pour le pavé mais ca m’a aussi permis de rassembler pas mal d’infos qui je pense pourront aider la communauté.

Merci d’avance pour vos réponses !

2

Bonjour,
Je possède également un insert à granulés MCZ.

Je suis très intéressé par vos travaux.

J’ai une rfxcom, qui semble être le protocole de mcz.

De votre côté, avez vous résolu vos problèmes de vitesse ?

3

Bonjour,

Voilà quelques nouvelles de mon projet qui a bien avancé !

J’ai créé ce petit script Python cmd_mcz.py pour lancer les différentes commandes au poêle:

import sys
import RPi.GPIO as GPIO
import time

pin = 11
GPIO.setmode(GPIO.BOARD)
GPIO.setup(pin, GPIO.OUT)

request = sys.argv[1]
print(request)
pulselength=0.00035

cmd_start = [1,1,1,1, ... ,1,0,1,0,1,1]
cmd_stop  = [1,1,1,1, ... ,0,0,1,1,0,1]
cmd_P1    = [1,1,1,1, ... ,1,0,1,0,1,1]
cmd_P2    = [1,1,1,1, ... ,0,0,1,1,0,1]
...

if request == 'start':
    code=cmd_start
elif request == 'stop':
    code=cmd_stop
elif request == 'P1':
    code=cmd_P1
elif request == 'P2':
    code=cmd_P2
elif ...

for i in code:
#    print (i)
    if i==0:
        GPIO.output(pin,0)
        time.sleep(pulselength)
    elif i==1:
        GPIO.output(pin,1)
        time.sleep(pulselength)

GPIO.output(pin,0)

J’ai placé celui-ci dans le dossier python_scripts du docker homeassistant

J’exécute ensuite ce script directement via homeassistant avec la plateforme command_line

#configuration.yaml
switches:
  - platform: command_line
    switches:
  	cmd_line_mcz:
	  command_on: python3 /config/python_scripts/cmd_mcz.py 'start'
	  command_off: python3 /config/python_scripts/cmd_mcz.py 'stop'

… Dnas mon premier message j’avais parlé d’un temps d’impulsion de 415 us, cependant le Raspberry semble mal cadencé, ou certaines opération son « lentes », leur temps d’exécution devient significatif (j’ai surement du rater quelque chose …) et les impulsions de 415 us ne permettaient pas de communiquer avec le poêle. Dans le doute, j’ai balayé une plage un peu plus large et je suis tombé sur 350 us qui fonctionne à la perfection :slight_smile:

NeverSurrender

Je suis maintenant capable d’allumer / éteindre, augmenter / diminuer la puissance et la ventilation du poêle ! Il ne me reste « plus qu’à » faire une gestion correcte pour un mode auto basé sur deux ou trois capteur de température, des détections de présence, des modes workday / Weekend / télétravail etc…

Si vous avez des idées, template, intégration, card lovelace qui pourraient me faciliter la vie pour cette dernière étape n’hésitez pas à partager !

4

Super boulot!!! Je possède un MCZ Musa qui fonctionne toujours avec la radiocommande mangeuse de pile… et qui m’énerve au plus haut point.
Votre travail m’intéresse beaucoup étant donné que j’utilise aussi Home Assistant sur RPI4, mais la j’avoue que ce que j’ai pu lire de votre sujet est très flou pour moi.