Commander un poêle à granulés MCZ

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

  • Picoscope
  • Emetteur et recepteur 433 MHz
    Lien Aliexpress
  • Arduino UNO
  • Home assistant sur Raspberry Pi 4

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
    • 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 !

Personnellement, j’utilise Pilight pour le 433mhz :
https://pilight.org/

Par contre, je suis passé sur Docker pour pouvoir installer le serveur sur le Rpi et HA dans Docker.

Tu peux commencer par regarder pour passer en installation Supervised (une petite recherche sur le forum te permettra de trouver un tuto pour le Rpi4) afin de garder le Superviseur mais avoir un RaspiOS et donc utiliser tous les outils que tu souhaites. → C’est une piste pas une recommandation :wink:

J’ai découvert ce code sur :
http://blog.idleman.fr/raspberry-pi-10-commander-le-raspberry-pi-par-radio/

Et avant l’utilisation de Pilight (qui contient plusieurs protocoles, vérifie si le tien y est :+1:), j’utilisais son programme en cpp compilé avec HA en utilisant l’intégration :

Salut @Clemalex ,

Merci pour ces infos, je vais faire quelques recherches sur le passage en Docker, ca fait un moment que j’y pense mais j’ai encore du mal à voir les effets de bords.

Peux tu m’en dire un peu plus par rapport à ton passage en docker ? Je n’ai pas les idées claires sur les différents types d’installations d’HA. Que contient le serveur que tu as installé sur le RPi ?

Une fois l’installation sou docker faite je pourrais par exemple via HA lancer un script en python stocké directement sur le linux ? (Ce qui me permettrait d’utiliser les librairies du genre « GPIO » et tout le reste … ? )

Je garde dans un coin de la tête l’intégration Pilight, j’en avait entendu parler mais ca me paraissait assez lourd pour une simple commande de port GPIO, à voir donc, si je ne m’en sort pas ca reste une option !

Merci encore !

Ça depends sur quelle type d’installation tu pars :

La méthode que j’utilise est la méthode Docker et donc sans add-ons.

La méthode pour les débutants et la simplicité est la méthode OS (pour les add-ons surtout) .

Toi dans ton cas, je pense qu’il faut que tu utilise soit la méthode Container (sans add-ons) soit la méthode Supervised (avec add-ons).
C’est deux solutions permettent d’avoir un Debian OS et donc de profiter de tous les programmes disponibles sous cette distribution.

Avec les deux installations dont je te parles, oui, tu pourras utiliser tout ce qui est disponible dans ta distribution en utilisant l’intégration CommandLine citée dans mon précédent post.

Le serveur Pilight permet de gérer une masse de protocole en 433mhz et potentiellement le tiens.

Je sais que celui que j’utilise (chacon, dio, intertechno) sont aussi en Manchester, à voir si avec ton matériel c’est compatible.

Ensuite,le serveur HA viens s’abonner au serveur Pilight, afin que, depuis HA, tu fasse la définition du code et demande au serveur Pilight de l’envoyer.

Tu peux aussi, via HA accéder à l’interface web du serveur Pilight et envoyer des codes directement sur le serveur.

Actuellement, mon serveur Pilight est sur un Pi2 et HA sur un Pi4, et ça fonctionne très bien depuis +2ans.

Je m’en sers pour ouvrir/fermer le garage et le portail (pieton ou voiture) et les lampes.

Je n’utilise pas le retour d’état car j’ai des capteurs zigbee pour les detections d’ouvertures et de luminosité.

hello
Regarde également du côté Rflink sur arduino mega.
c’est très puissant pour une utilisation en 433mHz

Je commence mon benchMark pour prendre une décision, une chose est claire c’est que l’accès direct aux commandes linux me parait essentiel pour la suite, je vais donc installer HA en docker dans les jours à venir.

  • De ce que j’ai pu lire je pense partir sur une distribution Debian (Raspbian) qui semble être la seule distribution pour laquelle HA est maintenu et donc celle qui poserai à priori le moins de problèmes.
  • Quels sont les avantages / inconvénients des méthodes docker supervisé/non supervisé ?
    • J’ai lu quelques commentaires assez négatifs sur la stabilité du supervisor en docker, si certains utilisent cette config sous Raspbian pouvez vous nous faire un petit retour ?
  • As-tu une vague idée du temps qu’il faut pour passer mon installation OS en docker ? J’aurai la possibilité de recharger une sauvegarde de mon installation actuelle ou il faut repartir de zéro (les fichiers de configurations, les dashboards lovelace, les configurations des capteurs zigbee via deCONZ, les automatisations etc… ) ?
  • Je vais peut être faire le passage sous docker sur une autre micro SD afin de pouvoir revenir facilement à mon installation actuelle le temps de rendre l’installation sous docker complètement fonctionnelle.

Salut @galley-dev , oui j’ai aussi vu cette solution mais je trouve ca dommage d’ajouter un montage Arduino alors que le Raspberry est très bien pré-disposé à faire ca… et puis il faut le dire, j’apprends pas mal de choses en essayant de coder ça par moi même et j’aime bien l’idée du script python qui m’ouvrira un grand champs des possibles pour pleins d’autres projets si jamais j’arrive à mes fins :slight_smile: Mais bien-sûre je garde en têtes toutes vos bonnes idées, Pilight ou le montage RFLink seront des supers backups si je galère trop avec mes scripts.

Salut pour répondre a quelques questions ci-dessus.

  • Raspbian sur rpi est un bon choix pense juste a prendre une 64 bits si tu veux installer HA en 64bits ( utile su tu as olus de 4 Go de ram et si tu veux l’addon Visual Studio Code)

  • Différences entre l’installation containers ou supervised ? Qu’entends tu par supervised et docker. Car il y a la méthode docker supervised et il y a aussi la méthode docker ou tu gères toi même l’installation de tes container.

  • Perso j’ai aucun problème sur mon rpi 4 raspbian 64bits et l’installation via le lien du dessus en docker supervised.

  • Pour le temps d’installation cela dépend de ta connexion mais moi en connexion vdsl je mets moins de 20 minutes. Ta sauvegarde marchera sans soucis.

  • Oui tu peux faire sur un autre support pour plus de sécurité car des fois les sauvegardes sont corrompus surtout la BDD.

Salut @McFly et merci pour ces éléments de réponse,

De mon côté j’ai bien avancé, j’ai installé la version docker sans supervisor.

  • Pour la récupération de mes config je n’ai plus le supervisor, donc plus d’accès au sauvegardes classiques, j’ai donc installé samba directement sur la debian puis j’ai rapidement réussi à copier/coller mes fichiers de config, mon lovelace, etc…
  • La partie DNS et accès à HA depuis l’extérieur m’a posé quelques soucis, la différence subtile réside dans le https://… de HA OS contre le http://… de HA en docker…
  • Instalation de deCONZ en docker, ré-appairage de tout les devices…

Bref, il n’y avait pas grand chose à faire pour retrouver une installation fonctionnelle mais l’acclimatation à cette nouvelle gestion de HA pour le novice que je suis aura tout de même été un beau parcours semé d’embuches !

Je referme donc la parenthèse « installation HA en docker » :hot_face: pour reprendre le sujet « Commander un poêle à granulés MCZ » :star_struck:

…La suite dans le prochain épisode …

Bonjour,

Voilà quelques nouvelles de mon projet qui avance bien !

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 !