Projet domotique avec domoticz part 1

Salutations visiteur d’un jour,

C’est le premier article d’une série portant sur un projet domotique personnel fait à partir d’un raspberry pi et de quelques composant, beaucoup de patience, de l’huile de coude et des centaines de litres de déca.

Pour mémoire, vous trouverez l’ensemble des composants à avoir ici.

Pour avoir testé pendant quelques mois l’année dernière la Version 1 et après l’avoir passé en production cet hiver, je dois dire que ça fonctionne très bien. La preuve, j’ai démonté notre ancien gestionnaire de chauffage pour le remplacer par un écran LCD qui affiche toutes les 15 min un état du chauffage, des températures et pleins d’autres info.

Au départ, je m’étais mis en tête de détailler mon installation précédente. Mais il faut reconnaitre qu’elle n’était pas très dynamique, l’ajout d’un simple capteur de température rendait la configuration complexe. Quand au packaging DIY ça ressemblait plus à du DBM (Destroy By Myself).

Attention, je parle bien de mes scripts, de mon environnement et non du projet YANA-SERVEUR que j’évoque pendant un temps. J’ai eu le plaisir de tester ce soft et les dernières versions sont toutes aussi prometteuses.

En attendant des photos de la baie informatique et de la box domotique perso, je vous fais un petit topo sur….

domoticz-570x300Et oui j’essaie actuellement domoticz. Vous avez peut être eu l’occasion de découvrir ce projet en scrutant le net à la recherche d’une solution domotique attractive, pas cher et dont la communauté et dynamique.

En cherchant bien sur ce blog, j’ai fait un petit topo sur le site français le plus précis sur le sujet à savoir easydomoticz.

Par quoi je commence ?
  • Téléchargez la dernière image de domoticz disponible sur le site ici,
  • L’installation de l’image se fait de manière classique,
  • A la mise sous tension, faites comme d’habitude le rasp-config qui va bien,

Au reboot, rendez vous sur l’adresse ip de votre serveur:8080. Si éventuellement la page ne s’affichait pas vérifiez que le service est bien actif sur le raspberry. A défaut :

sudo service domoticz start

domo anglais

Menu de la page de garde en anglais pour commencer

Pour modifier les premiers paramètres, tels que la langue et la localisation etc, rendez vous sur Setup puis modifier les paramètres suivants:

  • Langage: Français
  • Localisation à valider impérativement (pour la météo): cliquez sur le lien pour rechercher votre ville.
  • Save à gauche pour commencer.

Je vous laisse découvrir toutes les autres options qui sont, pour la plus part, relativement simples à comprendre.

setupPour bien prendre en main l’outil, je vous invite à découvrir les blogs suivants:

1/ Déclaration du bus OneWire

Pour mémoire ce bus, collecte les températures de 13 capteurs répartis dans la maison et à l’extérieur. Ils sont alimentés par un 5 volts différents du raspberry pi pour une meilleure stabilité. Pas de souci également pour le 5 volts sur le port GPIO 4 car vu la longueur du câblage, j’ai même diminué la résistance de pull up (faut que je cherche m’en rappelle plus ohms).

Vous z’êtes déjà perdus ? Allez zou, pas de blabla, lisez cet article sur Framboise 314

 Sur domoticz, allez sur « Configuration => Périphériques » comme sur l’image.

perif

Vue de la page de périphériques déclarés

Au bas de la page, cherchez dans le menu déroulant 1-wire (system), donnez un nom à ce slot (le nom importe peu et n’influence pas les capteurs qui en découleront). Cochez bien la case « Activé » et laissez le menu déroulant à « Désactiver ».

Ajouter le capteur et il viendra rejoindre les autres dans la liste.

Si des capteurs sont raccordés sur le bus, ils apparaitront automatiquement dans la liste des dispositifs. Si vous en avez plusieurs, soit vous les raccordez un par un [#meilleureoption] soit vous vous faites [#gros mot] comme moi. Dans la liste, le nom attribué par domoticz se trouve être le numéro de série du capteur 28-00000000, pas très pratique pour les différencier.

Bref, finalement on s’en sort entre la liste des capteurs, les températures qui s’affichent à la hausse a grand coup de sèche cheveux. 🙂

Dans cette fameuse liste, cliquez sur la flèche verte, donnez lui un nom et valider. Ci dessous, vous trouverez un exemple.

eau

Vue du capteur déclaré après son nommage.

Dans le menu température, votre capteur apparait désormais et en cliquant sur log, vous verrez dans quelques temps apparaitre un graphique.

panelchauffeau1

Chauffeeau2

Quand tout est fait ça donne un truc comme ça:

panel2

C’est tout pour l’instant, n’hésitez pas a revenir vous perdre ici de temps en temps.

 Fermer, démonter, rouler !

 

 

Supervision d’une cuve de recuperation d’eau

Bonjour à tous,

Dessin_cuveJ’aborde ici mon premier projet grandeur nature. Comme tout le monde, après avoir réussi à faire clignoter des diodes, il me fallait un véritable objectif pour mettre en pratique, grandeur nature, tout ce que j’avais eu l’occasion de tester.

Alors, l’année dernière à la sortie de l’hiver, je vérifie le volume d’eau contenu dans ma cuve enfouie de 2500 L.

Là, c’est le drame, il restait tout au plus 50 cm au fond. Me voilà partie en mode spéléo avec frontale et baladeuse à la recherche d’une fuite. Rien, nada 🙁

Je nettoie les filtres et guette la première averse, je suis enfin soulagé de voir que le niveau remonte. Il n’était pas question de rester aveugle et de se taper un démontage et levage de couvercle tous les 15 jours.

Il me faut l’aide de la technique ! En parcourant le NET, je découvre le Rasberry Pi et la communauté qui gravite autour.

Mon attention se porte particulièrement sur le blog d’Idelman.

Allez zou c’est parti, je bricole un truc en m’inspirant grandement du travail déjà fait histoire de ne par réinventer la roue.

Schéma de principe:

principeSchéma de raccordement des différents capteurs.

SchémaIdée de base :

Il me faut sur une petite page web permettant de visualiser:
– la hauteur d’eau,
– le volume estimé d’eau contenu,
– la température de l’eau,
– la température exterieure,
– la température de la boite de dérivation au cas où…

Elle doit également permettre de commander ma pompe de relevage et une prise de courant extérieure. Si l’interface vous dit quelque chose, c’est tout à fait normal. Elle est issue de la version qui précède le projet Yana-serveur d’Idelman.

mini_web

Pour visualiser les niveaux à partir du Web sans permettre un accès au serveur local, le raspberry de la cuve transmet toutes les 15 minutes, les graphiques sur ce site.

Eyesathome

On commence par où ?

une petite mise au point s’impose avant d’attaquer dans le dur….

Cette page n’est qu’un exemple de ce que j’ai mis en place chez moi. Les informations données ici n’ont pas d’autre but que d’aider ceux qui peuvent être intéressés par le sujet et remercier ceux qui m’ont inspirés.

Je vous rappelle les risques liés à la présence d’eau et du secteur (230 v).

Et enfin, dans la vie, je ne suis pas développeur, le code est brutal, peu adapté mais fonctionnel. J’ai depuis un peu progressé car j’ai une dizaine de capteurs de température dans toute la maison me permettant de gérer le chauffage mais ça c’est une autre histoire.

Le matos (liens donnés pour l’exemple):

Rasperry Pi (modèle B) installation classique avec OS raspbian,
– un capteur à ultrasons type HC-SR04,

hc– trois capteurs de température DS18B20,
– un module deux relais,

relais– une grosse boite de dérivation étanche pouvant contenir un module CPL + raspberry + un peu de bazar en plus :),
– une boite de dérivation 10*10 par exemple pouvant contenir le capteur à ultrasons,
– de la gaine thermo (pour faire le capteur de température immergé),
– des connecteurs RS232 pour raccorder les sondes de températures et le capteur HC-SR04.

rs232

Voici une image du rendu final

Db9Je ne reviens pas sur l’installation de l’os sur le raspberry, il existe une multitude de sites reprenant le sujet.

Les sondes de températures:

Elles utilisent le bus ONE WIRE en mode parasite comme indiqué sur ce site dont je recommande la lecture au passage. Vu le prix des sondes DS18B20 étanches, je vous invite à les faire vous même avec de la gaine thermo et votre fer à souder préféré comme indiqué ici.

sonde_eau

La sonde de profondeur:

Profondeur

Le capteur à ultrason type HC-SR04 se trouve dans une boite de dérivation percée aux dimensions des deux capteurs. Pour finaliser l’étanchéité, j’ai déposé un filet de silicone de salle de bains qui trainait au fond du garage. La boite est fixée sur un rail à placo qui repose sur le bord plastique de la cuve (en dessous de la réhausse). Les capteurs se trouvent à 18 cm de la hauteur maximum de l’eau.

Le réseau informatique:

J’ai testé les dongles wifi mais l’humidité ambiante finie par abîmer les connecteurs. J’ai opté pour un boitier CPLqui me restait. De toute façon, il faudra bien alimenter la pompe en 230 volts. L’adresse IP du lan est attribuée par un DHCP statique par l’intermédiaire de la box.

Au passage, j’attire votre ATTENTION sur les dangers du 230 V :

Si vous n’êtes pas à l’aise sur le sujet, je vous invite à prendre toutes les précautions qui s’imposent et en particulier,

COUPEZ LE COURANT avant toute intervention.

L’environnement où se trouve cette installation est plutôt humide, soyez prudent. Je décline toute responsabilité en cas d’accident.

Comment ça marche, ton affaire ?

Toutes les 5 minutes le script (capture.pl) collecte les températures des 3 sondes et les stock dans une base rrdtool. Puis toutes les 15 minutes, je transferts les images sur le site miroir en FTP.

Voici une vue du crontab qui tourne sur le serveur

# m h  dom mon dow   command
# Capture les temperatures par le bus 1-Wire
*/5 * * * * /home/super/programmes/temperatures/capture.pl

# Lance une copie des graphs sur le site de free toutes les 15 min
*/15 * * * * /home/super/programmes/syteme/copie_site.sh

# Lance les scripts lies a la hauteur d'eau et au volume
*/5 * * * * /home/super/programmes/profondeur/capa.py
*/6 * * * * /home/super/programmes/profondeur/capa.sh

# Lance les scripts de monitoring et graphiques
*/15 * * * * /usr/bin/python /home/super/programmes/temperatures/verif_tech.py
*/15 * * * * /usr/bin/python /home/super/programmes/temperatures/verif_cuve.py

Les scripts:

Les températures:

Comme indiqué plus haut, une base RRDTOOL nommée « temp_cuve.rrd » reçoit toutes les 5 minutes les valeurs des 3 sondes. Le script « creation_base_temp.sh » permet la création de la base RRDTOOL contenant les températures.

Comme vous pouvez le constatez dans les graphiques issus de cette base, les températures négatives ne s’affichent pas. Je modifierai cela plus tard.

rrdtool create temp_cuve.rrd --start N --step 300 \
DS:temp_eau:GAUGE:600:-5:20 \
DS:temp_ext:GAUGE:600:-25:45 \
DS:temp_tech:GAUGE:600:0:45 \
RRA:LAST:0.5:1:12 \
RRA:MAX:0.5:1:12 \
RRA:MIN:0.5:1:12 \
RRA:AVERAGE:0.5:1:12 \
RRA:AVERAGE:0.5:1:288 \
RRA:AVERAGE:0.5:12:168 \
RRA:AVERAGE:0.5:12:720 \
RRA:AVERAGE:0.5:288:365
creation_base_temp.sh

Cette base est alimentée toutes les 5 minutes par le script « capture.pl ». Il est en perl et j’avoue que l’année dernière je me suis contenté de l’adapter sans trop comprendre les rudiments du langage. Depuis, je me suis mis au python et ça va mieux 🙂

#!/usr/bin/perl
use LWP::UserAgent;

my $dir = '/home/super/programmes/temperatures/';
my $ua = new LWP::UserAgent;
$ua->timeout(120);
$modules = `cat /proc/modules`;

if ($modules =~ /w1_therm/ && $modules =~ /w1_gpio/)
{
#modules installed
}
else
{
$gpio = `sudo modprobe w1-gpio`;
$therm = `sudo modprobe w1-therm`;
}

# 1er capteur "eau"
$output = "";
$attempts = 0;
while ($output !~ /YES/g && $attempts < 5)
{
$output = `sudo cat /sys/bus/w1/devices/28-00000468dd1f/w1_slave 2>&1`;
if($output =~ /No such file or directory/)
{
print "Capteur cuve en panne.\n";
last;
}
elsif($output !~ /NO/g)
{
$output =~ /t=(\d+)/i;
$temp_eau = ($1 / 1000);
}

$attempts++;
}

# 2eme capteur "exterieur"
$output = "";
$attempts = 0;
while ($output !~ /YES/g && $attempts < 5)
{
$output = `sudo cat /sys/bus/w1/devices/28-00000468fd4a/w1_slave 2>&1`;
if($output =~ /No such file or directory/)
{
print "Capteur exterieur en panne.\n";
last;
}
elsif($output !~ /NO/g)
{
$output =~ /t=(\d+)/i;
$temp_ext = ($1 / 1000);
}

$attempts++;
}

# 3eme capteur "technique"
$output = "";
$attempts = 0;
while ($output !~ /YES/g && $attempts < 5)
{
$output = `sudo cat /sys/bus/w1/devices/28-0000049d7894/w1_slave 2>&1`;
if($output =~ /No such file or directory/)
{
print "Capteur technique en panne.\n";
last;
}
elsif($output !~ /NO/g)
{
$output =~ /t=(\d+)/i;
$temp_tech = ($1 / 1000);
$rrd = `/usr/bin/rrdtool update $dir/temp_cuve.rrd N:$temp_eau:$temp_ext:$temp_tech`;
}

$attempts++;
}

#print "Temperature eau: $temp_eau\n";
#print "Temperature exterieur: $temp_ext\n";
#print "Temperature boitier technique: $temp_tech\n";
Script de collecte des températures (capture.pl)

Bon c’est du brutal, y’a moyen de faire mieux !

Le script suivant lance la création des graphiques de températures à partir de la base rrdtool.Il est assez simple à personnaliser. On fixe au départ les répertoires sources, destination et les différentes couleurs. Cette partie du script (%.2lf) fixe le nombre de chiffres à afficher aprés la virgule.

#!/bin/bash
DIR="/home/super/programmes/temperatures"

# Pour le deplacement des fichiers img vers le repertoire du serveur web.
source='/home/super/programmes/temperatures/t_*.png'
destination='/var/www/cuve/img'
JOUR=$(date '+%d-%m-%Y %H-%M-%S')

# Affichage en degre C
TEMP_SCALE="Celsius"

#Choix des couleurs
TEMP_EAU_COUL="#000099" TEMP_TECH_COUL="#FF0000" TEMP_EXT_COUL="#993300"

#Titres  et informations
TITRE2="Suivi journalier" TITRE3="Suivi hebdomadaire" TITRE4="Suivi mensuel" TITRE5="Suivi annuel"

#Graphs heure multimesures
rrdtool graph $DIR/t_cuve_multi_4h.png --start -4h  --title="Vue globale sur 4 heures" --vertical-label=$TEMP_SCALE \
DEF:temp_eau=$DIR/temp_cuve.rrd:temp_eau:AVERAGE \
DEF:temp_ext=$DIR/temp_cuve.rrd:temp_ext:AVERAGE \
DEF:temp_tech=$DIR/temp_cuve.rrd:temp_tech:AVERAGE \
LINE1:temp_eau$TEMP_EAU_COUL:"Temperature de l'eau\n" \
LINE1:temp_ext$TEMP_EXT_COUL:"Temperature exterieure\n" \
LINE1:temp_tech$TEMP_TECH_COUL:"Temperature interne du boiter technique\n" \
COMMENT:" \n" \
GPRINT:temp_eau:LAST:"Mesure\: %.2lf" \
GPRINT:temp_eau:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_eau:MIN:"Mini\: %.2lf" \
GPRINT:temp_eau:MAX:"Maxi\: %.2lf\n" \
GPRINT:temp_ext:LAST:"Mesure\: %.2lf" \
GPRINT:temp_ext:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_ext:MIN:"Mini\: %.2lf" \
GPRINT:temp_ext:MAX:"Maxi\: %.2lf\n" \
GPRINT:temp_tech:LAST:"Mesure\: %.2lf" \
GPRINT:temp_tech:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_tech:MIN:"Mini\: %.2lf" \
GPRINT:temp_tech:MAX:"Maxi\: %.2lf\n" \
COMMENT:" \n" \
COMMENT:"Dernier releve $JOUR"

#Graphs par heure
rrdtool graph $DIR/t_eau_4h.png --start -4h  --title="Temperature eau sur 4 heures" --vertical-label=$TEMP_SCALE \
DEF:temp_eau=$DIR/temp_cuve.rrd:temp_eau:AVERAGE \
LINE1:temp_eau$TEMP_EAU_COUL:"Temperature de l'eau\n" \
GPRINT:temp_eau:LAST:"Mesure\: %.2lf" \
GPRINT:temp_eau:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_eau:MIN:"Mini\: %.2lf" \
GPRINT:temp_eau:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_ext_4h.png --start -4h --title="Temperature exterieure sur 4 heures" --vertical-label=$TEMP_SCALE \
DEF:temp_ext=$DIR/temp_cuve.rrd:temp_ext:AVERAGE \
LINE1:temp_ext$TEMP_EXT_COUL:"Temperature exterieure\n" \
GPRINT:temp_ext:LAST:"Mesure\: %.2lf" \
GPRINT:temp_ext:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_ext:MIN:"Mini\: %.2lf" \
GPRINT:temp_ext:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_tech_4h.png --start -4h --title="Temperature B.tech sur 4 heures" --vertical-label=$TEMP_SCALE \
DEF:temp_tech=$DIR/temp_cuve.rrd:temp_tech:AVERAGE \
LINE1:temp_tech$TEMP_TECH_COUL:"Temperature interne du boiter technique\n" \
GPRINT:temp_tech:LAST:"Mesure\: %.2lf" \
GPRINT:temp_tech:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_tech:MIN:"Mini\: %.2lf" \
GPRINT:temp_tech:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

#Graphs par jour
rrdtool graph $DIR/t_eau_24h.png --start -1d --title="Temperature eau sur 24 heures" --vertical-label=$TEMP_SCALE \
DEF:temp_eau=$DIR/temp_cuve.rrd:temp_eau:AVERAGE \
LINE1:temp_eau$TEMP_EAU_COUL:"Temperature de l'eau\n" \
GPRINT:temp_eau:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_eau:MIN:"Mini\: %.2lf" \
GPRINT:temp_eau:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_ext_24h.png --start -1d --title="Temperature exterieure sur 24 heures" --vertical-label=$TEMP_SCALE \
DEF:temp_ext=$DIR/temp_cuve.rrd:temp_ext:AVERAGE \
LINE1:temp_ext$TEMP_EXT_COUL:"Temperature exterieure\n" \
GPRINT:temp_ext:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_ext:MIN:"Mini\: %.2lf" \
GPRINT:temp_ext:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_tech_24h.png --start -1d --title="Temperature B.tech sur 24 heures" --vertical-label=$TEMP_SCALE \
DEF:temp_tech=$DIR/temp_cuve.rrd:temp_tech:AVERAGE \
LINE1:temp_tech$TEMP_TECH_COUL:"Temperature interne du boiter technique\n" \
GPRINT:temp_tech:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_tech:MIN:"Mini\: %.2lf" \
GPRINT:temp_tech:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

#Graphs par semaine
rrdtool graph $DIR/t_eau_1w.png --start -1w --title="Temperature eau sur 1 semaine" --vertical-label=$TEMP_SCALE \
DEF:temp_eau=$DIR/temp_cuve.rrd:temp_eau:AVERAGE \
LINE1:temp_eau$TEMP_EAU_COUL:"Temperature de l'eau\n" \
GPRINT:temp_eau:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_eau:MIN:"Mini\: %.2lf" \
GPRINT:temp_eau:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_ext_1w.png --start -1w --title="Temperature exterieure sur 1 semaine" --vertical-label=$TEMP_SCALE \
DEF:temp_ext=$DIR/temp_cuve.rrd:temp_ext:AVERAGE \
LINE1:temp_ext$TEMP_EXT_COUL:"Temperature exterieure\n" \
GPRINT:temp_ext:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_ext:MIN:"Mini\: %.2lf" \
GPRINT:temp_ext:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_tech_1w.png --start -1w --title="Temperature B.tech sur 1 semaine" --vertical-label=$TEMP_SCALE \
DEF:temp_tech=$DIR/temp_cuve.rrd:temp_tech:AVERAGE \
LINE1:temp_tech$TEMP_TECH_COUL:"Temperature interne du boiter technique\n" \
GPRINT:temp_tech:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_tech:MIN:"Mini\: %.2lf" \
GPRINT:temp_tech:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

#Graphs par mois
rrdtool graph $DIR/t_eau_1m.png --start -1m --title="Temperature eau sur 1 mois" --vertical-label=$TEMP_SCALE \
DEF:temp_eau=$DIR/temp_cuve.rrd:temp_eau:AVERAGE \
LINE1:temp_eau$TEMP_EAU_COUL:"Temperature de l'eau\n" \
GPRINT:temp_eau:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_eau:MIN:"Mini\: %.2lf" \
GPRINT:temp_eau:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_ext_1m.png --start -1m --title="Temperature exterieure sur 1 mois" --vertical-label=$TEMP_SCALE \
DEF:temp_ext=$DIR/temp_cuve.rrd:temp_ext:AVERAGE \
LINE1:temp_ext$TEMP_EXT_COUL:"Temperature exterieure\n" \
GPRINT:temp_ext:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_ext:MIN:"Mini\: %.2lf" \
GPRINT:temp_ext:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_tech_1m.png --start -1m --title="Temperature B.tech sur 1 mois" --vertical-label=$TEMP_SCALE \
DEF:temp_tech=$DIR/temp_cuve.rrd:temp_tech:AVERAGE \
LINE1:temp_tech$TEMP_TECH_COUL:"Temperature interne du boiter technique\n" \
GPRINT:temp_tech:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_tech:MIN:"Mini\: %.2lf" \
GPRINT:temp_tech:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

#Graphs 6 mois
rrdtool graph $DIR/t_eau_6m.png --start -25w --title="Temperature eau sur 6 mois" --vertical-label=$TEMP_SCALE \
DEF:temp_eau=$DIR/temp_cuve.rrd:temp_eau:AVERAGE \
LINE1:temp_eau$TEMP_EAU_COUL:"Temperature de l'eau\n" \
GPRINT:temp_eau:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_eau:MIN:"Mini\: %.2lf" \
GPRINT:temp_eau:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_ext_6m.png --start -25w --title="Temperature exterieure sur 6 mois" --vertical-label=$TEMP_SCALE \
DEF:temp_ext=$DIR/temp_cuve.rrd:temp_ext:AVERAGE \
LINE1:temp_ext$TEMP_EXT_COUL:"Temperature exterieure\n" \
GPRINT:temp_ext:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_ext:MIN:"Mini\: %.2lf" \
GPRINT:temp_ext:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_tech_6m.png --start -25w --title="Temperature B.tech sur 6 mois" --vertical-label=$TEMP_SCALE \
DEF:temp_tech=$DIR/temp_cuve.rrd:temp_tech:AVERAGE \
LINE1:temp_tech$TEMP_TECH_COUL:"Temperature interne du boiter technique\n" \
GPRINT:temp_tech:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_tech:MIN:"Mini\: %.2lf" \
GPRINT:temp_tech:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

#Graphs annuels
rrdtool graph $DIR/t_eau_1y.png --start -1y --title="Temperature eau sur 1 an" --vertical-label=$TEMP_SCALE \
DEF:temp_eau=$DIR/temp_cuve.rrd:temp_eau:AVERAGE \
LINE1:temp_eau$TEMP_EAU_COUL:"Temperature de l'eau\n" \
GPRINT:temp_eau:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_eau:MIN:"Mini\: %.2lf" \
GPRINT:temp_eau:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_ext_1y.png --start -1y --title="Temperature exterieure sur 1 an" --vertical-label=$TEMP_SCALE \
DEF:temp_ext=$DIR/temp_cuve.rrd:temp_ext:AVERAGE \
LINE1:temp_ext$TEMP_EXT_COUL:"Temperature exterieure\n" \
GPRINT:temp_ext:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_ext:MIN:"Mini\: %.2lf" \
GPRINT:temp_ext:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/t_tech_1y.png --start -1y --title="Temperature B.tech sur 1 an" --vertical-label=$TEMP_SCALE \
DEF:temp_tech=$DIR/temp_cuve.rrd:temp_tech:AVERAGE \
LINE1:temp_tech$TEMP_TECH_COUL:"Temperature interne du boiter technique\n" \
GPRINT:temp_tech:AVERAGE:"Moy\: %.2lf" \
GPRINT:temp_tech:MIN:"Mini\: %.2lf" \
GPRINT:temp_tech:MAX:"Maxi\: %.2lf" \
COMMENT:"Dernier releve $JOUR"

#Copie les graphs dans le repertoire du site local /var/www/cuve/img
#transfert.sh

#Transfert des donnees sur le serveur Web
chown www-data:www-data $source
sudo mv $source $destination
creation_graph.sh

Pour des raisons de sécurité, je ne voulais pas mettre mon raspberry pi directement sur le net. J’ai pris l’option de transférer les données (images) sur une pauvre page web consultable de partout. Le script pousse les images toutes les 15 minutes.

#! /bin/bash

######  Variables #############
TARGET_FTP="/var/www/cuve/img/ /img"
FTP="ftpperso.free.fr" LOGIN="#######" PASS="########"
MAIL="#######@free.fr" JOUR=$(date '+%d-%m-%Y %H-%M-%S')
#################################

# Balance les fichier sur le ftp free
lftp -e "open -u $LOGIN,$PASS $FTP; mirror -n -R $TARGET_FTP ;
bye";
# Message mail automatique
#echo "Mise a jour du site = ok" $JOUR | mail -s "Eyes At Home" $MAIL;
# Log de confirmation
#echo "Copie des fichiers et envoi de mail a "$JOUR >>/var/log/transfert.log;
copie_site.sh

La profondeur:

Le script se nomme capa.py. Il se lance en tâche planifiée toutes les 5 minutes. Comme pour les températures les données sont transmises à une base RRDTOOL. Le capteur doit être raccordé sur les pins 17 et 23 (que vous pouvez adapter à votre guise sous réserve de modifier les paramètres dans le script).

GPIO_TRIGGER = 17
GPIO_ECHO = 23

J’utilise encore une base rrdtool pour le stockage des données. La base créée se nomme capa_cuve.rrd.

rrdtool create capa_cuve.rrd --start N --step 300 \
DS:haut:GAUGE:600:1:130 \
DS:capa:GAUGE:600:0:2600 \
RRA:LAST:0.5:1:12 \
RRA:MAX:0.5:1:12 \
RRA:MIN:0.5:1:12 \
RRA:AVERAGE:0.5:1:12 \
RRA:LAST:0.5:1:288 \
RRA:MAX:0.5:1:288 \
RRA:MIN:0.5:1:288 \
RRA:AVERAGE:0.5:1:288 \
RRA:LAST:0.5:12:168 \
RRA:MAX:0.5:12:168 \
RRA:MIN:0.5:12:168 \
RRA:AVERAGE:0.5:12:168 \
RRA:LAST:0.5:12:720 \
RRA:MAX:0.5:12:720 \
RRA:MIN:0.5:12:720 \
RRA:AVERAGE:0.5:12:720 \
RRA:LAST:0.5:288:365 \
RRA:MAX:0.5:288:365 \
RRA:MIN:0.5:288:365 \
RRA:AVERAGE:0.5:288:365
creation_base.sh

Le script suivant a subi une modification. A l’origine, il est extrait d’ici |R|a|s|p|b|e|r|r|y|P|i|-|S|p|y|.|c|o|.|u|k| par Matt Hawkins. Repris par beaucoup d’entre nous, il offre un bon apprentissage de la sonde. Pour ma part, il me permet de déterminer la hauteur d’eau se trouvant dans la cuve et estimer son volume par calcul.
Je ne suis pas à 20 litres prés, l’estimation est suffisante.

#!/usr/bin/python
#+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#|R|a|s|p|b|e|r|r|y|P|i|-|S|p|y|.|c|o|.|u|k|
#+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#
# ultrasonic_1.py
# Measure distance using an ultrasonic module
#
# Author 1ere partie: Matt Hawkins
# Date   : 09/01/2013
# Author 2eme partie: Jose
# Date   : 10/05/2013

# Import required Python libraries
import time
import RPi.GPIO as GPIO
import rrdtool
import datetime

# Use BCM GPIO references
# instead of physical pin numbers
GPIO.setmode(GPIO.BCM)

# Define GPIO to use on Pi
GPIO_TRIGGER = 17
GPIO_ECHO = 23

# Set pins as output and input
GPIO.setup(GPIO_TRIGGER,GPIO.OUT)  # Trigger
GPIO.setup(GPIO_ECHO,GPIO.IN)      # Echo

# Set trigger to False (Low)
GPIO.output(GPIO_TRIGGER, False)

# Allow module to settle
time.sleep(0.5)

# Send 10us pulse to trigger
GPIO.output(GPIO_TRIGGER, True)
time.sleep(0.00001)
GPIO.output(GPIO_TRIGGER, False)
start = time.time()
while GPIO.input(GPIO_ECHO)==0:
start = time.time()

while GPIO.input(GPIO_ECHO)==1:
stop = time.time()

# Calculate pulse length
elapsed = stop-start

# Distance pulse travelled in that time is time
# multiplied by the speed of sound (cm/s)
distance = elapsed * 34300

# That was the distance there and back so halve the value
distance = distance / 2

# Mesure de la hauteur d'eau en faisant la différence entre la hauteur cuve pleine et le capteur 18 cm
fond=131.5
distance = fond - distance

# Fonction de calcul du volume théorique de la cuve
largeur=100
longueur=210

vol = largeur * longueur * distance
volume = vol / 1000

# Décoche les commentaires pour consulter les logs
print  "%.0f" % distance+" "+"%.0f" % volume

#Transfert dans la base rrdtool
database_file = "/home/super/programmes/profondeur/capa_cuve.rrd"
rrdtool.update(database_file, "N:%.2f" % distance+":%.0f" % volume)

# Reset GPIO settings
GPIO.cleanup()
capa.py

Quelques explications sur la mesure. Le script mesure le temps que met l’écho a revenir. J’ai pris le temps de mesurer la hauteur d’eau lorsque la cuve était pleine. Le capteur à ultrason se trouve dirigé vers la surface de l’eau et à une hauteur de 17 cm. Aprés la mesure, je retire la hauteur théorique pleine. Après un petit calcul de volume, j’estime la capacité en eau de la cuve.
On continue avec un script qui génère des graphiques.

#!/bin/bash
DIR="/home/super/programmes/profondeur"

# Pour le deplacement des fichiers img vers le repertoire du serveur web.
source='/home/super/programmes/profondeur/*_cuve_*.png'
destination='/var/www/cuve/img'
JOUR=$(date '+%d-%m-%Y %H-%M-%S')

# Affichage en degre C
ECHELLE="cm"
VOLUME="litres"

#Choix des couleurs
COUL_ECHELLE="#000099" COUL_VOLUME="#FF0000"

#Graphs par heure
rrdtool graph $DIR/h_cuve_4h.png --start -4h --title="Hauteur d'eau sur 4 heures" --vertical-label="cm"  \
DEF:haut=$DIR/capa_cuve.rrd:haut:AVERAGE \
LINE1:haut$COUL_ECHELLE:"Hauteur d'eau en $ECHELLE\n" \
GPRINT:haut:LAST:"Mesure\: %.0lf" \
GPRINT:haut:AVERAGE:"Moy\: %.0lf" \
GPRINT:haut:MIN:"Mini\: %.0lf" \
GPRINT:haut:MAX:"Maxi\: %.0lf" \
COMMENT:" \n" \
COMMENT:"Dernier releve $JOUR"

rrdtool graph $DIR/v_cuve_4h.png --start -4h --title="Volume sur 4 heures" --vertical-label="Litres" \
DEF:capa=$DIR/capa_cuve.rrd:capa:AVERAGE \
LINE1:capa$COUL_VOLUME:"Volume de la cuve en $VOLUME\n" \
GPRINT:capa:LAST:"Mesure\: %.0lf" \
GPRINT:capa:AVERAGE:"Moy\: %.0lf" \
GPRINT:capa:MIN:"Mini\: %.0lf" \
GPRINT:capa:MAX:"Maxi\: %.0lf" \
COMMENT:" \n" \
COMMENT:"Derniere estimation $JOUR"

#Graphs par jour
rrdtool graph $DIR/h_cuve_24h.png --start -1d --title="Hauteur d'eau sur 24 heures" --vertical-label="cm"  \
DEF:haut=$DIR/capa_cuve.rrd:haut:AVERAGE \
LINE1:haut$COUL_ECHELLE:"Hauteur d'eau en $ECHELLE\n" \
GPRINT:haut:AVERAGE:"Moy\: %.0lf" \
GPRINT:haut:MIN:"Mini\: %.0lf" \
GPRINT:haut:MAX:"Maxi\: %.0lf" \

rrdtool graph $DIR/v_cuve_24h.png --start -1d --title="Volume sur 24 heures" --vertical-label="Litres" \
DEF:capa=$DIR/capa_cuve.rrd:capa:AVERAGE \
LINE1:capa$COUL_VOLUME:"Volume de la cuve en $VOLUME\n" \
GPRINT:capa:AVERAGE:"Moy\: %.0lf" \
GPRINT:capa:MIN:"Mini\: %.0lf" \
GPRINT:capa:MAX:"Maxi\: %.0lf" \

#Graphs par semaine
rrdtool graph $DIR/h_cuve_1w.png --start -1w --title="Hauteur d'eau sur 1 semaine" --vertical-label="cm" \
DEF:haut=$DIR/capa_cuve.rrd:haut:AVERAGE \
LINE1:haut$COUL_ECHELLE:"Hauteur d'eau en $ECHELLE\n" \
GPRINT:haut:AVERAGE:"Moy\: %.0lf" \
GPRINT:haut:MIN:"Mini\: %.0lf" \
GPRINT:haut:MAX:"Maxi\: %.0lf" \

rrdtool graph $DIR/v_cuve_1w.png --start -1w --title="Volume sur 1 semaine" --vertical-label="Litres" \
DEF:capa=$DIR/capa_cuve.rrd:capa:AVERAGE \
LINE1:capa$COUL_VOLUME:"Volume de la cuve en $VOLUME\n" \
GPRINT:capa:AVERAGE:"Moy\: %.0lf" \
GPRINT:capa:MIN:"Mini\: %.0lf" \
GPRINT:capa:MAX:"Maxi\: %.0lf" \

#Graphs par mois
rrdtool graph $DIR/h_cuve_1m.png --start -1m  --title="Hauteur d'eau sur 1 mois" --vertical-label="cm" \
DEF:haut=$DIR/capa_cuve.rrd:haut:AVERAGE \
LINE1:haut$COUL_ECHELLE:"Hauteur d'eau en $ECHELLE\n" \
GPRINT:haut:AVERAGE:"Moy\: %.0lf" \
GPRINT:haut:MIN:"Mini\: %.0lf" \
GPRINT:haut:MAX:"Maxi\: %.0lf" \

rrdtool graph $DIR/v_cuve_1m.png --start -1m  --title="Volume sur 1 mois" --vertical-label="Litres" \
DEF:capa=$DIR/capa_cuve.rrd:capa:AVERAGE \
LINE1:capa$COUL_VOLUME:"Volume de la cuve en $VOLUME\n" \
GPRINT:capa:AVERAGE:"Moy\: %.0lf" \
GPRINT:capa:MIN:"Mini\: %.0lf" \
GPRINT:capa:MAX:"Maxi\: %.0lf" \

#Graphs pour 6 mois
rrdtool graph $DIR/h_cuve_6m.png --start -25w  --title="Hauteur d'eau sur 6 mois" --vertical-label="cm" \
DEF:haut=$DIR/capa_cuve.rrd:haut:AVERAGE \
LINE1:haut$COUL_ECHELLE:"Hauteur d'eau en $ECHELLE\n" \
GPRINT:haut:AVERAGE:"Moy\: %.0lf" \
GPRINT:haut:MIN:"Mini\: %.0lf" \
GPRINT:haut:MAX:"Maxi\: %.0lf" \

rrdtool graph $DIR/v_cuve_6m.png --start -25w  --title="Volume sur 6 mois" --vertical-label="Litres" \
DEF:capa=$DIR/capa_cuve.rrd:capa:AVERAGE \
LINE1:capa$COUL_VOLUME:"Volume de la cuve en $VOLUME\n" \
GPRINT:capa:AVERAGE:"Moy\: %.0lf" \
GPRINT:capa:MIN:"Mini\: %.0lf" \
GPRINT:capa:MAX:"Maxi\: %.0lf" \

#Graphs par an
rrdtool graph $DIR/h_cuve_1y.png --start -1y  --title="Hauteur d'eau sur 1 an" --vertical-label="cm" \
DEF:haut=$DIR/capa_cuve.rrd:haut:AVERAGE \
LINE1:haut$COUL_ECHELLE:"Hauteur d'eau en $ECHELLE\n" \
GPRINT:haut:AVERAGE:"Moy\: %.0lf" \
GPRINT:haut:MIN:"Mini\: %.0lf" \
GPRINT:haut:MAX:"Maxi\: %.0lf" \

rrdtool graph $DIR/v_cuve_1y.png --start -1y  --title="Volume sur 1 an" --vertical-label="Litres" \
DEF:capa=$DIR/capa_cuve.rrd:capa:AVERAGE \
LINE1:capa$COUL_VOLUME:"Volume de la cuve en $VOLUME\n" \
GPRINT:capa:AVERAGE:"Moy\: %.0lf" \
GPRINT:capa:MIN:"Mini\: %.0lf" \
GPRINT:capa:MAX:"Maxi\: %.0lf" \

#Transfert des données sur le serveur Web
chown www-data:www-data $source
sudo mv $source $destination
creation_graphs.sh

La page Web:

Basée sur le travail d’Idleman, la page de gestion est issue d’ici. Elle est tributaire de l’installation préalable d’un serveur apache ou autre. Si vous suivez les tutos d’Idleman depuis le début, cela ne devrait pas poser de problème. Bien entendu, vous pouvez installer votre serveur web préféré.

Une action sur le lien de page met en route la pompe de relevage ou la prise électrique qui sont commandées par l’intermédiaire de la carte aux deux relais. La page de configuration, vous permet de choisir les GPIO qui commanderont le ou les relais.

L’insertion des différents graphiques se fait par l’intermédiaire de balises <img> qui pointent sur le répertoire contenant les graphiques.

Et maintenant:

J’ai certainement oublié des choses ou je suis passé un peu vite sur certaines explications. Cette page et ces sous rubriques me permettent de garder en mémoire les scripts utilisés et les schémas. Vous l’avez certainement compris, ils ne sont pas tellement finalisés et doivent faire frissonner les puristes j’en suis conscient.

Bilan et évolutions:

Depuis un an, ce raspberry se trouve dans la cuve. Malgré l’environnement, il fonctionne très bien parfois mieux que celui que je maltraite sur mon bureau. 🙂

J’ai eu chaud à l’automne dernier car lors d’un violent orage, le trop plein de la cuve n’arrivait pas à tout absorber. C’est un peu normal car la totalité des eaux provenant de la toiture se déversent dedans. Je voyais le niveau d’eau monter et malgré la mise en route de la pompe immergée, l’eau à fini par noyer le capteur.
Après quelques jours de séchage, il a repris du service comme à la manœuvre.

Dans les évolutions futures, je pense remplacer le raspberry de la cuve par un arduino. Le fonctionnement serait sensiblement identique. Les deux appareils seraient raccordés par une liaison I2C car la liasion série est déjà utilisée sur un autre serveur qui collecte les données provenant du compteur EDF. Ceci me permettrait de récupérer un raspberry à brève échéance.

i2c_Bus

Le développement de mon nouveau projet est finalisé. Dés que j’aurai un peu de temps, je m’occuperai de sa rédaction et j’aurais le plaisir de vous retrouver ici.

 

Les sources:

Un grand merci à :

http://arduino103.blogspot.fr/
http://forum.pcinpact.com/topic/165594-raspberry-pi-fabriquons-des-trucs/
http://blog.idleman.fr/
http://www.manuel-esteban.com/
http://smhteam.info/blog/2011/11/15/faire-un-capteur-de-niveau-pour-une-cuve-deau/

Pleins d’autres sources ici

Avec une mention particulière au magasin en ligne http://shop.mchobby.be/fr/ qui grâce à ses traductions et à l’investissement personnel de son auteur nous font grandement progresser.

Augmenter le nombre de capteurs du bus one-wire.

Bonjour,

Si tout comment moi, vous aimez utiliser les capteurs DS18B20 ds18b20pour mesurer les températures de votre environnement, vous avez certainement atteint les limites des 10 capteurs possibles sur le bus one-wire (GPIO4) de votre rapsberry pi.

Et oui, le module w1-gpio est limité à 10 capteurs alors qu’en théorie le nombre de capteurs sur un bus one-wire est quasi illimité.

La solution m’a été apporté par Rinty lors d’un échange sur le site http://www.framboise314.fr/mesure-de-temperature-1-wire-ds18b20-avec-le-raspberry-pi/ que l’on ne présente plus.

Pour dépasser la limite, il suffit de créer un fichier wire.conf dans /etc/modprobe.d/
Vous écrivez à l’intérieur « options wire max_slave_count=20 » (sans les guillemets).

Après un reboot, comme par magie, le nombre max de capteurs est passé de 10 à 20.

Elle est pas belle la vie 🙂

Mon projet domotique (le matériel)

Bonjour visiteur de passage.

Dans une premier temps, je détaillerai la liste du matériel nécessaire au projet annoncé lors d’un article précédent. Puis, je présenterai un schéma de principe.

  • Un raspberry pi modèle B avec carte SD 8G classe 10.

raspberry-pi-model-b

  • Dix capteurs de température de type DS18B20 (un pour chaque pièce dans mon cas).ds18b20
  • Un afficheur LCD I2C de 20*4.

lcd_i2c

  • Des résistances.
  • Un composant permettant d’étendre le bus I2C P82B715PN.

P82B715

  • Un optocoupleur SFH620A permet la télérelève EDF via le port série.

sfh620a

  • Un pi cobbler pour assurer la liaison entre le raspberry et le circuit.

Adafruit_Pi_Cobbler_Breakout_Kit

  • Une série de relais permettant de commande le fil pilote des zones de chauffage et les ouvertures de portes (garage et portail).

relais

J’utilise également une alimentation 5 volts différentes pour tous les circuits de commandes évitant ainsi de trop tirer sur les ports GPIO et le rapsberry pi en général.

  • Une alimentation 5 volts 2 ampères

alimentation5v

  • Un interrupteur à souder.
  • Une diode Led rouge (au choix) pour la présence secteur.
  • Une diode 1N4148.

J’en profite pour remercier le père de mon collègue Nico qui, ancien prof de techo, m’a donné un stock énorme de composants électroniques 🙂

Voici le schéma de principe de l’installation.

Eyesathome

That’s all folks 🙂

 

Projet domotique complet (intro)

Bonjour à tous,

Je continue de mettre au propre toutes mes feuilles de brouillon histoire de faire un peu de place. Aujourd’hui, je vais commencer à détailler un projet de supervision domotique à base d’un raspberry pi. Après une phase de tests de plus de 6 mois sur mon bureau, il était temps de le mettre en production.

Tout ça c’est bien mais il fait quoi ton rapsberry ?

Sachant que je cherche à optimiser notre consommation électrique, j’ai commencé par chercher sur le net tout les sujets tournant autour de la gestion du chauffage, de l’estimation de la consommation edf etc etc.
Dans la rubrique « Sources » vous trouverez les sites m’ayant grandement inspirés.

Pour répondre à ta question cher lecteur, mon rapsberry fait les actions suivantes:
– Mise en route du chauffage électrique des chambres et de la salle de bain en fonction d’un google agenda,
– Télérelève EDF afin de connaitre en temps réel les consommations,
– Collecte des températures de toutes les pièces via bus-one wire déjà utilisé dans l’autre projet,
– Collecte les données de l’autre projet (gestion de la cuve) pour l’affichage des valeurs,
– Récupération et affichage de toutes ces données sur un afficheur I2C situé dans le salon:

– Zone de chauffage en marche,
– Température des pièces,
– Température, niveau et volume de l’eau de la cuve,
– Heures creuses ou pleines,
– Consommation EDF instantanée.

Le tout en s’intégrant le plus discrètement possible dans la maison afin que mon niveau Waf(1) ne descende pas trop.

Définition Wikipédia Waf : Ce terme est généralement employé pour désigner un objet traditionnellement masculin (typiquement les équipements informatiques, hi-fi ou vidéo) dont les propriétés ou les fonctionnalités le rendent acceptable auprès des dames (et notamment de la compagne du propriétaire dudit objet)

Cela sous entend des sondes très discrètes, un boitier pas trop moche dans le garage (enfin j’me comprends ;))

Pour la partie Web, j’utilise le cœur domotique Yana-server développé par Idelman et la communauté autour de ce forum. J’utilise certains des plugins à disposition. J’en ai développé un spécifique pour l’affichage des températures par pièce. Bref, je préfère vous laisser découvrir l’environnement et les multiples possibilités.

Je rédige en ce moment les différentes parties, n’hésitez pas à revenir régulièrement.

Pour finir cette introduction, je pose quelques photos du résultat final.

sonde_murale

Le petit point central est la sonde de température.

srv1a

Le serveur (srv-1) se trouve dans une boite recyclée dans le garage.

vue_piece

Vue de la page web de la température d’une chambre

@ bientôt