GuiguiAbloc

Un petit billet rapide pour vous informer de la mise à disposition d’un client xPL pour la carte IPX800 de GCE-Electronics que tout les fans de domotique connaissent

Vous trouverez le script et le code source sur mon google code :
http://code.google.com/p/guiguiabloc/downloads/detail?name=xPL-ipx800.py&can=2&q=

Pour le moment je ne gère que les ordre on/off sur les relais de 1 à 8 par un message standard xPL basé sur le schéma control.basic.

Exemple :

xpl-sender -m xpl-cmnd -c control.basic device=ipx800
 type=output current=on|off data1=1|2|...

Où data1= le numéro du relais

En espérant que cela vous serve autant qu’à moi

Quitte à tripoter ma chaudière fioul, autant en profiter pour la domotiser un peu

Quand je dis domotiser, je parle bien évidemment de la régulation/programmation du chauffage.

Pour les chauffages électriques, c’est de la rigolade, puisque dans la plupart des cas, c’est natif (fil pilote, thermostat d’ambiance, que sais-je encore…)

Pour les chaudières Gaz, mon « confrère » bloggeur, Abavala (je peux t’appeler confrère Hervé ? :p ), a écrit un excellent billet à ce sujet que je vous invite à lire de suite :

http://www.abavala.com/2011/10/24/ma-chaudiere-a-lapproche-de-lhiver/

Quand au chaudière fioul, bah y’avait pas grand chose…

Alors tout d’abord, petit rappel de fonctionnement.

Ma chaudière est une « vieille » chaudière (comme Karen Cheryl) (spécial clin d’oeil à Fred qui se lamentait de ne plus avoir de lien vers sa chanteuse favorite) (pardon Karen).

Elle n’a donc aucun dispositif de thermostat d’ambiance.

(Vous me direz, je pourrais en changer et mettre un truc de la mort qui tue avec toutes les options, mais bon, c’est comme mes PCs ou ma femme, je suis assez basique la dessus, tant que ça marche, pourquoi en changer ?..)

C’est une chaudière qui produit de l’eau chaude (nommée ECS dans les milieux autorisés, pour Eau Chaude Sanitaire).

Donc elle est composée d’un brûleur (qui brûle le fioul ah ah ah) et chauffe l’eau du ballon incorporé pour me permettre de prendre ma douche dans des conditions acceptables en hiver (et en été aussi d’ailleurs…) et également l’eau qui est envoyé dans le circuit d’eau des radiateurs par un Circulateur.

Ce circulateur est une sorte de pompe qui ne fait que faire « circuler » (d’où son nom, comme quoi la nature est bien faite) l’eau dans le circuit.

Alors un circulateur, c’est ça :

En mode « été », on coupe le circulateur d’eau chaude qui donc n’envoi plus d’eau dans le circuit des radiateurs (magique hein ?).

Sous ce circulateur, nous avons un gros thermostat d’avant guerre qui permet de « régler » la température de l’eau chaude envoyée dans le circuit (en fait une simple vanne qui permet de doser le volume d’eau chaude envoyé).

Vanne qui ne me sert à rien puisque tout mes radiateurs (sauf 1 bien sûr (obligatoire!)), sont équipés de robinets thermostatiques, c’est pour quoi elle est ouverte à fond.

Je peux donc, individuellement, contrôler la température de chaque « pièce/radiateur » (si je met le robinet thermostatique a 21°, le robinet coupe l’arrivée d’eau chaude dans ce radiateur une fois cette température atteinte dans la pièce).

Bon je ne vous expliquerais pas le fonctionnement du robinet, on s’en moque un peu.

Alors déjà ça c’est bien, mais le matin, quand on quitte la maison, on se voit mal faire le tour de tout les radiateurs (j’en ai 13 !) pour baisser la température de 2°.

Donc bilan, on laisse tel quel et dans la journée, quand personne n’est la (à part le lapin), ben ça chauffe pareil que quand on est la…

D’où l’idée de gérer un peu tout cela par le serveur Domotique.

De quoi dispose t’on pour traiter de sujet ?

La majorité des pièces de mon domicile sont équipées de sondes de température, mon système domotique « connait » donc la température de chaque pièce.

On ouvre la chaudière et on regarde un peu les branchements électriques :

Alors oui, c’est très old-school… Nous avons le fil d’alimentation du circulateur qui arrive sur un bornier et donc qui est alimenté quand la chaudière est mode Hiver et coupé quand elle est en mode été.

Ne reste plus qu’a se greffer la dessus.

Pour cela, rien de plus simple, il nous faut un contacteur on/off 1000w Chacon (RF 433Mhz)

Un interrupteur va-et-vient (pour passer en mode normal si le système domotique venait à ne plus fonctionner), un voyant rouge 220v (pour faire zoli et voir quand le circulateur est alimenté) et une boiboite pour mettre tout ca dedans.

Soudure, domino et tadammmmm :

The Chaudiere-Controler made by GuiguiAbloc.

Essentiel pour la compréhension, un schéma électrique bien pourri (PS: Pour ceux qui aurait dormi en cours d’électricité P = Phase (ou aussi L comme « Live ») et N = Neutre):

(Quizz a mes amis du réseau : De quel équipement est tiré l’oreille qui sert de support à mon domino ? )

Maintenant que l’on peut contrôler l’arrêt/marche du circulateur, comment on programme cela ?

Alors vous allez voir c’est assez basique.

Tout d’abord, on se créé un template crontab qui sera chargé tout les jours de la semaine de 8h à 18h.

Comme mon serveur domotique « plotte » nos agendas, si nous sommes en RTT/Vacances/Pas envie d’aller bosser , il ne charge pas la crontab dans ce cas là.

Une fois cette crontab chargée, il exécute un script tout les quart d’heure qui vérifie les consignes qui lui sont données dans un fichier YAML. Si la température est au-dessus de ses consignes, il coupe le circulateur, sinon il le relance. Par contre, si une des températures de la maison venait a descendre en dessous du seuil minimum, il relance le circulateur.

La commande on/off du module Chacon est envoyée sur le bus xPL et transmise par mon boîtier RFXCOM.

J’ai donc écrit un script en python qui est lancé toutes les 15 minutes :

NB: C’est une version allégée de celui que j’utilise

Exemple fichier YAML de consigne :

SALON: 18.0
SDB : 20.0
MINITEMP : 17.0

Le script :

#! /usr/bin/python
# -*- coding: cp1252 -*-
 
import MySQLdb, sys
import yaml, socket
 
# YAML
fichieryaml = open('consigne.yaml')
consigne = yaml.load(fichieryaml)
fichieryaml.close()
 
# ALIMENTATION VARIABLE
consignesalon =  consigne['SALON']
consignesdb = consigne['SDB']
minitemp = consigne['MINITEMP']
hostname = socket.gethostname()
 
# CONNECTEUR UDP XPL
UDPSock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
UDPSock.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST,1)
 
# fonction Message XPL
def xplmsgcmnd(ordre):
  msg = "xpl-cmnd\n{\nhop=1\nsource=guigui-chauffage." +hostname+"\ntarget=*\n}\nhomeeasy.basic\n{\naddress=0x1111bb\nunit=1\ncommand=" +ordre+ "\n}\n"
  xpladdr = ("255.255.255.255",3865)
  UDPSock.sendto(msg,xpladdr)
 
 
# Connexion MySQL
try:
  db = MySQLdb.connect(host="localhost", user="sonde", passwd="sonde", db="sondes")
except :
  print "connexion refusée"
  sys.exit(1)
 
c = db.cursor()
c.execute("SELECT sensorValue from sensor where sensorType='TempSalon' ORDER BY idx DESC limit 1")
 
rows = c.fetchall()
for row in rows:
    tempsalon = float(row[0])
 
c.execute("SELECT sensorValue from sensor where sensorType='TempSdb' ORDER BY idx DESC limit 1")
 
rows = c.fetchall()
for row in rows:
    tempsdb = float(row[0])
 
c.execute("SELECT sensorValue from sensor where sensorType='TempAutre' ORDER BY idx DESC limit 1")
 
rows = c.fetchall()
for row in rows:
    tempautre = float(row[0])
 
c.close()
 
if tempsalon < minitemp or tempsdb < minitemp or tempautre < minitemp :
  ordre = "on"
  xplmsgcmnd(ordre)
  sys.exit(0)
 
if tempsalon <= consignesalon or tempsdb <= consignesdb:
  ordre = "on"
  xplmsgcmnd(ordre)
 
if tempsdb > consignesdb and tempsalon > consignesalon:
  ordre = "off"
  xplmsgcmnd(ordre)

Et voila, un thermostat d’ambiance beaucoup plus fin que ceux que l’on trouve dans le commerce (car il prend en compte plusieurs températures et non pas seulement la température de la pièce de référence) et comble du luxe, comme je connais également la température extérieure, je peux peaufiner ma demande (inertie des radiateurs, baisse plus ou moins rapide de la chaleur de la pièce etc…)

C’est très DIY je l’avoue, mais c’est très amusant à faire (et en plus ça permet de faire des économies )

Amusez vous bien

Si vous suivez ce blog et ses derniers billets (grand bien vous en fasse ), vous savez que je me consacre de plus en plus à la domotique (pour diverses raisons dont vous trouverez l’explication dans cet historique justement).

En plus de cette passion pour la domotique, je me suis pris d’un grand intérêt pour le protocole xPL.
(et de nouveau je vous invite à lire l’excellent billet de Thibault sur son blog).
Qui dit xPL, dit forcément une lecture soutenue des différentes pages du projet xPL et de la rencontre avec ses différents acteurs.
D’ailleurs, mon engouement sur le sujet vient aussi beaucoup de l’activité française dans ce domaine et des contacts enrichissants et passionnants avec les passionnés de Domotique en France, que je salue au passage, dont le dévouement et l’implication font que cette communauté est a elle seule, une raison de les rejoindre.

Bref, comme vous l’avez vu, j’ai commencé a poindre mon nez en fournissant un premier client xPL écrit en python, qui, à ma grande surprise, a reçu un accueil très favorable et enthousiaste (au point d’être référencé dans les développeurs xPL du projet sur la page d’accueil !!!).
J’avoue avoir était grandement surpris et je remercie les agitateurs du projet pour leur soutien.
D’un autre côté, cela vous met une pression grave (en plus d’une demi-molle je l’avoue…)

Dans cette progression personnelle que j’ai, j’ai donc commencé à pondre du code (et là, les gens qui me connaissent bien doivent halluciner ).
Le langage de développement qui m’a très vite attiré est bien sûr Python (loin de moi l’idée de lancer un troll sans fin sur les remarques « mais t’es nul Java c’est mieux! », parce que bon, java, euh, comment dire… (bah non je vais rien dire mais j’en pense pas moins :p ))
Alors attention, je ne suis pas développeur du tout, mon métier c’est le système/réseau (plutôt réseau d’ailleurs), et donc je conçois totalement d’être hué, haï, conspué et dénigré par des « vrais » développeurs (quand ils existent), et si j’ai fait le choix de Python comme langage de prédilection, c’est qu’il répond à mes attentes, qu’il est très puissant, et que j’aime bien les serpents.
S’tout.

Cela étant dit, pour en revenir à nos moutons, dans une architecture xPL, un des éléments qui peut s’avérer important est ce que l’on appelle le xPLHal.
Vous en trouvez l’explication ici .
C’est un « moteur » central xPL, il écoute les messages transitant dans les hubs xPL et exécutent des actions en conséquence de ses messages ou suivant une programmation horaire définie par l’utilisateur.
Pour contrôler ce moteur, il y a un xPL-HalManager qui est l’interface entre l’utilisateur et le xPLHal.
Alors bien évidemment, cet xPL-Hal n’est pas obligatoire, beaucoup utilisent des scripts maison (surtout dans le monde Linux), ou autres bidouilles.
Sous windows, vous trouverez votre bonheur, mais sous Linux, c’est un peu le désert, a part un XPLHAL java plus maintenu depuis 2008.

Et en python, rien… (a part le projet Domogik bien sûr).
Parent pauvre de la domotique, Linux est durement supporté par une poignée de personnes face aux mastodontes Windoziens (aka Homeseer bien sûr) et c’est bien dommage au regard des gens qui sont actifs dans ce milieu.

Je me suis donc mis en tête et en cheval de bataille sur ses prochains mois, d’écrire un xPLHal en python.
La charge du projet est importante si l’on considère les pré-requis, et peut-être même insurmontable, mais après tout pourquoi pas.
Déjà cela m’obligera a me familiariser avec python, avec xPL, et surtout, le plus important à mes yeux, d’essayer d’offrir quelque chose de plus à la communauté.

Dont acte, début du projet xPL-pyHAL.

J’espère vous donner une première ébauche de ce que j’ai écrit, mais les premiers pas sont encourageants surtout quand on apprend le langage en même temps
Je suis parti pour l’instant sur une configuration à base de fichiers YAML (un simple fichier typé par module à surveiller dans lequel vous spécfifiez les règles a déclencher quand une action sur le module est détectée) et qui pour les premiers tests marchent plutôt bien (action de type HEYU, stockage dans un Memcached ou message de type Notifry (clin d’oeil a Thibault au passage pour son excellent xPL-PushMsg ) etc…) bref, ça avance et j’espère vous détailler plus tard un peu plus de ce projet qui me tient à coeur pour 2012.

Le projet sera hébergé ici : http://code.google.com/p/guiguiabloc/ (avec la création d’un nouveau logo pour l’occasion )

En attendant, je vous souhaite à tous d’excellentes fêtes de Noël et de fin d’année

Comme la majorité des passionnés qui touche à la domotique, j’utilise le protocole xPL pour centraliser les informations de mes équipements.

Si vous ne connaissez pas encore le principe, je vous invite à lire les excellents billets de Thibault et Mickael à ce sujet :

http://www.poulpy.com/2010/02/xpl-one-protocol-to-rule-them-all/

http://www.planete-domotique.com/blog/2011/05/18/le-protocole-xpl/

Et bien sûr, le site du projet lui-même :

http://xplproject.org.uk/wiki/index.php?title=Main_Page

C’est un protocole fiable, performant et acté par les plus fervents agitateurs de la domotique (par exemple Domogik, un des projets français les plus prometteurs actuellement dans la mise à disposition d’une solution « tout-en-un » (et libre surtout !) ou RFXCOM, un des leaders des équipements domotique RF qui intègre désormais nativement le xPL dans ses produits).

Moi, comme beaucoup de mes confrères passionnés, je suis absolument convaincu du fait qu’il faille définir un protocole standard pour l’interaction des équipements de domotique, bien évidemment, ouvert, et bien évidemment, xPL répond à cette attente.

Jusqu’a maintenant, j’utilisais beaucoup les scripts de la communauté, et surtout ceux de l’excellentissime Mark Hindess connu sous le pseudo de beanz et auteur du framework xpl-perl.

Et puis vient le moment où l’on a un besoin précis qui n’existe pas…

En l’occurence, je voulais récuperer les données et l’état de mon onduleur et bien sûr en xPL.

Je fais le tour des solutions et il existe xpl-apcups du même Mark pré-cité mais, mince, flûte, sacrebleu, il ne fonctionne qu’avec apcupsd.

Bon, tant pis, je me dis que je vais revoir le code pour le faire fonctionner et là, forcément, je sèche comme une blonde décolorée aux attributs siliconés  sur une plage méditerranéenne en plein mois d’août.

Parce que bon, Perl et moi… Comment dire… Autant expliquer le principe du cum-swapping à une none ayant fait voeu d’isolement… (avouez que vouliez un lien !!!!)

Donc je me dis que je vais tenter de l’écrire moi-même mon client, ayant aborder Python du coin de l’oeil je regarde ce qu’il existe et je trouve un petit exemple de John Bent sur le site du projet xPL.

Quelques litres de café plus tard (s/café/bière/), je vous propose donc xpl-nut.

Vous pouvez bien sûr le télécharger ICI
Ou sur le projet GoogleCode :
http://code.google.com/p/guiguiabloc/

J’ai essayé de suivre les recommandations du projet xPL.

Les schémas utilisés sont UPS.BASIC et SENSOR.BASIC

Concernant les recommandations TRIGGER, il est demandé de n’émettre une trame que lors d’un changement d’état mais personnellement, j’ai passé outre, préférant avoir une remontée constante des informations.

EDIT : Suite aux discussions avec l’équipe Domogik, j’ai revu mon code pour être « aux normes » et donc le format de message est donc de type STAT désormais et TRIG en cas de changement d’état (version 1.1 du script)

Comme donner un script python comme ça ne sert pas à progresser, et comme j’ai pris du plaisir à l’écrire (et oui :p), je vous propose d’en voir les parties intéressantes, au cas, où, comme moi, vous décidez d’écrire vos propres clients xPL

#############
# variables
#############
upsaddr='127.0.0.1'
upsport=3493
polltime=10
nomups = 'mononduleur'
 
xpladdr = ("255.255.255.255",3865)
UDPSock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
UDPSock.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST,1)

Ici rien de compliqué, on définit les variables essentielles, a savoir :
- upsaddr : l’adresse IP du démon NUT
- upsport : le port du démon NUT
- polltime : la fréquence d’interrogationdu démon NUT en secondes
- nomups : le nom de votre onduleur, tel que définit dans votre /etc/ups.conf
- xpladdr : l’adresse et le port de broadcast pour les messages

Le code suivant est la préparation de l’ouverture d’un socket UDP.

etatonduleur = "get var "+nomups+" ups.status\r\n"
voltage= "get var "+nomups+" input.voltage\r\n"
batterycharge= "get var "+nomups+" battery.charge\r\n"

Ici on définit les requètes que nous allons passer au démon NUT.
Si vous faites un « telnet ip_du_nut_demon 3493″ par defaut, vous avez accès a une console qui vous permet d’interroger le démon NUT.
HELP donne l’aide (nan ????)
GET VAR nomdelonduleur input.voltage donne le voltage en entrée
etc…
Pour avoir la liste des variables, il vous suffit de taper : upsc nomonduleur.

Voici par exemple ce que cela retourne chez moi :

srv-guiguiabloc:/etc/nut# upsc mgeups
battery.charge: 100.0
battery.charge.low: 30
battery.runtime: 02655
battery.voltage: 055.2
battery.voltage.nominal: 048.0
device.mfr: MGE UPS SYSTEMS
device.model: Pulsar ESV22+
device.type: ups
driver.name: mge-utalk
driver.parameter.pollinterval: 2
driver.parameter.port: /dev/ttyS0
driver.version: 2.4.3
driver.version.internal: 0.89
input.frequency: 50.00
input.transfer.boost.high: 212.0
input.transfer.boost.low: 204.0
input.transfer.high: 248.0
input.transfer.low: 204.0
input.transfer.trim.high: 248.0
input.transfer.trim.low: 240.0
input.voltage: 227.0
output.current: 002.9
output.voltage: 224.1
ups.delay.shutdown: 020
ups.delay.start: 001
ups.firmware: 2
ups.id: Pulsar ESV22+ 2
ups.load: 027.0
ups.mfr: MGE UPS SYSTEMS
ups.model: Pulsar ESV22+
ups.status: OL
ups.test.interval: 10080

A vous de forger les requètes en conséquence

s.send(etatonduleur)
    data = s.recv(50)
    resultat = data.split()
    statusbatt = resultat.pop()
    statusbatt = statusbatt.replace('"','')
    statusbatt = statusbatt.replace('OL','onmains')
    statusbatt = statusbatt.replace('OB','onbattery')
    statusbatt = statusbatt.replace('LB','lowbattery')
    body = 'status=battery\nevent='+statusbatt
    msg = "xpl-trig\n{\nhop=1\nsource=guigui-xplnut."+hostname+"\ntarget=*\n}\nups.basic\n{\n" + body + "\n}\n"
    UDPSock.sendto(msg,xpladdr)
    print msg

J’envois la requète au démon NUT et je récupère le résultat que je traite (salement je l’avoue).
Je forge ensuite le message xPL que j’envois dans le réseau.

Le reste du code est assez basique et vous devriez en comprendre le fonctionnement avec ses quelques explications.
soyez indulgent, je suppose que mon code n’est pas très propre et si vous êtes un pro du python, je suis ouvert à vos recommandations !

En tout cas, cela marche très bien et pour un premier script xPL j’en suis plutôt fier

Une fois lancé, vous devriez voir les remontées dans votre bus xPL:

[xpl-trig/ups.basic: guigui-xplnut.Thanatos -> * - battery onmains]
[xpl-trig/sensor.basic: guigui-xplnut.Thanatos -> * - mgeups[voltage]=225.7]
[xpl-trig/sensor.basic: guigui-xplnut.Thanatos -> * - mgeups[battery]=100.0]

En espérant que cela vous serve,

Amusez vous bien