FERG : Mon vieux compteur EDF connecté en mode framboise

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

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.

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

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

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.

Lors de l’installation de la bibliothèque FERG, mon fichier de config est copié sur le raspberry pi ici /opt/FERG/config.py.
"border-collapse: collapse">

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:

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)

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

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