Le Blog de C-quad

Archive pour la catégorie ‘Domotique’

Domotiser un poêle à granulés ( partie 2 : Le code )

Nous avons vu dans un précédent article le montage électronique pour contrôler le poêle grâce à un raspberry et un potentiomètre digital. Nous allons voir maintenant le code utilisé pour cela.

Nous allons avoir 2 processus qui tournent en tache de fond :

  • L’alimentation en continu de la température en faisant varier la résistance du potentiomètre digital.
  • L’interface web qui me permettra de piloter tout cela.

J’ai choisi de tout programmer en python pour diverses raisons. La principale étant que je ne connais pas et que le meilleur moyen d’apprendre est d’avoir quelque chose de concret à réaliser. Il se peut donc qu’il y ai des améliorations à apporter au code qui vous sera présenté ci dessous.

Communication avec le potentiomètre digital

Le potentiomètre digital choisi est le MCP4162. Voici la datasheet de ce potentiomètre.

Comme vous pourrez le constater, ce potentiomètre communique via SPI. J’ai choisi d’utiliser la librairie python spidev.

import spidev

# Ouverture du bus SPI
spi = spidev.SpiDev()
spi.open(0,0) # car j'utilise la pin CE0: serait spi.open(0,1) si j'utilisais la pin CE1

# Transfert de la temperature (plus exactement un pas sur le digipot)
resp = spi.xfer2([0, index])

Dans notre cas, le potentiomètre digital possède 256 valeur de 0 à 255, index prendra l’une de ces 256 valeurs.

Ce qui donne le code complet :

!/usr/bin/python
# -*- coding: utf-8 -*-
 
import spidev
import time
import urllib2
import json

# Ouverture du bus SPI
spi = spidev.SpiDev()
spi.open(0,0) # car j'utilise la pin CE0: serait spi.open(0,1) si j'utilisais la pin CE1

coeff = 0.087
TEMP_OFF = 25
CONSIGNE_POELE = 19

try:
    while True :
        content = urllib2.urlopen("http://ip_raspberry:5000/status").read()
        d = json.loads(content)    
        print d
        if d[u'Etat'] == u'off' :
            print "poele eteint"
            index = 0
        else :
            print "poele allume"
            print (d[u'Temperature']- d[u'Consigne'] + CONSIGNE_POELE)
            index = int((TEMP_OFF - (d[u'Temperature']- d[u'Consigne'] + CONSIGNE_POELE))/coeff)
            if index < 0 :
                index = 0
            if index > 255 :
                index = 255
        resp = spi.xfer2([0, index])
        time.sleep(10)

finally:
    spi.close()

Voici le code, celui ci n’est pas indépendant du service web. C’est grâce au service web que cette boucle déduit la température à donner au poêle.

L’appel au « status » retourne le json suivant :

{
  "Consigne": 19.0, 
  "Etat": "on", 
  "Exterieur": 17.6, 
  "Temperature": 23
}

Ce json est ensuite converti en dict pour être utilisé simplement dans la suite du traitement.

On demande au poêle de se mettre en route si la température est inférieure à 19°C. La température dans la pièce est actuellement de 23°C. La température extérieure n’est actuellement pas utilisée, elle le sera peut-être plus tard si je trouve comment l’utiliser convenablement.

L’interface web

Pour l’interface web, j’ai fait le choix d’utiliser Flask.

L’objectif est de pouvoir piloter le poêle directement depuis un smartphone, ou de pouvoir l’inclure dans ma solution domotique existante (Zibase pour le moment).

Récupération de la température

La température de la pièce est fournie par la station météo Netatmo, qui fournit une API. j’utilise une API python déjà existante.

Ce qui se traduit par le bout de code suivant:

# Connexion à la Netatmo
authorization = lnetatmo.ClientAuth()
devList = lnetatmo.DeviceList(authorization)

#Récupération de la température
temperature_interieur = devList.lastData()[u'Intérieur']['Temperature']
temperature_exterieur = devList.lastData()[u'Extérieur']['Temperature']

Communication avec la zibase

Je veux pouvoir connecter le poêle à la zibase, parce que celle-ci fournit directement une fonctionnalité de thermostat.

En réalité ce dont j’ai besoin que la zibase connaisse, c’est la température relevée par la station météo Netatmo.

La Zibase peut peut effectuer des commandes http, mais elle est plutôt limitée de ce coté. Elle sait lire du XML. Le service web fourni donc une page qui transforme le dict retourné par l’API netatmo en XML compréhensible par la Zibase.

#Appel par la zibase pour récupérer les infos de la Netatmo    
@app.route("/netatmo")
def netatmo():
    global devList
    xml = unicode(dicttoxml(devList.lastData()), "utf-8")
    xml = re.sub(r" type=(.*?)>",">",xml)
    xml = unicodedata.normalize('NFKD', xml).encode('ascii','ignore')
    return Response(xml, mimetype='text/xml')

Pour simplifier la configuration coté Zibase, j’ai retiré les accents par exemple « Extérieur » devient « Exterieur » et simplifier au maximum le xml produit en retirant les types.

La zibase ne permet que d’allumer/éteindre, j’ai donc un service qui recoit le on/off :

#Appel par la zibase pour allumer/eteindre le thermostat    
@app.route("/thermostat/<consigne>")
def thermostat(consigne):
    global VAR_ZIBASE_TEMP_INT
    global VAR_ZIBASE_CONSIGNE
    global zibase_control
    global Statut
    if zibase_control :
        Statut['Etat'] = consigne
        content = urllib2.urlopen("http://ip_zibase/sensors.xml").read()
        root = ET.fromstring(content)
        for var in root.iter('var'):
            if var.attrib['num'] == VAR_ZIBASE_TEMP_INT :
                Statut['Temperature'] = float(var.attrib['val'])/10
            if var.attrib['num'] == VAR_ZIBASE_CONSIGNE :
                Statut['Consigne'] = float(var.attrib['val'])/10
    return "OK"

Par contre, heureusement pour moi, les variables qui servent au thermostat de la zibase, sont accessibles dans sensors.xml. J’utilise ElementTree pour lire ce XML et affecter mes variables gloables qui sont retournées dans la page status (utilisée par l’autre processus).

Le statut global

C’est donc dans les variables globales du service Web que l’état du poêle est connu : température de la pièce, température demandée, thermostat activé ou non, température extérieure.

@app.route(« /status »)
def status():
global Statut
Statut[‘Temperature’] = devList.lastData()[u’Intérieur’][‘Temperature’]
Statut[‘Exterieur’] = devList.lastData()[u’Extérieur’][‘Temperature’]
return jsonify(**Statut)

Cette page status se contente donc juste d’afficher un json du dict global qui contient toutes les infos nécessaires.

Interface indépendante de la zibase

Parce que je n’ai pas envie de dépendre uniquement de la zibase, j’ai aussi réalisé une petite interface web. J’utilise Jquery Mobile pour que celle ci soit accessible de n’importe quel type de matériel que ce soit mon ordinateur, smartphone ou tablette.

Voici un petit aperçu de cette page :

Capture d'écran de 2014-06-19 14:13:14

Comme vous pouvez le constater, l’interface web prend en compte le niveau de granulés dans la réserve. Cela sera réalisé via un émetteur à ultra-son HC-SR04.

Mais au même titre qu’il me manque un boitier pour le raspberry qui accueille la Pi Plate, il me manque aussi une mise en place discrète sous le couvercle des granulés de l’émetteur à ultra-son.

Il est bien souvent plus simple de faire les prototypes et de programmer que d’intégrer cela proprement chez soi.

 

Domotiser un poêle à granulés ( partie 1 : Le montage )

Ma maison est une maison récente, mais dont la seule source d’énergie est l’électricité. Le chauffage était donc un plafond rayonnant au rez de chaussée et des « grilles pains » à l’étage.

Je n’ai aucun reproche à faire à la chaleur et le confort procuré par le plafond rayonnant, par contre, d’après nos estimations nous pensons être environ à 900€ de chauffage par an (comparaison de la consommation hiver/été). Nous avons donc pris la décision d’installer un poêle à pellets pour réduire cette facture et le plaisir de voir une flamme.

Notre choix s’est porté sur le CMG Dual :

Poêle à granulés CMG Dual

Ce poêle présente l’avantage d’être plutôt silencieux. Il était hors de question qu’il nous réveille en se mettant en route le matin.

Ce poêle a néanmoins 2 défauts (qui sont liés) :

  1. La sonde de température est filaire. De ce fait, elle est perturbée par la chaleur dégagée par le poêle en fonctionnement.
  2. La programmation est hebdomadaire, il n’est pas possible de programmer un allumage à une date précise ou dans X jours (exemple retour de vacances etc).

Voila donc pourquoi domotiser le poêle !

Domotiser le poêle

Les objectifs

Objectif numéro 1 : Faire en sorte que la température remontée au poêle ne soit plus perturbée par le fonctionnement du poêle.

Objectif numéro 2 : Pouvoir programmer le poêle plus finement.

Comment ?

CMG ne fourni pas à ce jour de solutions pour rendre connecté son matériel. Il ne me reste donc qu’a bidouiller avec ce que j’ai et mes connaissances.

Le gros point noir que j’ai c’est une sonde filaire.

Comment faire pour remplacer une sonde filaire par une sonde distante ?

Il existe deux types de sondes filaires, les sonde numériques et les sondes analogiques. La mienne ne possède que 2 files et a une résistance variable en fonction de la température constatée.

La première étape est donc de débrancher cette sonde et de prendre un ampèremètre pour mesurer la résistance de celle-ci. Cela me donne une résistance d’environ 12kohm.

Deuxième étape : je décide de remplacer cette sonde par un potentiomètre classique de 10 kohm avec en série une résistance de 10kohm. Il me reste maintenant à faire varier le potentiomètre, noter la température donnée par le poêle, débrancher et mesurer pour avoir la résistance équivalente.

Ce qui donne ces quelques mesures :

8°C       = 19,7 kohm
18,1 °C = 13    kohm
18,4 °C = 12.9 kohm
20 °C    = 12   kohm
25 °C    = 10   kohm

La solution : remplacer ce potentiomètre analogique, par un potentiomètre digital.

Le matériel

L’objectif est de pouvoir connecter le poêle pour qu’il soit contrôlable à la fois via un PC ou Smartphone. Il me fallait donc une connexion sans fil. Mon choix s’est donc porté sur :

  • Un raspberry PI
  • Une clé USB wifi
  • Un potentiomètre digital MCP 4162

Et pour les tests :

  • Un ampèremetre
  • Un Pi Cobler
  • Une breadbord (platine d’essai)
  • des fils 😉

Au départ je n’était pas parti sur ce potentiomètre, mais sur un AD5175 qui présente l’avantage d’avoir un pas de 1024 alors que celui-ci n’a que 256 valeurs possibles. Mais il présente l’avantage d’être dans un format qui me permet de le tester facilement sur une platine d’essai. Et surtout n’ayant jamais soudé, au plus simple au mieux.

Le montage

Voila donc une photo du prototype.

Le montage d’essai

Ce qui donne les schémas suivants :

raspberry_digipot_bb

 

raspberry_digipot_schéma

Voila pour le montage.

Résumé

Donc pour résumer, nous utilisons un potentiomètre digital connecté via SPI au Raspberry PI. Ce potentiomètre remplace la sonde filaire du poêle et lui indique la température. Nous allons jouer sur cette température pour alluer ou non le poêle.

Au niveau du poêle, il sera toujours allumé avec une température demandée à 19°C. Si on veut que le poêle se coupe, on fait croire à celui-ci qu’il fait 25°C dans la pièce sinon on lui envoie la température relevée par une sonde déportée. Dans mon cas je récupère la température via la station netatmo.

Dans le cas d’un poêle à granulé, il est impossible de le faire fonctionner en on/off parce que la quantité de granulés consommée par le poêle est variable en fonction de l’écart entre la température constatée et la température demandée. Il est donc nécessaire de prendre cela en compte.

Reste à faire

Comme vous pouvez le constater, actuellement le WAF n’est pas au rendez vous 😉

J’ai donc acheté une Pi plate :

http://www.adafruit.com/products/801

http://www.adafruit.com/products/801

Je cherche encore un boitier qui peut accueillir le raspberry et la Pi plate que je puisse facilement attacher derrière le poêle.

A suivre : Le code utilisé pour que tout cela fonctionne 😉

 

Récupérer la téléinformation avec un Arduino (suite)

Je vous avais parlé, il y a déjà un bout de temps de la méthode afin de récupérer la trame téléinformation EDF à partir d’un arduino. Le défaut de cette méthode, c’est que la trame est « brute ». Je trouvais dommage de ne pas la décoder directement au niveau de l’arduino et n’envoyer que les informations utiles.

Je me suis donc attelé à cette tâche.

Décodage de la trame téléinformation via arduino

Pour rappel, la trame « brute » ressemble à ceci :

ADCO 02092xxxxxx @
OPTARIF HC.. <
ISOUSC 45 ?
HCHC 010956910 %
HCHP 016779643 >
PTEC HP..
IINST 021 Z
IMAX 047 J
PAPP 04860 3
HHPHC A ,
MOTDETAT 000000 B

Le premier fichier (ar_teleinfo)  permet de récupérer et décoder la trame de téléinformation.
Une trame commence par le caractère 0x02 et se termine par le caractère 0x03. Celle ci est composée de groupes.Un groupe commence par 0x0A et se termine par un retour chariot 0x0D.

Une fois qu’on est arrivé au niveau des groupes nous allons pouvoir récupérer les informations intéressantes.

Un groupe est composé :

  • d’une étiquette
  • un espace 0x20
  • une valeur
  • un espace 0x20
  • un caractère de checksum

Il nous reste donc à traiter les chaines de caractères comprises entre les espaces. Le checksum va nous permettre de vérifier que les valeurs récupérées correspondent bien à ce qui nous a été envoyé.

Le deuxième fichier (xpl_teleinfo) sert a envoyé une trame xpl contenant les informations qui ont été décodées précédemment.

Le troisième fichier (time) va permettre d’envoyer le messge xpl-stat et hbeat régulièrement.

Pour votre installation, il est nécessaire de modifier les constantes en début de programme (ar_teleinfo) afin de spécifier notamment l’adresse ip de l’arduino, ainsi que l’intervalle désiré d’envoi de trames xpl.

Récupérer la téléinformation sous domogik

Maintenant que nous décodons et envoyons les trames téléinformation via xpl, nous pouvons nous atteler à les récupérer sous domogik.

Pré-requis: disposer au minimum de la version 0.20alpha1 de domogik.

La version 0.20 de domogik apporte une fonctionnalité très interessante pour la gestion des plugins et external, c’est que ceux ci sont gérés indépendament de domogik et s’installent sous forme de package à partir des repositories de domogik.
J’ai donc réalisé un package pour domogik pour la téléinformation via arduino.

Afin de l’installer, il suffit donc d’avoir domogik en version 0.20alpaha d’installée (en mode install et non develop) et de parcourir les plugins disponibles et de choisir ar_tinfo :

Ensuite afin de pouvoir visualiser les données, il est nécessaire d’ajouter un device :

Une fois le device affecté à un espace de visualisation, vous pouvez donc consulter les informations de téléinformation.

On retrouve un historique précis des consommations électriques :

 

Récupérer la téléinformation avec un Arduino

Depuis longtemps j’avais envie de pouvoir suivre ma consommation électrique, sans jamais avoir vraiment franchi le pas. Il existe bien des solutions toutes faites qui permettent de suivre cette consommation via par exemple une pince ampèremétrique, mais j’avais envie de le faire moi même. Cela pour plusieurs raison :

  1. Envie de monter en compétence sur ce formidable Arduino
  2. Que cela ne me coute pas trop cher (moins d’un euro l’opto-coupleur + l’arduino qui va servir à autre chose)
  3. On est tellement fier quand on a réussi quelque chose fait maison 😉

Pour ceux qui ne connaissent pas encore l’Arduino, je vous conseille d’aller faire un petit tour sur le site du projet

Il s’agit d’un petit circuit imprimé complètement open-source disposant d’un microcontrôleur facilement programmable.

La téléinformation

Les compteurs EDF de type électronique possèdent deux bornes (I1 et I2) qui émettent un signal modulé sur 50Hz. Il existe de nombreux schema de circuit imprimé disponible sur internet afin de démoduler ce signal et obtenir par exemple votre consommation en temps réel.

Pour ceux qui désirent avoir un peu plus de détail, je vous conseille de lire l’article plutôt complet sur le sujet  rédigé par Planète-domotique.

Et pour ceux qui aiment aller directement à la source, voici la documentation officielle d’ERDF.fournie par bernard lefrancois.

Le schéma et l’arduino

Une recherche sur internet, m’a amené sur un schéma simple sur chaleurterre  : http://www.chaleurterre.com/forum/viewtopic.php?p=51607#51607

Par contre, il est prévu pour une connexion RS232 (port Série) d’un ordinateur. Cela ne correspondait pas tout à fait à mon besoin, j’ai pour objectif de collecter la téléinformation via le microcontrôleur arduino (qui va faire plus de chose par la suite), mon pc étant très éloigné du compteur.

Heureusement je suis tombé sur quelqu’un qui avait fait le même type de montage pour une interface série TTL. Voici donc le schéma utilisé :

Et avec ce petit bout de code :

#include <SoftwareSerial.h>

SoftwareSerial cptSerial(2, 3);

void setup() {
        Serial.begin(1200);     // opens serial port, sets data rate to 1200 bps
        cptSerial.begin(1200);
}

void loop() {

  if (cptSerial.available())
    Serial.write(cptSerial.read() & 0x7F);
}

J’ai effectivement la chance d’avoir en sortie des données qui ressemblent bien à celles de la téléinformation :

ADCO 02092xxxxxx @
OPTARIF HC.. <
ISOUSC 45 ?
HCHC 010956910 %
HCHP 016779643 >
PTEC HP..
IINST 021 Z
IMAX 047 J
PAPP 04860 3
HHPHC A ,
MOTDETAT 000000 B

Maintenant que j’ai validé que le montage est ok, il me reste à investir dans un shield ethernet afin de pouvoir me passer de la connexion usb.

L’objectif c’est de connecter ce module à domogik via xpl, mais ce sera l’objet d’un autre article.

Logiciels utilisés :

  • Fritzing pour le schéma
  • Arduino pour le développement
  • cutecom pour la liaison série

PS : Partout sur internet on parle de l’opto-coupleur SFH6206, j’ai fait l’erreur de l’acheter, il s’agit d’un opto-coupleur qui n’est pas au format DIP et qui n’est donc pas utilisable sur une plaque d’essai. Je vous conseille donc de prendre plutot le SFH620A qui lui est au format DIP (C’est le même).

Projet Domotique – Connaitre le niveau d’une cuve de récupération d’eau de pluie

Jusqu’à présent, j’ai toujours réalisé des articles sur des sujets que j’ai déjà réalisés. Aujourd’hui je compte vous présenter mon projet domotique qui consiste à connaitre le niveau d’une cuve de récupération d’eau de pluie. J’ai choisi de le présenter avant sa réalisation parce que celui ci est plutôt très éloigné de mon domaine de compétence et je pense qu’il est donc opportun de le partager et d’en discuter avant plutôt que de regretter ses choix après.

Le contexte

Ma maison est équipée d’une cuve de récupération des eaux pluviales sur laquelle sont connectés les WC et la machine à laver, ainsi qu’un robinet dans le garage. J’aimerais mettre en place un système d’arrosage automatique du jardin. Mais, je ne tient en aucun cas à dépenser de l’eau de ville pour arroser le jardin. Je voudrais donc pouvoir arroser uniquement si le niveau de ma cuve est supérieur à un seuil (disons 30% pour commencer).

Je dispose déjà d’une petite installation domotique dans la maison à base de Zibase, qui me permet par exemple de mettre en route un ventilateur quand la température dépasse un certain seuil  (suite au souci autohebergement  et fortes chaleur 😉 ).

La cuve quand à elle n’est malheureusement pas équipée de quoique ce soit qui puisse m’indiquer son taux de remplissage, elle est déconnectée de la maison (mis à part le circuit d’eau).

Solution envisagée – La mesure par ultrason

J’avoue avoir étudié pas mal de solutions avant dans sélectionner une, du flotteur relié à un potentiomètre avec un contrepoids à la barre immergée avec des capteurs positionnés dessus, jusqu’à tomber sur des solutions professionnelles de mesure de cuve via des ultra sons.

La précision de la mesure par ultrason me semble être plus que largement suffisante dans mon cas. Et surtout je devrais pouvoir l’installer dans la cuve sans la vider et n’intervenir que sur la rehausse.

Technique – Arduino + module Ultrason + module RF 433 Mhz

Après quelques recherches je suis tombé sur le module ultrason HC-SR04 :

Le cout est plutôt faible 10$ et un librairie pour Arduino est disponible.

Cela sera pour moi l’occasion de découvrir l’Arduino et un peu d’électronique au passage, domaine dans lequel je n’ai aucune connaissance.

Je pense que beaucoup d’entre vous connaissent déjà, mais pour reprendre une partie de la définition wikipedia  :

Arduino est un circuit imprimé open-source sur lequel se trouve un microcontrôleur (calculateur) qui peut être programmé pour analyser et produire des signaux électriques, de manière à effectuer des tâches très diverses.

Normalement en utilisant la librairie fournie et un arduino, je devrais donc être capable de mesurer la distance entre le module à ultrason et la surface de l’eau.

Mais ma problématique c’est d’avoir l’information dans la maison, si je dois ouvrir la cuve pour aller lire la valeur sur un écran LCD, je ne sais pas bien ou serait le gain.

Il me faut donc une solution pour faire communiquer l’arduino avec les équipements dans la maison.

Les diverses méthodes de communication compatible Arduino Xbee , Wifi, Bluetooth,  etc sont très onéreuses et pas directement compatible avec la Zibase. Il existe par contre une solution à base de Radio Fréquence à 433 Mhz qui il me semble devrait être compatible.

Ce dispositif est de l’ordre de RF 433 Mhz est de l’ordre de 5-6€,

Ce qui ferait un cout total d’environ 45€ :

  • Arduino 25€
  • Ultrason 10€
  • RF-Link 6€
  • Frais de port …

Les questions en suspend …

L’alimentation électrique

Je pensais au départ alimenter le système via des piles. Il semblerait qu’en fonction des éléments ajoutés à l’arduino, la consommation électrique puisse devenir trop importante et que la durée de vie des piles ne me permettent pas d’avoir une solution viable.

Il existe une possibilité de « réveiller » l’arduino à intervalle fixe et cela devrait donc me permettre d’économiser de la batterie.

Cf : http://hackaday.com/2009/08/13/sleepy-arduino-saves-batteries/

Reste à savoir si cela sera suffisant ?

L’humidité

Qui dit cuve de récupération d’eau de pluie, dit eau et condensation. Il sera donc nécessaire de bien protéger l’électronique de la condensation produite par l’eau de la cuve.

J’ai vu qu’il existait des petits boitiers plastiques spécifiques à l’arduino, il faudra néanmoins revérifier ces points une fois le montage terminé, le volume occupé n’étant pas uniquement la carte arduino.

La communication RF

Je ne sais pas comment vérifier avant l’achat que l’ émetteur RF 433 Mhz sera bien compatible avec la Zibase (ou un récepteur RFXCOM)

Si ce n’est pas le cas, la seule solution que je vois serait de mettre une deuxième carte Arduino dans la maison avec le récepteur compatible qui retransmettra via le réseau le signal. Mais je préfèrerais vraiment faire sans.

Et vous ?

Avez vous déjà mis en place une solution pour mesurer le niveau d’une cuve, quelles solutions avez vous choisie ?