FERG : Mon vieux compteur EDF connecté en mode framboise

Medium rn3tjbkd5lgvxmq3j6ji

Difficulté:

ou comment relever sa consommation électrique zone par zone à l’aide d’un compteur EDF à roue, de quelques tores et d’un raspberry pi (Nouvelle option : ajout d’un arduino (ou équivalent) pour fiabiliser le comptage)



Quel radin (ou juste soucieux de dépenser moins) un peu geek n’a jamais voulu savoir ce qu’il dépense en électricité et pourquoi?


C’est un lisant le très bon blog de Sebastien Warin (http://sebastien.warin.fr/2015/03/24/2478-senergy-la-solution-de-monitoring-des-ressources-energetiques-de-la-maison-geek-is-in-da-house-2015/) que l’idée m’est venue de réaliser ce compteur connecté.
Contrairement à Sébastien, je ne m’occupe pas de l’eau et du gaz, mais uniquement de l’électricité (plus du fuel, mais c’est pour un autre tuto).


L’idée est :


  • de lire chaque tour de la roue du compteur EDF pour en déduire puissance instantanée et énergie consommée.
  • de lire le courant dans quelques circuits à l’aide de tores
  • de lire l’état du relais jour-nuit

Mais aussi d’en déduire d’autre valeurs indirectes :


  • La consommation d’un circuit comme étant la somme ou la différence de plusieurs circuits
  • La consommation d’un appareil électrique dont je connais la puissance (ex : sur le même circuit un congélateur de 100W et un frigo de 150W. Avec une seule mesure, nous allons calculer deux consommations distinctes)

Et bien sûr prendre des décisions :


  • Délester un circuit (exemple le chauffe eau) quand on atteint la limite de consommation du compteur
  • Alerter quand le frigidaire consomme trop (la porte doit être ouverte)

Toutes les informations sont stockées dans une base mysql (ou mariaDB). Elle peut être sur le raspberry ou n’importe où ailleurs (dans mon cas sur un NAS Synology).


Et comme j’aime bien le python : tout est en Python!
avec mes bibliothèques qui vont bien :


  • FGPIO pour gérer toutes le matériel avec les GPIO du RPI

  • FERG pour le code spécifique au projet de compteur connecté

  • FUTIL mes utilitaires.

  • Ce tutoriel s’applique à bien détailler les techniques et matériel mis en oeuvre.

    Matériel

    Medium dguyreraoyccl56ztday

    Budget:

    1 €

    J’ai utilisé :

    • Un rasperry pi 2 (ou autre version) : Disponible ici
    • Alimentation 5V, 2A : Disponible ici
      et carte micro SD 16Go classe 10 pour raspberry : Disponible ici
    • Un capteur optique : QRD114
    • 6 tores SCT013 30A/1V : Disponible ici
    • 6 prises jacks femelles à souder : Disponible ici
    • Un convertisseur analogique/numérique MCP3008 : Disponible ici
    • Quelques résistances ( 1×1 kOhm, 2×100 Ohm, 1×220 Ohm, 1×680 Ohm) :
    • Une led
    • Une capa de 47 nF 400Volt : Disponible ici
    • Une capa de 100µF 10 Volt : Disponible ici
    • Une diode 1N4007 : Disponible ici
    • Un optocoupleur PC817 : Disponible ici
    • Connectique : nappe, borniers, …
    • En option : buzzer
    • Une croix de communiant (ou n’importe quoi d’autre pour fixer le capteur optique sur le compteur EDF
    • Une boite plexo pour enfermer tous ce qui touche au 220V (relais et capteur Jour_Nuit)
    • option : un arduino ou puce atmega

    http://ouiaremakers.com/wp-includes/images/media/document.png , http://ouiaremakers.com/wp-includes/images/media/document.png , http://ouiaremakers.com/wp-includes/images/media/document.png

    Etape 1 : Capter les tours de roue du compteur

    C’est le point un peu technique du projet : il s’agit de capter le passage de la bande noire peinte sur la roue du compteur.
    Pour cela, nous allons utiliser un capteur optique qui émet avec, une led, une lumière Infra-rouge et qui transmet un signal issu de son récepteur. Le signal varie en fonction de la manière dont la lumière est renvoyée.
    Quand la roue passe sans la bande, nous mesurons un voltage faible, quand la bande noire passe, le voltage augmente un peu.
    La difficulté est de bien positionner le capteur en face de la roue et faire en sorte que ça ne bouge plus ensuite. Après avoir essayé plusieurs choses, j’ai finit par y mettre ma vieille croix de communiant (à l’envers quand même, c’est mon coté anté-christ).
    Bien faire attention à ce que ça ne fasses pas trop hacker : le technicien EDF risque de tiquer un peu s’il voit des fils sortir de son compteur!!!

    Branchement du capteur : voir schéma (j’ai utilisé comme résistance pull-up : 100 Ohm).
    (Pour tous les schémas électriques : voir l’étape sur la réalisation de la carte électronique)

    Version sans Arduino (lecture directe):

    Comme le Raspberry Pi n’a pas d’entrée analogique, on utilise un module MCP3008 qui possède 8 entrées analogiques et communique avec le RPI via SPI. Nous détaillerons plus bas son fonctionnement.
    Algorithme :

    En python, tout le matériel est géré via la librairie FPGIO avec les classes suivantes:

    • rpiduino_io pour le raspberry en lui même (qui peut aussi être un pcduino si vous voulez)
    • mcp300x_hspi_io pour le module MCP3008
    • qrd1114_io pour le capteur optique

    Je ne vais pas tout détailler le code (nous verrons par la suite le fichier de config plus en détail), mais juste l’accés au voltage du capteur optique va s’écrire:

    pc = rpiduino_io()
    mcp3008 = mcp3008_hspi_io()
    capteur_roue = qrd1114_analog_io(mcp3008.pin[0])
    voltage = capteur_roue.read()

    Ensuite, on va juste lire en permanence la valeur du capteur pour détecter la bande noire. Là je vous laisse allez voir le code dans FERG/compteur_edf.py.

    Alternative : avec un microcontroleur (un arduino par exemple) :

    Comme il arrive que la roue du compteur tourne très vite et que notre raspberry soit occupé à faire autre chose, il est possible de rater quelques tours de roues. pour pallier à ça, la solution la plus simple est d’utiliser un micro-contrôleur (de type arduino) pour lire les tours de roues et d’envoyer les informations au raspberry pi. Pour envoyer les informations, j’utilise le mode i2c (avec l’arduino en mode esclave et le raspberry pi en mode maître).

    L’alternative avec arduino est détaillée à la fin.

    http://ouiaremakers.com/wp-includes/images/media/text.png

    Etape 2 : Les tores pour mesure des circuits “internes”

    Medium pqvm4xs0rq31g2douzll

    Je ne vous refais pas le cours de physique sur les courants induits et les champs magnétiques (en fait mes souvenirs commencent à dater), mais le principe du tore est que si vous placez un morceau de ferrite en forme de tore autour d’un câble électrique (un seul conducteur : la phase ou le neutre, mais pas les deux) et que vous réalisez une bobine autour du tore de ferrite, vous obtiendrez un courant proportionnel au courant dans le câble.
    Vous pouvez réaliser votre tore tout seul, mais le plus simple est d’acheter des tores tout fait, par exemple les SCT-013-030 qui permettent une lecture directe du courant. S’il passe 30 Ampères dans le tore, il délivrera 1 Volt à ses bornes.
    Il existe plusieurs références de tore ( de 5A à 60A). Je vous déconseille juste le SCT-013-00 qui permet de mesurer jusque 100A, mais qui nécessite une résistance de charge.

    Comme vous pouvez le voir sur la photo de mon tableau électrique, j’ai casé 6 tores à des endroits stratégiques. A vous de déterminer ce que vous souhaitez mesurer.

    Branchement des tores
    Pour mesurer le voltage des tores, nous utiliserons notre module MCP3008 (il reste encore 7 entrées de libre).
    Les tores sont livrés avec une prise jack 3.5mm. J’ai utiliser des prises jack femelles pour pourvoir les brancher facilement. Ensuite, on branche juste un pôle sur le 0V et l’autre sur une entrée du MCP3008.
    Comme le courant mesuré est alternatif, le voltage mesuré est aussi alternatif. Mais pas de soucis, ma librairie gère la mesure tout bien et retourne une mesure cohérente.

    Code
    Déclaration des tores :

    tores = {'circuit_1': SCT013_v_io(mcp3008.pin[1], Imax = 30.0, Vmax = 1.0), 
    			'circuit_ce': SCT013_v_io(mcp3008.pin[2], Imax = 30.0, Vmax = 1.0), 
    			'circuit_frigo': SCT013_v_io(mcp3008.pin[3], Imax = 30.0, Vmax = 1.0), 
    			'circuit_ext_haut': SCT013_v_io(mcp3008.pin[4], Imax = 30.0, Vmax = 1.0), 
    			'circuit_frigo_cuisine': SCT013_v_io(mcp3008.pin[5], Imax = 30.0, Vmax = 1.0), 
    			'circuit_divers': SCT013_v_io(mcp3008.pin[6], Imax = 30.0, Vmax = 1.0) 
    			}
    #Si jamais vous habitez dans un endroit un peu exotique, il faudra ajouter les paramètres V0 (=240.0 par defaut) et freq (=50.0 par defaut).

    Mesure de la puissance :
    dans FERG/installation.py, installation.enregistre_circuits_secondaires() mesure la puissance instantanée de chaque circuit toutes les secondes et enregistre une moyenne au bout d’une minute.

    Etape 3 : le module analogique – numérique

    Medium xf54w8vv40lfgi7wjwdp

    Je ne vais pas détailler le fonctionnement de ce module, vous trouverez bien ça ailleurs. Je vous invite juste à lire la datasheet ainsi que ma classe python (voir FGPIO) mcp300x_hspi_io.

    Le MCP3008 permet de convertir 8 entrées analogiques sur 10 bits (soit 2^10= 1024 valeurs).
    Si votre besoin n’est que de 4 entrées, il y a aussi le MCP3004.
    Branchement des pattes:

    —–pin—– Vdd Voltage d’alimentation : 5V Vref Voltage qui va correspondre au 1024 : on va mettre 3.3V Agrnd 0V CLK Horlogue : GPIO11 du RPI (SPI0_SCLK) Dout GPIO09 du RPI (SPI0_MISO) Din GPIO10 du RPI (SPI0_MOSI) CS GPIO8 du RPI (SPI0_CE0_N) DGND 0V

    En python avec la librairie FGPIO, ça donne :

    from rpiduino_io import *
    from FGPIO.mcp300x_hspi_io import*
    import time
    pc = rpiduino_io()
    mcp3008 = mcp3008_hspi_io(bus=0, device=0, vref=3.3)
    ch0 = mcp3008.pin[7]
    while True:
         print 'Voltage : %.2f Volts' % ch0.get_voltage()
         time.sleep(0.5)
    

    A noter (mais en fait on s’en fout) : J’ai crée une autre classe pour gérer ce convertisseur : mcp300x_io : sans utiliser le spi du système et tout faire à la main. Mais dans la pratique, je n’utilise jamais. C’était juste un truc de puriste. Seul utilité : on peut utiliser n’importe quelle pin du RPI.

    http://ouiaremakers.com/wp-includes/images/media/document.png

    Etape 4 : Détecteur jour nuit

    Medium xrnjaojdjwt2y8vei06h

    Pour savoir si nous sommes en horaire de jour ou de nuit, le plus simple est de regarder l’heure.
    Je trouvais ça un peu trop simple, et je ne sais pas pourquoi, ça m’embêtais de mettre une heure en dure quelques part.
    J’ai donc voulu créer un capteur qui va détecteur la présence d’une tension au borne du relais jour/nuit.
    (en fait j’ai googlé un peu et recopié un circuit qui va bien).
    Je vous laisse regarder les schémas…
    D’un coté on branche le neutre et la phase 220V sortie du relais jour/nuit, de l’autre le 0V et une entrée du Rpi.

    Pour ce qui est du code avec la librairie FGPIO:

    pc = rpiduino_io()
    capteur_heure_creuse = bt_io(pc.bcm_pin(24))
    capteur_heure_creuse.read()
    


    (bt_io est à la base un bouton poussoir qui met à la masse une entrée du RPI configurée en mode PULLUP)

    http://ouiaremakers.com/wp-includes/images/media/default.png

    Etape 5 : Réalisation de la carte électronique

    Medium frlwzejxuwrpnvs2hm1i

    Sur une carte pour prototype, j’ai souder

    • en haut un connecteur 20 pins pour les GPIO du raspberry pi 2
    • au centre le MCP3008 (sur un connecteur un peu grand pour lui!)
    • à gauche les connecteurs pour le détecteur optique et ses resistances
    • en haut à gauche, une led qui va s’allumer quand la roue fait un tour (pratique pour vérifier si ça marche bien)
    • en bas les 6 prises jack pour les tores
    • au dessus du tore n°6 : un connecteur pour le détecteur de tension jour/nuit
    • encore au dessus, un connecteur 6 pins pour piloter des relais
    • enfin au centre, un buzzer (que je n’utilise pas vu que enerve pas mal la famille avec qui je vie)

    Je ne suis pas le roi de la soudure, mais bon avec un peu de patience on y arrive.

    http://ouiaremakers.com/wp-includes/images/media/default.png

    Etape 6 : Les relais

    Medium itfywlg4c8rjua9r6b9j

    Des petits relais 10A existent dans toutes les configurations (par 1, 2, 4, 6, …). Personnellement, j’aime bien les modules de 1 avec deux petites diodes pour pouvoir tester tranquillement sans brancher au circuit 220V.
    Ils se pilotent tous simplement avec 2+nb de modules pins :

    Vcc Voltage d’alimentation : 5V In1 Une sortie du Rpi pour basculer le relais In… Une sortie du Rpi pour basculer le relais Gnd 0V

    Code
    Encore la bibliothèque FGPIO, même si dans ce cas c’est un peu trivial!

    from FGPIO.relay_io import *
    deleste_chauffe_eau = relay_io(pc.bcm_pin(23))
    deleste_chauffe_eau.off()
    deleste_chauffe_eau.on()
    

    Etape 7 : Branchement de tous les composants

    Medium jp8qyyoh5izsjbk8tlq8

    Pour plus de sécurité, j’ai séparer les deux circuits électrique :

    • dans une boite plexo, tous ce qui a du 220V : le (ou les) relais et le détecteur de tension jour/nuit
    • le reste tranquille à la vue de tous … qui ouvrent l’armoire où est le compteur électrique

    Pour brancher le raspberry au circuit j’utilise une vieille nappe IDE.
    Pour le détecteur optique, un bout de câble réseau (ou téléphone).
    Les tores sont fournit avec des câbles assez grands.
    Pour l’accès au réseau, je me suis branché en ethernet, mais en wifi, ça marche aussi.

    Etape 8 : La raspberry pi dans tous ça.

    Je ne vais pas vous expliquer comment installer un système sur raspberry pi. Pour ma part, j’ai installé rasbian (Wheezy).
    Il vous faudra aussi installer pip :

    mkdir install
    cd install/
    wget https://pypi.python.org/packages/source/d/distribute/distribute-0.7.3.zip
    unzip distribute-0.7.3.zip
    cd distribute-0.7.3
    sudo python setup.py install
    sudo easy_install pip
    


    Ensuite, pour installer mes bibliothèques python:

    sudo pip install FGPIO
    sudo pip install FERG
    sudo pip install FUTIL
    

    Et la bibliothèque mysql.connector

    sudo pip install mysql.connector
    

    A noter que le setup de FERG créé un repertoire /opt/FERG pour y placer les programmes principale comptage.py et chk_alertes.py ainsi le fichier de config config.py. Il créé aussi un service “comptage” qui s’exécute automatiquement au boot. Si ça vous défrise : sudo sysv-rc-conf

    Le programme chk_alertes.py va calculer les consommations des circuits non mesurés, gérer le délestage et envoyer des alertes si besoin. Pour que ça fonctionne, il faut l’exécuter de temps en temps. Pour cela, il y a crontab :

    sudo crontab -e -u root
    #Ajouter cette ligne :
    */10 * * * * sudo python /opt/FERG/chk_alertes.py

    Etape 9 : Base SQL

    Medium pzr5mtrnfaej2otsuayq

    Toutes les données vont être stockées dans une base de données MySQL (ou équivalent). La base peut être hébergée n’importe où. Personnellement, je l’ai mise sur un NAS Synology, mais on peut aussi laisser la base sur le raspberry pi.
    J’ai joint le fichier des instructions SQL pour créer la base. Il suffira donc d’importer la base avec votre gestionnaire de base de données (phpMyAdmin pour ma part).

    http://ouiaremakers.com/wp-includes/images/media/archive.png

    Etape 10 : Fichier de configuration

    Medium h3gvrfapztwtlxsgdw9o

    Lors de l’installation de la bibliothèque FERG, mon fichier de config est copié sur le raspberry pi ici /opt/FERG/config.py.
    http://blog.ouiaremakers.com/wp-content/uploads/formidable/config.py
    Comme tout le monde n’a pas la même maison que moi, c’est là qu’il faut adapter le code à sa propre configuration.

    base de données

    	# Base de données pour les consos electriques
    	db_elect = conso_electriqueDB( 
    					db_name = 'tempeDB', 
    					user = 'fred', 
    					passwd='achanger', 
    					host = '192.168.10.10', 
    					mail = FUTIL.mails.gmail(gmail_account='monmail@gmail.com', gmail_pwd='xxxxx'))


    Changez le nom de la base de données, l’utilisateur et l’adresse ip du serveur de base de données.
    Comme j’utilise une adresse gmail, je n’ai prévu que cette solution. Si vraiment gmail vous rebute, je vous laisse coder vous même une autre solution (voir librairie FUTIL).
    capteur jour/nuit

    		#Le capteur heure creuse est réalisé avec un detecteur de tension
    		# Il fonctionne comme un bouton poussoir vers la masse.
    		capteur_heure_creuse = bt_io(pc.bcm_pin(24))


    Remplacez 24 par le n° BCM du port sur lequel est branché le capteur d’heures creuses.
    SI vous ne voulez pas mettre de capteur d’heures creuses :

    capteur_heure_creuse =None


    Convertisseur Analogique

    		#Convertisseur Analogique/Numérique pour lecture analogique sur Rpi
    		mcp3008 = mcp3008_hspi_io()


    Si besoin, changer par : mcp3008 = mcp3008_hspi_io(bus=no_bus, device=no_client_spi, vref=3.3) ou mcp3004_hspi_io(…) si module à 4 entrées.

    Capteur optique

    capteur_roue = qrd1114_analog_io(mcp3008.pin[0])
    


    Ou “0” est le n° de l’entrée du module mcp3008 où est branchée le capteur optique

    led

    led = led_io(pc.bcm_pin(16))
    


    Si pas de led : led = None

    Compteur EDF

    		compteur = compteur_edf( 
    					capteur = capteur_roue, 
    					capteur_hc = capteur_heure_creuse, 
    					led = led, 
    					intensity_max = 45, 
    					energy_tr = 2.5, 
    					nb_tours_mesure = 10)
    


    Là vous changez :

    • intensity_max : intensité maximum de votre abonnement EDF
    • energy_tr : c’est l’energie en Wh mesuré par tour de roue (noté C sur le compteur)
    • nb_tours_mesure : nombre de tour par mesure (10=tous les 10 tours de roue, la base de donné est renseignée)

    Les tores

    tores = {'circuit_1': SCT013_v_io(mcp3008.pin[1], Imax = 30.0, Vmax = 1.0), 
    			'circuit_ce': SCT013_v_io(mcp3008.pin[2], Imax = 30.0, Vmax = 1.0), 
    			'circuit_frigo': SCT013_v_io(mcp3008.pin[3], Imax = 30.0, Vmax = 1.0), 
    			'circuit_ext_haut': SCT013_v_io(mcp3008.pin[4], Imax = 30.0, Vmax = 1.0), 
    			'circuit_frigo_cuisine': SCT013_v_io(mcp3008.pin[5], Imax = 30.0, Vmax = 1.0), 
    			'circuit_divers': SCT013_v_io(mcp3008.pin[6], Imax = 30.0, Vmax = 1.0) 
    			}
    


    Pour chaque tore, donnez lui un nom, le n° d’entrée analogique, l’ampérage maxi du tore et le voltage correspondant.

    Liste des tores SCT-013 Modèle Imax Vmax SCT-013-005 5 1 SCT-013-010 10 1 SCT-013-015 15 1 SCT-013-020 20 1 SCT-013-025 25 1 SCT-013-030 30 1 SCT-013-050 50 1 SCT-013-060 60 1

    Relais de delestage

    deleste_chauffe_eau = relay_io(pc.bcm_pin(23))
    #Si pas de relais : deleste_chauffe_eau = None
    

    Buzzer

    buzzer = buzz_io(pc.bcm_pin(25))
    #Si pas de buzzer : buzzer = None
    

    Le circuit général

    	circuit_0 = circuit_general( 
    		nom = nom_compteur, 
    		puissance_maxi = 10000,
    		energie_maxi_jour = 50000, 
    		compteur = compteur)
    

    Chaque circuit mesuré
    C’est la description des circuits que l’on mesure avec un tore.
    (pour plus de clarté, on donne à nom à chaque circuit)

    	circuit_ce = circuit_mesure( 
    			nom = 'circuit_ce', 
    			parent = circuit_1, 
    			puissance_maxi = 1500, 
    			energie_maxi_jour = 7000, 
    			compteur = tores['circuit_ce'], 
    			eclatable = True, 
    			delest = deleste_chauffe_eau, 
    			puissance_typique = 1300)
    # .....
    circuits_mesures = [circuit_0, circuit_1, circuit_ce, circuit_frigo, circuit_ext_haut, circuit_frigo_cuisine, circuit_divers]
    
    • parent : circuit qui alimente le circuit (attention, doit être déclaré avant)
    • eclatable : True si le circuit va pouvoir être “éclaté” pour en déduire des mesures indirectes
    • puissance_typique : dans le cas où le circuit est composé que d’un apareil qui ne peut consommer que zéro ou une valeur

    Circuits non mesuré directements avec une puissance typique

    	congelateur = electric_device( 
    			nom = 'Congelateur', 
    			parent = circuit_frigo, 
    			puissance_maxi = 130, 
    			energie_maxi_jour = 1500, 
    			puissance_typique = 110, 
    			#max_average_power = 0.75*110
    			)
    	refrigerateur = electric_device( 
    			nom = 'Refrigerateur', 
    			parent = circuit_frigo, 
    			puissance_maxi = 230, 
    			energie_maxi_jour = 2800, 
    			puissance_typique = 190, 
    			#max_average_power = 0.75*190
    			)
    


    Dans mon exemple, un congélateur et un réfrigérateur sont branchés sur le même circuit. Le congélateur a une puissance typique de 110W. Le réfrigérateur à une puissance typique de 190W. Le tore ne mesure que la somme des deux consommations (circuit_frigo). Et bien avec ça, on va pouvoir en déduire ce que consomme séparément le réfrigérateur et le congélateur:

    Solutions Total mesuré (environ) Congélateur Réfrigérateur 0 0 0 110 110 0 190 0 190 300 110 190

    Circuit déduits

    	buanderie = electric_device( 
    			nom = 'Buanderie_chaufferie', 
    			parent = circuit_1 
    			)
    #
    electric_devices = [congelateur, refrigerateur, buanderie, cuisine]
    


    Ici, on note que la buanderie est alimenté par le circuit_1.
    Or plus haut, est noté que le circuit_ce est aussi alimenté par ce même circuit_1.
    Le programme va donc déduit buanderie comme étant circuit_1 – circuit_ce.

    seuil de delestage

    	return installation( 
    				db = db_elect, 
    				circuits_mesures = circuits_mesures,
    				electric_devices = electric_devices, 
    				seuil_delestage = 8000, 
    				buzzer = buzzer)
    

    http://ouiaremakers.com/wp-includes/images/media/text.png

    Etape 11 : Lecture des résultats

    Medium em4jcr23pgw7w9iuiknb

    Les données de consommation électriques sont stockées bien au chaud dans la base de donnés. Les circuits calculés sont aussi dans la base de données (c’est le programme chk_alertes.py qui s’en charge). Eventuellement quand il y a une alerte, un mail est envoyé et si on dépasse la capacité du compteur, le chauffe eau (dans mon cas) se coupe.
    Tout çà est bien, mais on en veux plus : avoir accès aux données et ainsi …. savoir ce que l’on consomme.
    On peut utiliser Excel pour faire de jolis graphiques et tableaux de reporting (mais je vous laisse faire yourself).

    Personnellement, j’ai fait un petit site web (voir images et code html+php dans energies.zip),
    Si j’avais confiance, je donnerais l’adresse de mon site avec codes d’accés pour visualiser mes consommations électriques. Mais en fait j’ai pas confiance!
    Vous pouvez juste voir sur les copies d’écrans que je suis nul en graphisme. On peut choisir le circuit (un seul!) une plage de dates et soit la puissance instantanée, soit des cumuls par type de période (heure, jour, semaine, mois, année).
    Pour faire les graphiques, j’utilise http://dygraphs.com/ . C’est simple a mettre en oeuvre et super efficace. Ce que je préféré est le fait de pouvoir zoomer à la souris très simplement!

    http://ouiaremakers.com/wp-includes/images/media/archive.png

    Etape 12 : Conclusion

    J’utilise cette installation depuis plusieurs mois et ça fonctionne bien.
    Le seul problème majeur et que passées les quelques semaines durant lesquelles je regardais les graphes tous les jours, j’ai tendance à ne plus trop y regarder.
    Et très honnêtement, j’ai très peu d’actions sur ma consommation électrique.

    Le seul vrai point positif : le délestage du chauffe eau nous permet maintenant de mettre en marche entre 12H30 et 14H00 en même temps four, lave vaisselle, plaques à induction, machine à laver le linge et sèche linge sans que ça ne disjoncte! Le vrai pied pour le super consommateur que je suis!!!

    J’espère avoir donné des idées à ceux qui ont réussi à lire ce tuto jusque là.
    Et si vous pouvez récompenser mes efforts par un petit commentaire, je serais ravi.

    Etape 13 : Alternative : avec micro-contrôleur (type arduino)

    Une alternative à la lecture directe du capteur optique par le raspberry pi est l’utilisation d’un micro contrôleur de type arduino.

    J’ai utilisé pour ma part un arduino nano (ça coute 3€ sur Ebay et l’avantage est qu’il y a un port usb).
    Pour le moment, j’ai réalisé le montage sur une breadboard. Si un jour j’ai le courage et le temps, je referais bien la carte électronique de l’étape 5 en y ajoutant une puce atmega.

    Ci-joint schémas et programme.
    (bien sur ça modifie aussi un peu les schémas de la carte électronique : plus besoin d’y brancher le capteur optique).

    En gros :
    Coté capteur optique : le capteur est branché comme précédemment : on alimente la led IR en 5V avec une résistance en série, les masses sont … à la masse, on met une résistance “pull-up” entre la sortie et les 5V, et on branche cette sortie avec une entrée analogique de l’arduino.
    Coté raspberry : on alimente l’arduino avec les 5V du raspberry pi. On branche l’i2c : raspberry GPIO2 (i2c SDA1) sur arduino A4 et raspberry GPIO3 (i2c SCL1) sur arduino A5.
    Plus une petite LED sur D8 de l’arduino pour voir si la bande est détectée.

    Au niveau du programme arduino:

    Je vous laisse regarder le code (ferg_compt.ino). C’est assez bien commenté.
    Il y a toujours une phase d’apprentissage (calcul du seuil de détection de la bande noire), puis quand une bande est détectée, on comptabilise un tour de plus.
    D’autre part, quand le raspberry vient lire l’arduino, il envoie par i2c du nb de tours détecté depuis dernière lecture. possibilité aussi au raspberry de réaliser un reset de l’arduino en envoyant un code spécial (j’ai mis 88 comme j’aurais pu mettre 3).

    Au niveau raspberry et python:

    Le code python a été revu (version 0.9.5 de FERG) pour prendre en compte cette nouvelle possibilité.

    Dans le fichier config.py, il faut juste remplacer :

    capteur_roue = qrd1114_analog_io(mcp3008.pin[0])


    par

    atmega = i2c_device_io(pc=pc, addr = 0x12)


    et

    		compteur = compteur_edf( 
    					capteur = capteur_roue,
    					(....)


    par

    		compteur = compteur_edf( 
    					micro_controleur = atmega,  # Selon choix du type de branchement du capteur optique
    					(...)

    http://ouiaremakers.com/wp-includes/images/media/default.png

    Vous aimez ce tutoriel ?


    Ipxav

    07 juil. 2016 à 10:25

    Oo ! Voilà comment monitorer sa consommation électrique sur les vieux compteurs en comptant les tours. Merci pour le partage fred et bravo pour le détail.

    Dodutils

    07 juil. 2016 à 10:27

    Sympa je suis en train de faire la même chose chez moi avec l'astuce de Seb pour le compteur à roulette (sauf que j'ai du utiliser un IR TCRT5000 au lieu de son petit module IR sinon ça marchait pas, question de qualité du reflet sûrement), mon compteur est un 1.6Wh/tour du coup ça va très vite quand ça pompe bien.


    Pour la détection de conso de chaque appareil relié à un même disjoncteur je fais pareil en me basant sur la puissance connu de chaque appareil et faire des “and” pour savoir lequel(s) toure(nt) à un instant T, attention à certains appareil dont la conso peut pendant un très court instant monter assez haut comme mon frigo qui pfait des pointes à 1000W après une coupure de courant.


    Par contre pour les pinces ampèremétriques il faut faire attention à calibrer en fonction de la tension réelle du réseau sinon le chiffre sera faussé.

    Fred Thx

    07 juil. 2016 à 10:27

    Bon courage pour ton compteur. Le mien fonctionne pas mal : même si les valeurs relevées par les tores ne sont pas parfaites, c'est largement suffisant pour ce que j'en ai besoin. Pour le compteur en lui même, je dois perdre un peu moins de 1% des tours.

    Dodutils

    07 juil. 2016 à 10:27

    As-tu une explication pour la perte de 1% des tours ? pour ma part c'est un arduino qui compte les tours (mais je pense le remplacer par un ATTiny85, pas besoin de plus gros pour ça) et pour éviter les pertes je l'utilise uniquement pour envoyer l'info “rapidement” à l'ESP8266 (mais ça pourrait aussi être un RasPi) et revenir au comptage de façon à ne pas manquer un tour, ensuite l'ESP prend le temps de balancer au serveur et au besoin bufferise ce qui vient de l'Arduino quand ça tourne vite si le serveur à l'autre bout est un poil lent ou indisponible, je pourrais aussi utiliser directement ESP pour la lecture via son port ADC mais ça demande des réglages car sa plage de conversion est de 0-1V seulement, pareil pour la lecture des pinces avec un MCP ou autre 74HCxxxx je pourrais très bien le faire 100% un l'ESP et transmettre en WiFi vers mon serveur du coup ça gagne pas mal de place par rapport à un RasPi dans le boitier EDF 😉

    Fred Thx

    07 juil. 2016 à 10:28

    Je pense que mon raspi a du mal a suivre quand ça va très vite (surtout qu'il ne fait pas que ça). Pour résoudre, j'hésite entre mettre un petit atmega328 pour lire la roue et transmettre au raspi ou améliorer mon code python pour ne plus rater de tours.

    Dodutils

    07 juil. 2016 à 10:28

    Un RasPi n'étant pas un micro contrôleur il est toujours succeptible d'être bloqué à faire autre chose et du coup manquer des tours donc ATMega ou ATTiny pour être sûr de ne rien rater, puis un envoi vers le RasPi qui “bufferisera” (du verbe bufferiser bien connu du Petit Robert 😉 tranquillement et dépilera les tours qui auront été reçus avec un timestamp de préference voir même laisse le micro contrôleur stocker une minute de tours et ne lui faire envoyer un simple total des tours qu'une fois par minute ce qui est largement suffisant, pas besoin de granularité inférieure pour ça, si tu veux une lecture instantanée les tores sont là pour ça.

    nico33

    07 juil. 2016 à 10:28

    Tout d'abord merci beaucoup pour ce partage.

    Je cherchais comment mesurer certaines conso depuis mon tableau et ton tuto colle parfaitement avec mon but.

    J'ai donc entrepris de le mettre en oeuvre pour n'utiliser que la partie avec les TORS.

    Mais ça bloque à l'installation PIP de FERG. (je suis sous raspbian comme toi)

    J'obtiens une série d'erreurs qui commence par :


    Downloading/unpacking FERG

    Running setup.py egg_info for package FERG


    Traceback (most recent call last):

    File “”, line 14, in

    File “/home/pi/install/distribute-0.7.3/build/FERG/setup.py”, line 39, in

    shutil.copy('comptage.py', '/opt/FERG')

    File “/usr/lib/python2.7/shutil.py”, line 119, in copy

    copyfile(src, dst)

    File “/usr/lib/python2.7/shutil.py”, line 82, in copyfile

    with open(src, 'rb') as fsrc:

    IOError: [Errno 2] No such file or directory: 'comptage.py'

    Complete output from command python setup.py egg_info:

    running egg_info


    J'ai du rater qqchose … Une idée ?

    Merci d'avance.

    Fred Thx

    07 juil. 2016 à 10:29

    Merci pour ton conseil que j'ai appliqué. J'ai mis un ATMega pour lire le capteur optique et compter les tours. Il est relié au Rpi via i2c. Le Rpi va juste lire le nombre de tours quand il a le temps (toutes les secondes quand même). Je met à jour les sources (qui laisseront les deux choix de mesure, avec ou sans micro-controleur) et le tuto dés que j'ai un peu de temps.

    Dodutils

    07 juil. 2016 à 10:29

    Cool et en plus grâce à ça si tu doit stopper/rebooter ton Pi pour mise à jour ou autre tu ne perdras rien.


    p.s : une granularité d'une seconde n'est pas forcément utile tu peux récupérer un cumul toutes les 10 secondes ou toutes les minutes c'est déjà pas mal de toute façon ce qu'il faut c'est connaître la différence de temps par rapport à la précédente récupération du nombre de tours.

    Fred Thx

    07 juil. 2016 à 10:29

    Désolé, une grosse bourde c'était glissée dans la version en ligne. Vous pouvez réessayer!!

    nico33

    07 juil. 2016 à 10:29

    C'est nickel maintenant. Merci.

    Reste plus qu'à adapter ton code. 🙂

    Plus qu'à … 🙂

    Vebyrn

    07 juil. 2016 à 10:33

    Excellent projet! Je suis tout à fait d'accord avec l'une des conclusions : “Le seul problème majeur et que passées les quelques semaines durant lesquelles je regardais les graphes tous les jours, j’ai tendance à ne plus trop y regarder.” J'ai fait le monitoring de ma consommation électrique chez moi et j'avoue que je ne la regarde pas très souvent. Ce qui est intéressant, c'est de multiplier le Wh avec la consommation pour obtenir le coût journalier/hebdo ou mensuel.

    occasionel

    20 jan. 2017 à 16:47

    pour ceux qui envisagent de développer un système analogue, je signale qu'il existe des capteurs 'prêts à l'emploi' pour lire les compteurs. Ils communiquent avec le 'cerveau' de l'installation via les protocoles Zwave qui sont largement utilisés.
    Un module Zwave enfichable exite pour le rasperry pi.
    Cela pourrait permettre de ne pas perdre d'impulsion et et mettre le système de calcul n'importe où.
    Parmis les produits Zwave il y a des "prises" intelligente qui mesurent la consommation et qui sont télécommandables.
    adresse pour les lecteurs de compteurs: http://products.z-wavealliance.org/products/1610
    P.S. Pour éviter tout malentendu, cela fait partie de mes rêves mais je n'ai rien réalisé à cette heure!

    Fred Thx

    21 jan. 2017 à 13:07

    Il existe des modules du commerce qui savent lire les vieux compteurs mécaniques?
    Si oui, je suis curieux de voir ça.

    occasionel

    21 jan. 2017 à 13:33

    Oui, j'en possède 2! C'est minuscule et """facile""" à appliquer sur la vitre du compteur avec un papier adhésif transparent livré d'origine.
    Pout l'électricité, il lit le passage du disque et pour le gaz il fait de la reconaissance optique sur le chiffre 6.
    dimensions: 4cm x 2cm
    C'est installé par les compagnies de gaz et électricité aux pays-bas et en belgique. Je pense que j'ai donné la bonne référence dans mon post.
    Je ne sais pas s'ils le vendent en direct aux particuliers...
    C'est depuis que c'est installé chez moi que j'examine la possibilité de les lire avec un Pi.
    Sur le documentation il est indiqué une marque: Quby.
    Sur leur site il n'y a que de la pub.
    Mais le produit est repris dans les produits Z-wave.
    L'estension Z-wave pour le pi s'appelle RaZberry2 et coûte environ 50€
    Les périfériques domotique compatibles Z-wave sont fabriqués par une société "FIBARO" et coûtent chacun +/- 50 €
    A disposition pour plus d'infos sachant que je suis en mode "explorateur" et pas encore utilisateur....

    occasionel

    21 jan. 2017 à 13:34

    J'ai oublié... Félicitations pour la présentation.


    S'inscrire:


    • Vues: 7269
    • J'aime: 6