Bonjour à tous !

Choses promise chose due, un petit article pour partager avec vous la mise en place d’une compteur d’eau a impulsion et la récupération des valeurs dans notre box domotique (en l’occurrence l’eedomus).

1. Préparation du matériel

Avant de commencer, liston le matériel dont nous allons avoir besoin :

♦ D’un Raspberry PI & D’une carte fille PiFace:

L’on ne présente plus le Raspberry, c’est une petite boite avec un linux embarqué :

La carte PiFace permet d’ajouter des connecteurs Entrés / Sortie au Raspberry :

A noter que j’aurai tout aussi bien pu choisir un Arduino, mais l’avantage du Raspberry PI est qu’il possède nativement un port Ethernet et qu’il est très facile de lui rajouter un dongle wifi pour assurer la communication avec le réseau.

Le montage est assez simple, il suffit d’emboiter  la carte PiFace avec le raspberry.

Un petit boitier pour englober le tout sera du plus belle effet. J’ai choisi ce modèle qui est prévu pour la carte PiFace.

Un peu de colle forte sera nécessaire si vous voulez utiliser les petits morceaux de plastique transparent qui servent à visualiser l’état des diodes au travers du boitier.

♦ D’un Compteur d’eau a impulsion :

Dans mon cas j’ai utilisé le capteur suivant :

Pas besoin d’un compteur eau chaude, puisque je l’ai branché en amont au niveau de l’arriver d’eau de mon ballon d’eau chaude.

Il existe aussi un compteur compatible Zwave, je ne l’ai pas testé personnellement. La solution vous reviendra un peu plus cher mais cela surement beaucoup plus simple a utiliser, a vous de choisir 🙂 L’avantage de la carte PiFace est de pouvoir être utilisée pour d’autres réalisation à venir.

2. Préparation du logiciel

Préparation du Raspberry Pi :

Il existe déjà beaucoup de tutoriels très bien fait pour préparer la carte SD du Raspberry PI, je vous laisse regarder l’article de Cédric (ici) ou sur le wiki elinux (ici).
Lors de la configuration initiale, vous devez activer quelques option pour activer le PiFace (source) :

Dans la partie raspi-config (sudo raspi-config) Allez dans  « Advanced Options » puis »SPI » et sélectionnez « yes »

Enfin installer la librairie python du PiFace :

$ sudo apt-get update
$ sudo apt-get upgrade
$ sudo apt-get install python{,3}-pifacedigitalio
$ sudo apt-get install python-mysqldb

Dans le répertoire vous trouverez quelques exemples de code pour vérifier que tout fonctionne (source) :

python3 /usr/share/doc/python3-pifacedigitalio/examples/blink.py

En lançant cette fonction, la diode devrait se mettre a clignoter.

Nous aurons besoin d’une base MySQL, et de quoi héberger un simple code PHP :

J’ai choisi d’utiliser un autre Raspberry (oui oui j’en ai déjà 4 chez moi ^^) pour héberger la base MySQL et la page PHP qui ira lire cette base. Vous pouvez très bien tout mettre sur le même Raspberry PI, ou bien utiliser un Nas Synology. A vous de voir !

Créez dès à présent votre base MySQL :

Elle se compose de 2 tables et d’une vue. La première table permet de stocker la liste des devices, la seconde la liste des enregistrements.
Une vue en MySQL est en quelque sorte une manière de présenter différemment les informations d’autres tables. Ici elle permet de faire la somme de tous les enregistrements d’une journée (autrement dit la consommation de la journée).

--
-- Base de données: `timelogger`
--
-- --------------------------------------------------------
--
-- Structure de la table `Devices`
--
CREATE TABLE IF NOT EXISTS `Devices` (
  `dID` int(5) NOT NULL AUTO_INCREMENT,
  `Name` varchar(50) NOT NULL,
  PRIMARY KEY (`dID`),
  UNIQUE KEY `dID` (`dID`)
);
-- --------------------------------------------------------
--
-- Structure de la table `logger`
--
CREATE TABLE IF NOT EXISTS `logger` (
  `measure_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `dID` tinyint(4) NOT NULL,
  `value` decimal(10,0) NOT NULL,
  `unit` enum('L','W','°C','W/h','%') NOT NULL
);
-- --------------------------------------------------------
--
-- Structure de la vue `SumByDay`
--
CREATE VIEW `SumByDay` AS (select date_format(`logger`.`measure_time`,'%Y%m%d') AS `measure_time`,
                                  `logger`.`dID` AS `dID`,
                                   sum(`logger`.`value`) AS `SUM` from `logger`
                                   Group by date_format(`logger`.`measure_time`,'%Y%m%d'),`logger`.`dID`);
-- --------------------------------------------------------

Je vous propose une structure que j’ai voulu générique pour pouvoir ajouter d’autres types de capteurs demain, vous pouvez bien sur l’adapter a loisir.

3. Installation matérielle

Première chose installer le compteur à impulsion, Ici cela dépendra de la configuration de votre circuit d’eau. Le compteur est livré avec des adaptateurs … dans mon cas, j’ai eu besoin de compléter avec des adaptateurs trouvable dans tous les magasins de bricolage. Les tailles sont standardisées, vous n’aurez pas de surprise (Astuce: prenez avec vous les adaptateurs pour allez en magasin, sinon vous risquer de devoir y retourner plusieurs fois : le nombre de références dans ces rayons est souvent énorme et la probabilité de se tromper si l’on fait ca « a l’oeil » est quasi certaine, croyez mon expérience :p)

Une fois que c’est chose faite, il faut clipser la sonde a son emplacement  et nous sommes prêt.

Bon, c’est bien beau tout cela, maintenant il reste donc a raccorder notre compteur avec le Piface :

L’un des fils doit être connecter a l’entrer 0V (ici en noir) : et l’autre a l’entré que vous voulez (ici la numéro 7) :

4. Configuration Logicielle

Pour alimenter la base MySQL, j’ai donc écris un petit script en python qui compte chaque impulsion et qui met à jour la base SQL toutes les 5 minutes.

C’est mon premier script en python, alors c’est surement assez sale comme code, s’il y’a des pros du python … n’hésitez pas, mon code est sur GitHub.
Vous devrez adapter les informations de connexion à la base SQL.

#!/usr/bin/env python

import pifacedigitalio
import MySQLdb
from threading import Timer

water = 0

def createwaterrecord(value):
    global water

    try :
       db = MySQLdb.connect(host="rsp03",
                         user="timelogger",
			 passwd="timelogger",
                         db = "timelogger" )

       sql = """INSERT INTO logger (dID,
             value, unit)
             VALUES ('1', %(value)d, 'L') ON DUPLICATE KEY UPDATE value=value+%(value)d;""" % {"value": value}
       cursor = db.cursor()
       cursor.execute(sql)
       db.commit()
       db.close()
    except:
      water += value
      #db.rollback()

def waterAdd(event):
    global water
    water += 1

def PrintWater():
    global water
    oldwater = water
    water = 0
    print ("watercounter =  {0}.".format(oldwater))
    createwaterrecord(oldwater)
    t = Timer(60.0, PrintWater)
    t.start()

if __name__ == "__main__":
    #pifacedigitalio.init()
    #pifacedigitalio.digital_write_pullup(7,1)

    pifacedigital = pifacedigitalio.PiFaceDigital()
    listener = pifacedigitalio.InputEventListener(chip=pifacedigital)
    listener.register(7, pifacedigitalio.IODIR_ON, waterAdd)
    listener.register(0, pifacedigitalio.IODIR_ON, waterAdd)
    listener.activate()
    print "Start counting"
    t = Timer(2.0, PrintWater)
    t.start()

Voila, maintenant il faut faire en sorte que le programme se lance au démarrage du Raspberry, et vérifier que tout marche.
Pour cela il faut créer un .sh qui va piloter les actions que nous pouvons faire. Vous pouvez récupérer le mien directement sur GitHub, il n’y aura que le chemin vers votre script a changer.
déposer le dans le répertoire « /etc/init.d » et donner lui les droits d’exécution :

sudo cd /etc/init.d
sudo wget https://raw.github.com/AntorFr/watercounter/master/watercounter.sh
sudo chmod +x /etc/init.d/watercounter.sh
sudo update-rc.d watercounter.sh defaults

Vous pouvez utiliser les commandes suivantes pour démarrer ou arrêter le module.

sudo /etc/init.d/watercounter.sh start
sudo /etc/init.d/watercounter.sh stop

A ce point nous avons donc un module qui alimente une base MySQL avec les valeurs de notre compteur.

Le petit script PHP ci-dessous permet de produire un fichier XML que votre Eedomus ira lire pour afficher la valeur :
Vous devez adapter les informations de connexion a la base MySQL.

<?php
$db = mysql_connect('rsp03', 'timelogger', '');
mysql_select_db('timelogger',$db) or die('Erreur SQL !
'.$sql.'
'.mysql_error());
$sql = 'SELECT dID, SUM FROM SumByDay WHERE measure_time = '.date("Ymd").' AND dID = 1';
$req = mysql_query($sql) or die('Erreur SQL !
'.$sql.'
'.mysql_error());

header ("Content-Type:text/xml");
print '<!--?xml version="1.0"?-->'.PHP_EOL;
print "<water_consos>".PHP_EOL;
print " ".PHP_EOL;
while ($data = mysql_fetch_assoc($req)) {
	print "	<conso_id".$data['did'].">".PHP_EOL;
	print "		"."Compteur eau chaude"."".PHP_EOL;
        print "		".$data['SUM']."".PHP_EOL;
	print "	".PHP_EOL;
}
print " ".PHP_EOL;
print "".PHP_EOL;

?>

5. Configuration de l’Eedomus

Dans l’eedomus il ne reste plus qu’a créer une sonde qui aille chercher a fréquence régulière notre page PHP pour récupérer la valeur.

Configurer l’url et le chemin XPATH « /water_consos/consos/conso_id1/value »

Et voila 🙂 nous avons un beau device qui donne la consommation. L’on peut bien sur rajouter des règles pour détecter si la consommation augmente alors que vous n’êtes pas la.

Dans mon cas, je l’utilise pour désactiver le mode heure creuse si la consommation est supérieur à 50% de la capacité du chauffe-eau histoire de ne pas se retrouver avec de l’eau froide le jour ou vous avez des invités par exemple.

Pour allez plus loin

Maintenant que nous connaissons la consommation en eau chaude, il faut trouver un moyen de rendre le tout ludique pour réduire la facture (d’eau et d’électricité). Je planche actuellement sur un petit module a base d’un arduino pour afficher la consommation dans la salle de bain avec des afficheurs 7 segments (Vishay en l’occurence) Peut-etre bien l’objet d’un prochaine article 🙂 nous verrons …

Compteur d'eaueedomusMySQLPhpPiFacePythonRaspberry Pi