Jeudi, février 26 2015

Moteur à électroaimant 100% récup

Il pleut aujourd’hui ? Vous savez pas quoi faire pour passer le temps ? Vous avez une montagne de vieux disques durs en attente de recyclage ?
Si vous avez répondu oui à au moins une de ces questions, ce projet est fait pour vous !
L’idée est simple : utiliser l’électroaimant d’un disque dur pour produire une rotation du disque, comme le ferait le piston d’un moteur thermique ou vapeur. Ne cherchez pas une quelconque justification technique à ce projet, il n’y en a aucune, mais ça fait un petit moteur rigolo, avec un joli bruit, et c’est amusant :)

Il vous faut un disque prêt à être sacrifié. Peut importe qu’il ne marche déjà plus, de toutes façons, il ne fonctionnera plus ensuite (en tant que disque dur tout du moins)
Un disque dur prêt à être sacrifié

Il va maintenant falloir le désosser, en faisant attention à certaines pièces. A cette étape, il y a de grande chances que vous ayez besoin d’un petit tournevis torx. Commencez par enlever l’étiquette du capot, une vis se cache sous celle-ci.

Vis cachée

Désossez ensuite la carte électronique, et mettez là de côté, elle servira plus tard. (il suffit de dévisser, elle vient ensuite toute seule. Enlevez également la mousse ou l’isolant qui est dessous)

La carte à démonter

Une fois toutes les vis enlevées, vous pouvez ouvrir le disque. Il faut des fois utiliser un petit tournevis plat pour amorcer l’ouverture. Si ça ne viens pas, ne forcez pas, vous avez sans doute oublié une vis.
Il faut maintenant enlever l’aimant au dessus du bras de lecture. Il n’est pas collé, simplement maintenant par son magnétisme (costaud). Enlevez le simplement en tirant dessus (ne le lachez pas, sinon il va se repositionner violemment, et risque de se casser), et mettez le de côté. Inutile d’enlever l’aimant de son support métallique, laissez en un seul morceau.
Vous pouvez également enlever (et jeter) toutes les petites pièces plastiques servant à parquer les têtes.

l'intérieur du disque

A l’aide d’un tournevis plat, dévissez le pivot des têtes de lectures, ainsi que le connecteur relié aux têtes par nappe souple.

démontage des têtes

Les têtes de lectures se constituent d’un corps en aluminium assez rigide, terminé par des languettes métalliques souples supportant les éléments de lecture magnétiques. Avec un cutter, détachez précautionneusement toutes les lamelles souples du corps en aluminium. Vous pouvez casser les nappes souples des têtes sans hésiter, mais pas le grosse nappe reliant les têtes au connecteur.

Le résultat

Dans les vis que vous avez récupéré lors de l’ouverture, certaines auront une tête très plate et fine. Prenez en une, et insérez là entre les deux bras supérieurs du support de tête (vous pouvez les écarter avec un tournevis plat que vous faites tourner). Mettez un morceau de papier plié de manière à combler l’intervalle entre les 2 bras et maintenir la vis en place. Chauffez les premier bras et la vis avec un fer à souder et étamez. Ca se fait pas trop mal avec un fer d’électronique, mais la soudure accroche assez mal sur l’aluminium, il faut bien chauffer, ce qui prend un petit moment. Coupez un bout de tube laiton de diamètre 3mm, et étamez l’intérieur. Chauffez, et enquillez le tube sur la vis, rajoutez de l’étain si nécessaire pour que l’ensemble tienne bien.

Soudure de la came

Sur le disque central fixant les plateaux du disque, soudez avec la même méthode (sans la vis) un tube laison, bien vertical.

les cames

Il faut maintenant remonter la tête de lecture en revissant son axe de rotation, et en repositionnant l’aimant au dessus. Refixez également le contact pour le circuit. Maintenez la tête de lecture en position haute (ie le plus vers le disque possible), et faites tourner le plateau jusqu’à ce que les 2 cames soient le plus proche possible. Coupez un bout de tube laiton de cette distance moins 1mm environ.
Etamez 2 rondelles de 3mm, écrasez le tube laiton aux extrémités, et soudez une rondelle de chaque côté.
la bielle

faites tourner les plateaux pour vérifier qu’il n’y a pas de point dur. S’il y en a, déssoudez une rondelle, raccourcissez légèrement le tube, remontez, retestez, etc…

Il faut maintenant repérer les fils de l’électroaimant des têtes de lectures. Prenez une alimentation 12v, et testez tous les contacts (certaines positions vont faire fumer de petits composants sur la nappe, tant pis pour eux ;) ). Une fois trouvé les 2 fils correspondant à l’électroaimant, repérez les pastilles correspondantes sur le circuit imprimé (miroir).
En effet, on va devoir souder des fils pour alimenter l’électroaimant, et c’est assez galère sur une nappe souple, et le connecteur se détruit assez rapidement lorsqu’on soude directement dessus. On utilisera donc plutôt le circuit imprimé, plus facile et prévu pour.
Les bornes de l'électroaimant

Soudez maintenant 2 fils là ou vont les pistes des 2 contacts précédemment repérés. Dans mon cas, sur une diode, et un CI. pour le CI, pas besoin de faire dans la finesses, même si 2 pattes touchent le fil, ce n’est pas grave. Vérifiez juste que les 2 pastilles qui nous intéresse ne se retrouvent pas connectées ensemble ;)

Les fils d'alimentation

Prenez une tige de cuivre, ou de n’importe quoi d’autre d’un peu rigide et que vous pouvez former. Collez le sur le grand côté du disque opposé à l’électroaimant. Cette pièce viendra supporter l’interrupteur. Vérifiez que vous pouvez toujours tourner le disque avant de fixer définitivement. Cette pièce sera soumise à quelques contraintes, alors j’ai collé à la super glue pour le positionnement, puis enduis le tout à l’époxy.

Le support

Soudez un des fils de l’électroaimant à l’interrupteur, et un second qui ira à l’alimentation. Faites un test de polarité pour que le bras se lève quand vous appuyez sur l’interrupteur. Alimentez en 15v, et positionnez à la main l’interrupteur sur son support. Pour trouver la bonne position, lancez le plateau jusqu’à trouver la position où le mouvement se maintient. Selon la position, le rendement sera plus ou moins bon. Une fois la position trouvée, collez l’interrupteur à la super glue.
Alimentez à l’aide d’une alimentation de labo réglable par exemple, et essayez différentes tensions. Mon moteur tourne à partir de 15v et tourne assez vite autour des 25v. N’oubliez pas qu’il faut lancer le moteur à la main à chaque fois :)

Vendredi, février 20 2015

Des nouvelles de RaspiO'Mix

J'ai peu donné de nouvelle récemment, notamment au sujet de RaspiO'Mix et pourtant, il y a à dire...

Un site dédié

Un site dédié permet de commander directement les RaspiO'Mix : www.raspiomix.org, tant qu'il y a du stock, vous recevrez votre RaspiO'Mix en 48h.

Je n'exclus pas de proposer les RaspiO'Mix aux revendeurs intéressés, merci de me contacter directement.

Librairie Python

La librairie Python à quelque peu évoluée et est devenue encore plus simple.

Pour lire une tension sur une des entrées analogiques suivi d'une lecture des 4 entrées analogiques :

$ python
>>> from raspiomix import Raspiomix
>>> r = Raspiomix()
>>> r.readRtc()
2014-11-12T20:41:26
>>> print(r.readAdc(0))
[4.0669732000000005]
>>> print(r.readAdc((0, 1, 2, 3)))
[4.066934600000001, 0.010923800000000001, 0.08515160000000001, 0.2866822]
>>> 

Cette librairie est disponible sur GitHub : GitHub / RaspiOMix / raspiomix.py

RaspiO'Mix+

Présentation

RaspiO'Mix poursuit son évolution avec la RaspiO'Mix+ créés pour être utilisée comme vous pouvez vous en douter avec un Raspberry+.

J'ai repris le tableau d'un précédent article sur RaspiO'Mix comparant cette dernière avec la carte GrovePi :

Fonctionnalité GrovePi RaspiO'Mix RaspiO'Mix+
Entrées / Sorties 7 4 8
Entrées analogiques 3 4 8
Résolution CAN 10bits 18bits 18bits
Lignes I2C 4 2 3
Lignes série 1 1 1
Horloge Non Oui (via DS1307) avec batterie de sauvegarde Oui (via DS1307) avec batterie de sauvegarde
Interrupteur 0 2 2
Alimentation via le Raspberry via le Raspberry ou une prise jack / bornier via le Raspberry ou une prise jack / bornier
Option - - Capteur I2C TMP10

Note: GrovePi+, l'évolution pour RaspberryPi+ possède les même caractéristiques que GrovePi.

RaspiO'Mix+ est au format Raspberry HATs+ et donc bien plus petite que la version originale, la densité de composants est donc plus forte.

RaspiO'Mix comparée à RaspiO'Mix+ :
Comparatif de taille RaspiO'Mix vs RaspiO'Mix+

Une carte RaspiO'Mix+ sur un RasberryPi :
RaspiO'Mix+ sur un RaspberryPi+

En détail

Le schéma de principe :
schema.png

J'ai ajouté un deuxième MCP3424 afin de doubler le nombre d'entrées analogiques, un second convertisseur de niveau à 4 entrées / sorties (TXB0104PWR) rejoint le TXS0108PWR et sera utilisé pour les entrées sorties de type Push / Pull (le TXS0108PWR ayant un mode haute impédance).

Une EEPROM série rejoint la carte afin de répondre à la spécification HAT mais je ne sais pas si elle sera montée sur les cartes (quoiqu'il arrive, son emplacement sera laissé sur le pcb).

J'ai également ajouté un capteur de température I2C (TMP10x) sous la carte permettant la mesure de la température rayonnée par le Raspberry mais le circuit intégré ne sera pas disponible de série, ou alors, uniquement en option (sauf si j'arrive à les obtenir par quantité à un coût intéressant).

La suite

Pour le moment, la carte RaspiO'Mix est fonctionnelle mais non disponible à la vente, quelques modifications sur l'emplacement des composants sur le pcb doivent encore être faite (merci Seeedstudio de proposer des librairies Eagle légèrement foireuse).

Samedi, février 14 2015

Entretenir des roulements à billes, démo vidéo

Et j'ai fait la bêtise de remplir complètement les roulements, comme ceci : dsc00439.jpg
Puis je suis allé patiner…

Au début ça allait, puis catastrophe, j'avais l'impression de bien galérer, et la fatigue fût telle qu'il n'y avait pas de doute, la graisse freine beaucoup trop !
M'enfin, ça peut être utile pour qui veut se muscler les cuisses…

Pour une vitesse maximale, on pourrait mettre de l'huile à la place, mais ce type de roulement n'étant pas étanche, elle aurait vite fait de se sauver, laissant le métal sans lubrification…

  • Du coup on va mettre moins de graisse, et c'est l'occasion de voir comment se déroule toute l'opération, notamment avec la bidouille à base de moteur lego, dans cette courte vidéo :

Pour 16 roulements, le temps de tout démonter, maniper et remonter, il faut compter deux heures…
Le dégraissage n'ayant lui, duré que dix minutes.
dsc00442.jpg

Vendredi, février 13 2015

Entretenir des roulements à billes

dsc00407.jpg

  • Pour dégraisser des roulements à billes, il y a pas mal de techniques différentes, mais il en est certaines plus efficaces que d'autres.

J'avais tout d'abord essayé le nettoyage au bac à ultrason, dans un bain d'acétone, posé sur le rebord de la fenêtre ! Mais non, méthode complètement nulle, en plus d'être toxique, ça met des plombes à nettoyer vu qu'il faut recommencer l'opération de nombreuses fois pour un résultat correct.

  • Puis je me suis souvenu de cette vidéo que j'avais trouvé, puis perdue, et en cherchant après, je suis tombé sur celle-ci, qui montre comment avec un simple moteur électrique, une pile et un peu d'astuce on peut se confectionner un outil de nettoyage rapide et efficace.
  • Seulement j'étais pressé, et n'avais donc pas le loisir de me lancer dans la fabrication d'un tel outil, mais j'ai quand même fouillé dans mes affaires, pour retrouver ces bons vieux lego technic…

Un stylo sacrifié plus tard, me voici avec un outil rudimentaire mais tout à fait fiable, à connecter sur un bloc d'alimentation 5V.
dsc00412.jpg dsc00409.jpg

  • Quelques secondes à tourner dans le white spirit et l'affaire est réglée.

Restait alors à appliquer la graisse (pas beaucoup !!!) sur les roulements propres et à remettre en place les rondelles protectrices.

Samedi, février 7 2015

Retour sur Geek Faëries : On The Web V3 - Partie 1/2

2015_logo-gf.png

  • Pour ceux qui n'ont pu assister à l’événement en direct depuis leurs fauteuils, les replay du festival Geek Faëries On the Web V3.0 de Janvier dernier sont en cours d'upload sur la chaîne youtube du StudioAffects.

Cependant, 12 téras de données, c'est très long à uploader, et je ne saurais vous dire quand sera disponible la conférence que nous avons animé. Cela fera l'objet d'un second billet dés que j'aurais pu mettre la main dessus.
Vu que je streamais avec mon ordi, il se trouve que je dispose de l'enregistrement de mon intervention post conférence.

  • En attendant, je propose donc cette vidéo ainsi que le matériel que j'ai utilisé, pour un petit compte-rendu d'« une impression3D, de l'idée à l'objet physique », pour qui voudrait débuter dans le domaine.

Désolé pour la qualité du son, je ne me suis pas rendu compte que le micro était quelque peu saturé…



  • Et enfin quelques photos du Jointed Robot spécialement imprimé pour la convention !

dsc00417.jpg dsc00419.jpg dsc00415.jpg dsc00420.jpg dsc00421.jpg dsc00422.jpg dsc00423.jpg dsc00424.jpg

Mercredi, février 4 2015

Rpi-pi_EYE

Impressionné par le résultat, j'ai alors entrepris de l'imprimer, ce malgré le manque d'informations et d'instructions flagrant, me disant naïvement que le gars avait dû faire les choses bien, que ça passerait sans problèmes…
Bien mal m'en a pris, ce fût une catastrophe !
L'impression en ABS étant toujours assez galère avec des décollements de pièces importants, j'ai dû jeter la pièce principale du P-eye qui non seulement était donc déformée, et qui de plus ne permettait pas d’accueillir convenablement les servo-moteurs, les logements n'étant pas aux bonnes dimensions, en plus d'un système d'enclipsement de ceux-ci vraiment trop fragile.
Ces impressions difficiles obligeant à avoir systématiquement recours aux supports d'impression, et le fait qu'il manque le panneau arrière pour loger le Raspberry me fit enfin comprendre que non, son truc n'est vraiment pas terminé.
Encore eut-il fallut le signaler, la fonction existe, une case à cocher dans Thingiverse pour signaler qu'il s'agit d'un WIP:

Hey! This thing is still a Work in Progress. Files, instructions, and other stuff might change!

Hum, bref, passons…
J'importe et nettoie l'objet dans Sketchup histoire de tout refaire… Wép, le travail n'est pas sourcé, puis de retourner sur la page dans l'idée de publier un remixe et de me rendre compte que le modèle était protégé par une licence restrictive (CC by-nc-nd) interdisant cela !

  • Pas cool, je laissais tout de même un message sur la page histoire de faire baver les follower qui attendaient la suite depuis un an, et Ghiotto, eut alors l'amabilité de libérer son travail afin que je puisse le publier : http://www.thingiverse.com/thing:520703

Le prototype :

img_0186.jpg img_0183.jpg Voici donc une version au design plus simple que le projet d'origine, plus facilement imprimable.
Tous les éléments du kit de Ghiotto ont été conservés, sauf le boîtier principal que j'ai entièrement refait et séparé en deux morceaux.

img_0185.jpg J'ai notamment modifié, agrandit et consolidé les supports de servo pour les adapter à ceux dont je disposais, en plus d'y adjoindre une fixation par vis.
Le fichier source Sketchup permettra au besoin d'ajuster la position latérale de ces supports, ou de les revoir complètement.
Il reste à faire un boîtier arrière pour intégrer le Raspberry-Pi et fermer cet ouvrage.

  • Voici une vue de l'arrière, avec les servos fixés par des petites vis de récupération :

img_0181.jpg

En action avec la vidéo :

  • On peut fixer les servos de deux manières différentes :

img_0129.jpg img_0184.jpg

  • Il faudra peut-être percer un peu plus grand en fonction des vis dont on dispose, ou utiliser la technique du briquet, pour éviter l'éclatement du plastique lorsque le pas de vis va creuser son sillon.

C'est simple : engager la vis, chauffer la tête, visser doucement dans le plastique qui va ramollir sur le passage de la vis, attendre que ça refroidisse/solidifie pour dévisser, ébavurer l'excédent de plastique fondu remonté au bord du trou, revisser en utilisant la bonne technique !


  • L'anneau gris est à coller sur la structure :

img_0182.jpg img_0130.jpg

C'est un peu plus esthétique, ici en vidéo :



 Câblage des servos sur les GPIO du Raspberry :

Avec des servo TowerPro SG90,

  • Premier servo

- Fil orange sur le GPIO1 du Raspberry (pin18).
- Fil rouge sur le +5V d'une alimentation externe (l'USB du Raspi n'est pas assez puissant).
- Fil marron sur la masse de l'alimentation.

  • Second servo

- Fil orange sur le GPIO4 du Raspberry (pin17).
- Fil rouge sur le +5V de l'alimentation.
- Fil marron sur la masse de l'alimentation.

Relier une masse GPIO du Raspberry sur la masse de l'alimentation externe.

Utilisation de la librairie RPIO :

Voici la doc de la librairie : http://pythonhosted.org/RPIO/

  • Pour l'installer, c'est facile :
sudo apt-get install python-setuptools
sudo easy_install -U RPIO
  • Voilà quelques morceaux de code qu'on peut utiliser dans la console python, notamment pour déterminer les valeurs limites de la course du servo (valeurs à tâtonner doucement, pour ne pas trop la dépasser, car sinon on force le micro-mécanisme au risque de l'abîmer).

Valeurs minimale et maximale de la PWM testée pour mes servos : 820µs à 2690µs.

On initialise la libraire :

from RPIO import PWM
servo = PWM.Servo()
  • Puis on fait bouger le servo connecté au GPIO17 avec 820µs :
servo.set_servo(17, 820)
  • On fait bouger le servo connecté au GPIO17 avec 2690µs, dans le sens opposé donc:
servo.set_servo(17, 2690)
  • On stoppe les opération pour le GPIO17 :
servo.stop_servo(17)

À ce stade, on sait donc piloter les servos, il suffit de choisir la valeur qui sied à la position dont on a besoin. Avec ces commandes simples, on peut déjà créer un programme…

Piloter les servos via une interface web avec web.py :

  • Découvert après quelques recherches, on va utiliser un module http://webpy.org/, qui contient un serveur Web ultra-léger.

Et de me rendre compte de la mention en bas de page :
started by Aaron Swartz (webpy@aaronsw.com)

Tomber sur un petit bout du travail d'Aaron Swartz, peu après avoir visionné sa bio en vidéo, ma saisi au tripe… quand on sait le gâchis qu'a été cette histoire, une victime pour l'exemple, du patriot act américain, que l'état Français cherche à faire la même chose au travers de lois sécuritaires, donc liberticides, que beaucoup applaudissent, dont madame pécresse qui déclare publiquement des bêtises (« Il faudra bien entendu un Patriot Act à la française… »), pour déclarer plus tard : « je ne sais même pas ce qu'il y a dans le Patriot Act américain »…
Tout ça me file la nausée… juste, connectez vos cerveaux ou allez faire chier les mygales dans leurs nids, qu'on ait la paix !
Ces lois n'empêcheront pas les poseurs de bombes, ho que non ! Par contre elles permettent de contrôler touuuut le monde, voire d'en pousser certains à bout, jusqu'au suicide…

  • Si vous ne l'avez pas vu, allez tout de suite télécharger la vidéo : The Internets Own Boy_The Story of Aaron Swartz, voici les sous-titres en Français.

Hum…

  • C'est donc avec émotions qu'on installe le module, à l'aide d'easy install :
sudo easy_install web.py
  • Puis on crée une arborescence sur le Raspberry-Pi:
cd /
mkdir webpyserver
cd /webpyserver
mkdir templates
mkdir static

Le dossier webpyserver contiendra le fichier Python à exécuter.
Le dossier webpyserver/templates contiendra une page HTML.
Et le dossier webpyserver/static contiendra une feuille de style au format CSS.

  • On va écrire un programme qui sera placé dans le dossier /webpyserver/DeuxServo.py :
#!/usr/bin/env python 
import web, RPIO
from web import form
from RPIO import PWM

servo = PWM.Servo()

# definit la page de nom index pour le site web 
urls = ('/', 'index') 
dossier_web = web.template.render('templates')

app = web.application(urls, globals())

# definit les boutons a afficher 
ma_forme = form.Form( 
form.Button("btn", id = "btn1-0", value = "s1-0", html = "Servo 1 - 0 degre", class_ = "bouton_1-0"), 
form.Button("btn", id = "btn1-90", value = "s1-90", html = "Servo 1 - 90 degres", class_ = "bouton_1-90"), 
form.Button("btn", id = "btn1-180", value = "s1-180", html = "Servo 1 - 180 degres", class_ = "bouton_1-180"), 
form.Button("btn", id = "btn2-0", value = "s2-0", html = "Servo 2 - 0 degre", class_ = "bouton_2-0"), 
form.Button("btn", id = "btn2-90", value = "s2-90", html = "Servo 2 - 90 degres", class_ = "bouton_2-90"), 
form.Button("btn", id = "btn2-180", value = "s2-180", html = "Servo 2 - 180 degres", class_ = "bouton_2-180") 
)

# definit l action a effectuer quand la page index est appele 
class index:
    def GET(self): 
        forme = ma_forme() 
	return dossier_web.index(forme, "Raspberry Pi control Servo") 
    def POST(self): 
        userdata = web.input() 
        if userdata.btn == "s1-0": 
            servo.set_servo(17, 820)
        if userdata.btn == "s1-180": 
            servo.set_servo(17, 2600)
        if userdata.btn == "s1-90": 
            servo.set_servo(17, 1710)
        if userdata.btn == "s2-0": 
            servo.set_servo(18, 820)
        if userdata.btn == "s2-180": 
            servo.set_servo(18, 2600)
        if userdata.btn == "s2-90": 
            servo.set_servo(18, 1710)
        raise web.seeother('/')

# programme 
if __name__ == '__main__': 
    app.run()
  • Enfin dans le dossier templates on écrit un fichier index.html :
$def with (form, title)
<!doctype html>
<html>
    <head>
        <title>$title</title>
    </head>
   
    <body>
        <br />
        <form class="form" method="post">
        $:form.render()
        </form>
    </body>
</html>
  • Tout est prêt, on initialise le programme avec la commande :
sudo python DeuxServo.py
  • Et on se rend à l'adresse IP du Raspberry en spécifiant le port 8080 :

ControlServo.jpg

  • C'est tout pour ce programme de test !

Reste à écrire un programme pour piloter les deux servos à l'unisson afin de diriger l'œil de la caméra aux coordonnées désirées. Cela fera peut-être l'objet d'un futur billet, mais il faut déjà que je termine la modélisation3D du boîtier.



Ressources :

http://itechnofrance.wordpress.com/2013/02/04/piloter-les-ports-gpio-partir-dun-navigateur-internet/
http://webpy.org/

https://www.censa.mx/imgs/prods/18022004/docs/doc1-1401817609.pdf
http://www.servodatabase.com/servo/towerpro/sg90
https://www.censa.mx/imgs/prods/18022004/docs/doc1-1401817609.pdf
https://projects.drogon.net/raspberry-pi/wiringpi/pins/
https://groups.google.com/forum/#!topic/raspberrybots/lRfu5ucbjYE
http://papinthierry.free.fr/index.php?option=com_content&view=article&id=32&Itemid=32

Jeudi, janvier 15 2015

Geek Faëries : On The Web V3

2015_logo-gf.png

  • Ce samedi, comme l'an dernier, je participerais au festival Geek Faëries On the Web V3.0 qui a lieu ce week-end sur http://www.geekfaeries.fr.

Ne cherchez pas de lieux où se rendre, c'est en direct sur internet avec plus d'une dizaine de Flux en direct et simultanés, il n'y a donc pas de public sur place !

  • J'interviendrais avec Yvan West Laurence, à partir de 16h, sur le Flux Conférences, pour parler impression3D.

Si c'est possible, mon intervention sera suivie d'une session démo avec chat, ou j'expliquerai concrètement et techniquement comment se passe une impression, de l'idée à l'objet physique, pour qui voudrait débuter dans le domaine.

Jeudi, janvier 1 2015

Domotique avec raspberryPi et Domoticz

J’utilise depuis quelques mois une solution domotique qui me donne pleinement satisfaction. Cette solution relativement économique repose sur l’utilisation d’un RaspberryPi avec le logiciel Domoticz ainsi que d’un « modem » radio 433MHz RFXCom

Je ne vais pas détailler l’installation de Domoticz, tout est décrit sur leur site et l’opération reste très simple.

Mes besoins essentiels concernent les consommations de l’habitation ( eau, gaz, électricité ) et les relevés de température et humidité dans certaines pièces. De plus, je pilote quelques lumières ainsi qu’un radiateur de type sèche serviettes. Depuis quelques temps j’ai ajouté des capteurs d’ouverture sur les Vélux et les portes. Je peux ainsi savoir par une notification sur le téléphone si l’on quitte la maison avec un Vélux oublié ouvert…

La solution à base de technologie radio en 433MHz présente quelques avantages:

  • Le prix
  • Le nombre de modules disponibles sur le marché
  • La possibilité de créer facilement ses propres capteurs avec un arduino par exemple

Le gros inconvénient c’est que contrairement au Zwave, il n’y a pas de retour d’état. Pour piloter des éléments « critiques » comme le chauffage, c’est un peu gênant mais on peut y remédier d’une façon assez satisfaisante à l’aide d’un script.

Les modules que j’utilise sont disponibles facilement dans les grandes surfaces de bricolage ou sur internet.

 

Le raspberry équipé d’une carte RFM12Pi en 868MHz pour un usage futur.

RasberryPi
RaspberryPi

 

Le modem RFXCom. On pourrait en créer un avec un arduino pour beaucoup moins cher mais il faut décoder les différents protocoles ce qui m’aurait demandé trop de temps. J’ai donc préféré acheter un module « tout fait » et consacrer plus de temps sur les autres parties.

Module RFXCom
Module RFXCom

 

Des sondes de température Oregon sont disposées aux endroits stratégiques ( Salon, Salle de bain, extérieur, chambres…)

Capteur oregon de température et humidité
Capteur Oregon de température et humidité

 

Le carillon de la porte d’entrée est lui aussi compatible. Il peut donc servir d’alerte sonore si besoin, d’autant qu’il dispose de 3 mélodies utilisables avec des codes différents.

Carillion
Carillon

 

Pour les Vélux, de simples capteurs d’ouverture

Capteur d'ouverture
Capteur d’ouverture

 

Pareil pour la porte du garage

Capteur d'ouverture
Capteur d’ouverture

 

Il y a aussi un capteur de mouvement pour le déclenchement d’un éclairage et d’une notification sur smartphone

Capteur de mouvements
Capteur de mouvements

 

Les lumières sont pilotables par ces petits relais.

Module d'éclairage
Module d’éclairage

J’utilise aussi les modules d’éclairage pour piloter le sèche serviette. Attention, il faut le piloter au travers du fil pilote. Il y a une petite astuce très bien décrite sur le site d’Alexandre.

La consommation électrique est relevée par un OWL180. Une petite pince ampèremétrique branchée sur le compteur transmet la consommation en temps réel.

Consommation électrique - OWL180
Consommation électrique – OWL180

 

Un petit écran déporté affiche la consommation en temps réel

Consommation électrique - OWL180
Consommation électrique – OWL180

 

Pour le gaz, c’est un peu plus compliqué mais aussi plus amusant. Les modules du commerce sont très chers, le DIY vient à la rescousse.

Capteur DIY Gasmonitor
Capteur DIY Gasmonitor

C’est simple, un arduino relève les impulsions générées par le compteur de gaz (un aimant est placé sur la roue du compteur) et les transmet à Domoticz par radio. On peut capter les impulsions d’un compteur de gaz avec un interrupteur reed.

Par la même occasion je relève la température et l’humidité du garage avec un DHT22.

Je vais aussi ajouter la consommation d’eau un peu plus tard.

IMG_20141230_095054_

Et le circuit vraiment très simple

Sélection_023

Le schéma et le code pour programmer l’arduino sont sur Github ici. C’est une première version mais ça marche très bien.

Pour la transmission des informations, j’ai utilisé une librairie permettant de simuler un capteur de type RFXMeter et RFXSensor. Du coup domoticz détecte le capteur tout seul comme un grand. Pour les informations de température et d’humidité, j’ai plutôt utilisé le format Oregon V2 gentiment mis à disposition par Olivier ici. Le nombre d’impulsions comptées est stocké dans l’EEPROM de l’arduino toutes les heures afin de ne pas perdre les informations en cas de coupure de courant.

Un seul arduino peut donc émuler toutes les sondes possibles et imaginables. D’autant qu’il ne faut qu’un arduino et un petit transmetteur 433MHz qui coûte 2-3€ ! Pour les arduino, j’utilise des Mini Pro en 5v ou en 3.3v suivant le type d’alimentation.

 

Après les informations concernant le matériel, voilà un petit tour de ce que ça donne dans Domoticz.

 

Le dashboard
Le dashboard
Les compteurs
Les compteurs
La conso de gaz
La conso de gaz
Les rapports d'électricité avec les coûts
Les rapports d’électricité avec les coûts
La météo
La météo
Des scénarios
Des scénarios

 

Des scripts lua sont aussi possibles pour faire ce qui n’est pas possible avec l’interface web. Ici par exemple, on envoie une notification sur mobile si la porte du garage est restée ouverte. Pratique avec des enfants :-D

print(‘Porte de garage…’)

t1 = os.time()
s = otherdevices_lastupdate[‘Porte de garage’]
— returns a date time like 2013-07-11 17:23:12

year = string.sub(s, 1, 4)
month = string.sub(s, 6, 7)
day = string.sub(s, 9, 10)
hour = string.sub(s, 12, 13)
minutes = string.sub(s, 15, 16)
seconds = string.sub(s, 18, 19)

commandArray = {}

t2 = os.time{year=year, month=month, day=day, hour=hour, min=minutes, sec=seconds}
difference = (os.difftime (t1, t2))
if (otherdevices[‘Porte de garage’] == ‘Open’ and difference > 300 and difference < 400) then
commandArray[‘SendNotification’]=’La porte de garage est ouverte depuis plus de 5 minutes!’

end

return commandArray

Il y a aussi des applications android / iphone pour piloter le tout avec son mobile.

Voilà un bref aperçu de ce que l’on peut faire. Tout ou presque est possible ! Si vous avez des questions sur cette solution, n’hésitez pas à laisser un commentaire :)

- page 1 de 42