BreizhMakers

Ca faisait longtemps déjà que j'avais envie d'un Miroir Magique, dit aussi Miroir Intelligent.

J'ai enfin le temps de m'y consacrer :)

L'idée est donc d'avoir un miroir semi-transparent qui fournit tout un tas de services, le plus intelligemment possible :)

Parmi ce que j'envisage:

• Affichage d'un calendrier, de l'heure, des prévisions météo
• Affichage des emails non-lus de ma femme (sur commande)
• Affichage automatique du trafic entre chez moi et mon lieu de travail (Rennes) le matin (avec affichage sur demande aussi)
• Affichage de la webcam de l'aéroclub et du flux vidéo venant de l'imprimante 3D.
• Flux de news
• Commande vocale
• Commande tactile
• Détection de présence via la caméra du Raspberry Pi (voire même détection de visage).

J'ai trouvé un écran d'occasion aux dimensions idéales, et doté de haut-parleurs intégrés, ce qui va me permettre de diffuser des notifications ou messages audio facilement.

J'ai rapidement désossé l'écran, pour constater que je vais devoir garder le cadre arrière en plastique, car toute l'électronique ainsi que les haut-parleurs y sont fixés. C'est pas bien grave, le miroir sera juste un peu plus épais.

Les dimensions intérieures du cadre sont 500x310mm. 

N'étant pas équipé pour faire des découpes propres à 45°, je vais le faire faire sur mesure. Reste à voir si la partie "boite" sera faite avec ou si je le fais moi-même.

Concernant le miroir sans tain, dit aussi miroir espion.

Après avoir contacté une miroiterie qui pour une raison étrange ne prenait de devis ni par téléphone ni par email (?!) j'ai suivi les avis déposé sur Google pour Glasren, et je n'ai pas été déçu. Devis rapide et la commande devrait être prête d'ici quelques jours. Bon j'en ai quand même pour 95€ mais le résultat devrait être infiniment mieux qu'un film réfléchisant ou qu'un miroir acrylique.

Je prévois de percer des aérations sur les tranches haute et basse et d'y mettre une grille imprimée à la maison.

Le tout sera fixé au mur via un rail de fixation pour tableau lourd trouvé chez BricoDépôt.

Le coeur du miroir est un Raspberry Pi 3 équipée de la caméra qui va avec.

Elle sera logée juste sous l'écran, j'ai réservé une zone de 5cm à cet effet.

De part et d'autre de la caméra seront disposées des touches capacitives reliées à une carte MPR121 de chez Sparkfun. Ces touches seront invisibles côté miroir et permettront de commander l'affichage des différents modules (en plus de la commande vocale). Les tests de faisabilité ont montré que la détection est OK à travers une plaque de verre.

Tests de faisabilité des touches capacitives:

J'ai aussi un mini-micro USB pour la commande vocale. Il sera placé près d'une grille d'aération.

Le logiciel est construit autour de l'excellent MagicMirror². 

C'est en quelque sorte un framework pour développer un miroir magique.

Il dispose de tout un tas de modules et est assez facilement extensible pour peu qu'on connaisse le développement web (HTML/Javascript/CSS et NodeJS).

J'ai d'ailleurs contribué un module qui permet d'utiliser le gestionnaire de touches capacitives MPR121: MMM-MPR121. J'ai aussi contribué à la francisation d'autres modules.

J'ai suivi la procédure décrite ici à la lettre, et ça a fonctionné du premier coup.

A l'heure actuelle, la partie logicielle est quasiment terminée. Il ne reste que le paramétrage final à faire une fois le tout intégré avec l'écran final et les touches capacitives.

Le miroir répond à la voix et affiche les modules en fonction.

Les 2 touches capacitives actuellement câblées permettent de réafficher le profil par défaut, d'éteindre l'écran et d'éteindre le raspberry PI. (on a deux fonction par touche: un appui court  ou long).

Les modules que j'utilise, hormis ceux installés par défaut sont:

• googlemap
• iFrame
• MMM-Globe
• MMM-ModuleScheduler
• MMM-ProfileSwitcher
• MMM-MPR121
• MMM-Remote-Control
• MMM-SystemStats
• motiondetector
• voicecontrol

Une fois encore l'inspiration m'est venue en lisant l'excellente revue Hackable. Et une fois encore je me suis dis que c'était sympa mais que je pouvais faire mieux ;)

J'ai donc décidé de restaurer deux lampes à pétrole données par un ami à qui j'avais eu la bonne idée de faire part de mon projet ;) avec les objectifs suivants:

• Aucune consommation d'énergie quand la lampe est éteinte
• Différents modes d'éclairages
• Réutilisation de la commande de la mèche de la lampe pour régler l'intensité et/ou la couleur de la lampe.
• Réutilisation (quand c'est possible) du bouchon du réservoir pour changer de mode d'éclairage.

J'ai une grande et une petite lampe. J'ai rapidement vu que je ne pourrai pas loger le contacteur rotatif à 2x6 contacts sous le bouchon du réservoir de la petite. La petite lampe utilisera donc le poussoir de l'encodeur rotatif pour changer de mode d'éclairage. L'encodeur rotatif étant accouplé à la commande de la mèche (plus de détails plus loin).

Côté éclairage, j'ai commandé des couronnes de LED WS2812B de différents diamètres qui feront très bien l'affaire.

Côté micro-contrôleur, l'ATMega328P est tout indiqué. Il me reste encore quelques unes des géniales cartes Evil-Mad Scientist qui sont tout à fait adaptées à ce besoin. C'est bien plus propre qu'une plaque à trous et bien plus simple que de devoir faire son propre circuit imprimé.

Les différents modes d'éclairage que j'ai envie de proposer sont:

• Eclairage fixe et réglage de l'intensité via la molette
• Eclairage fixe et réglage de la couleur via la molette
• Eclairage "arc-en-ciel" fixe et réglage de l'intensité via la molette
• Eclairage "arc-en-ciel" rotatif et réglage de l'intensité via la molette
• Eclairage "simulateur de flamme"

Schéma électrique de la grande lanterne (avec contacteur rotatif):

Schéma électrique de la petite lanterne (sans contacteur rotatif):

Manette de commande

J'ai eu pas mal de boulot côté hardware: découpes au Dremmel, modélisation et impression 3D.

Il a tout d'abord fallu démonter le mécanisme d'alimentation de la mèche et trouver où placer l'encodeur rotatif en prolongement avec l'axe du mécanisme. Le disque de découpe du Dremmel fut un outil précieux dans cette tâche!

Pour coupler la manette avec l'encodeur j'ai essayé deux méthodes:

Pour la première lanterne où j'avais pas mal de place j'ai utilisé du plastique EasyPlast (qui fond à 60°) trempé dans de l'eau chaude puis modelé à la main et au pistolet à air chaud. Ce plastique est  quand même vachement pratique car ça permet modeler à la main des pièces très solides après refroidissement.

Pour la seconde j'ai usiné le bout de la manette pour qu'il entre à forcer dans l'encoche de l'axe de l'encodeur rotatif.

Support de LEDs et Diffuseur

J'ai modélisé un support paramétrable pour les anneaux de LED (avec OpenScad) afin de pouvoir poser l'anneau à plat tout en ménageant un espace pour les soudures et les câbles.

Le modèle est disponible dans le dépôt github donné à la fin de ce billet.

Il m'a fallu aussi modéliser un diffuseur. J'ai fait pour cela un modèle paramétrique dans OpenScad qui permet de modéliser une calotte sphérique avec un diamètre, une hauteur et une épaisseur paramétrable. J'ai ainsi imprimé des diffuseurs adaptés à chaque lampe, en PLA transparent.

Support de la carte électronique

J'ai aussi eu besoin d'un support pour fixer la carte électronique au fond du réservoir.

Là j'ai opté pour Fusion360 qui m'est bien plus simple à utiliser pour ce genre de pièce (le modèle est disponible dans le dépôt github).

J'ai imprimé un support adapté à chaque taille de lampe, fixé par deux vis dans une découpe du fond du réservoir.

Support de la petite lanterne:

Fixation du contacteur rotatif

Après avoir réfléchi à plusieurs solutions pour fixer le contacteur rotatif sous le bouchon de réservoir de la grande lanterne j'ai fini par modéliser une bride de fixation (avec Fusion360) sur laquelle le contacteur est vissé, et qui est collée à la colle époxy à l'intérieur du réservoir.

J'ai aussi usiné un méplat sur l'axe du contacteur.

Enfin concernant le bouchon du réservoir, j'ai dû meuler son pas de vis, percer un trou en son centre et y faire un méplat en collant une barrette métallique à la colle époxy.

Il ne restait plus qu'à faire la partie logicielle :)

Logiciel

Côté logiciel j'ai commencé par utiliser la librairie WS2812FX, qui utilise la librairie Neopixel d'Adafruit. Elle n'est pas mal, elle dispose de plein d'effets, mais rien qui ne me convenait.

C'était une bonne occasion d'utiliser la librairie FastLED dont j'avais entendu parler par ailleurs. Elle est relativement bien documentée mais surtout bien plus compacte (et très portable).

J'ai pu sans problème faire ce dont j'avais besoin.

Pour la partie simulateur de flamme, j'ai fait plusieurs essais pas vraiment convaincants et je suis revenu à celui que je préfère pour ce genre d'usage: Celui-ci. Je l'ai simplement adapté pour utiliser FastLED pour piloter mes LED et pour permettre de sortir facilement d'une boucle de simulation quand on change de mode d'éclairage.

C'était la première fois que j'utilisais un encodeur rotatif. J'ai essayé diverses librairies pour finalement retenir celle de PJRC. Elle a l'avantage de pouvoir fonctionner avec ou sans interruptions, d'être simple à mettre en oeuvre et de permettre d'initialiser la valeur que manipule l'encodeur.

Les valeurs de luminosité, de couleur, et de mode (pour la petite lanterne uniquement) sont stockées dans l'EEPROM afin que la lampe se rallume dans le même état qu'elle s'est éteinte (les valeur ne sont écrites qu'en cas de modification).

Le code est commenté, il ne devrait pas poser de problème à ceux qui souhaiteraient le réutiliser.

Le code, le schéma électrique et les modèles 3D sont disponibles sur ce dépôt github.

Le résultat final:

Ma femme souhaitait disposer d'un sonomètre lumineux afin que ses élèves voient vraiment combien ils sont parfois bruyants :)

J'ai un Sonomètre WENSN WS1361 déjà mis en oeuvre sur un autre projet.

L'idée là est d'avoir un bargraphe lumineux, avec seuil maximal réglable, et la valeur de pic qui reste allumée pendant plusieurs secondes.

Du côté du logiciel, j'ai réutilisé le code Python permettant d'accéder au Sonomètre, en l'adaptant à mon besoin.

Le bargraphe est constitué de deux barres de LED WS2812B (NeoPixel) et piloté via l'excellente librairie  rpi_ws281x. Un exemple d'utilisation est donné sur le site de Adafruit.

Attention: Avec mon RPi3 j'ai dû désactiver l'audio sur le HDMi car ça empêchait le fonctionnement correct de la librairie. Il faut pour cela commenter/ajouter les lignes suivantes au fichier /boot/config.txt.(plus d'infos ici):

#dtparam=audio=on
hdmi_force_hotplug=1
hdmi_force_edid_audio=1

Concernant le réglage du seuil maximal, le RPi ne dispose malheureusement pas d'entrée analogique. Comme je voulais garder le montage le plus simple possible, j'ai eu recours à un montage à base de filtre R variable / C branché sur une sortie et une entrée numérique. La mesure de la position du potentiomètre se traduit par une mesure de temps de charge du condensateur, qui lui est proportionnel. C'est rustique et relativement peu précis, mais très suffisant pour l'usage envisagé. Le code dont je me suis inspiré est celui-ci.

J'ai ensuite fait de ce script Python un service SystemD afin qu'il démarre automatiquement au boot. Je me suis inspiré de cet article.

Tout le code est disponible sur ce dépôt GitHub.

Premier prototype, sans boîtier ni diffuseur:

Côté Hardware j'ai imprimé un boitier pour RPi3 trouvé sur Thingiverse, que j'ai ensuite usiné au Dremmel pour y ménager les ouvertures pour passe les câbles et l'axe du potentiomètre de réglage. 

Le diffuseur est constitué d'un morceau de plastique translucide de récupération sur lequel j'ai collé à la colle chaude les 2 barres de 8 LED Neopixel ainsi que l'adaptateur de niveau 3.3v vers 5v

La base du diffuseur a été modélisée sur Fusion360 (mon outil préféré, avec Openscad pour les pièces paramétriques) et imprimée à la maison.

Le sonomètre lumineux terminé, alimenté par une batterie:

Le système est depuis utilisé couramment en classe et fait l'unanimité chez les professeurs! :)

J'ai beaucoup de demande et je commence à réfléchir à une version plus compacte et ne nécessitant pas un sonomètre externe.

Une petite vidéo de démonstration: 

Depuis que j'ai découvert le bac à sable "augmenté" de O Kreylos j'ai eu envie d'en faire un.

Il se trouve que le chercheur auteur du site et du logiciel a eu la bonne idée de mettre le logiciel en open-source, et surtout de documenter la procédure d'installation et de calibrage d'une façon exceptionnelle. Ca simplifie grandement la mise en oeuvre!

J'ai modifié cette procédure pour l'adapter à mon cas d'usage où l'image projetée n'est pas exactement de la taille du bac à sable. Je ne vais pas reprendre ici tous les détails de la procédure "officielle", extrêmement bien documentée ici, mais seulement donner quelques explications complémentaires.

• Il faut impérativement un ordinateur équipé d'une carte graphique nVidia (une carte moyen de gamme suffit).
• Le système d'exploitation requis est Linux. J'ai choisi la version Linux Mint recommandée, sur laquelle j'ai ensuite installé le pilote graphique nVidia propriétaire requis.
• Une Kinect Version 1 et un adaptateur pour PC (disponible pour une quinzaine d'euros sur ebay par exemple) afin de pouvoir la brancher sur un port USB.
• Le vidéoprojecteur utilisé doit être HDMI, de préférence avec une résolution supérieure ou égale à 1024 x 768 pixels, et avec une courte focale, afin de pouvoir avoir une grande image sans trop d'éloignement.

Aucune indication n'est donnée quant à la construction du bac à sable et du support de projecteur.

La dimension recommandée est d'environ 1m x 0.75m sur 15cm de profondeur.

Je recommande plutôt de mesurer la taille de l'image obtenue avec le projecteur souhaité à une distance de 1.20m environ et de construire le bac à sable à cette dimension.

Mon bac à sable fait donc 1m x 0.75m sur 17.5cm de profondeur.

Il est assemblé à partir de planches découpées et d'un fond de contreplaqué de 15mm d'épaisseur.

Les angles des planches sont "crantés", c'est un peu galère à découper au ciseau à bois mais je trouve que ça offre la meilleure solidité. Le tout est collé et vissé.

J'ai ajouté 4 poignées métalliques pour faciliter le transport.

Le support de vidéoprojecteur est construit à base de profilé en U de 1m de longueur et 20mm de côté et d'équerres métalliques vissées sur ce profilé.

Je conseille plutôt du profilé rectangulaire assez solide (genre 20mm x 35mm) car mon support, bien que solide, est un peu trop souple et oscille quand on le touche.

Le vidéoprojecteur est posé sur une planche en médium.

Le miroir est quant à lui un simple miroir de salle de bain, avec des supports en tasseau, des petites équerres-butées et quelques points de colle chaude. J'avais initialement mis le miroir à 45° mais avec mon projecteur il vaut mieux quelques degrés de plus pour avoir une image centrée.

Enfin le support de la Kinect est constitué de 4 équerres collées à la super-glu sur les profilés alu et de colliers auto-serrants. Il y a juste assez de jeu pour pouvoir enlever la Kinect en la faisant glisser dans son support.

Là encore, en l'absence de documentation sur comment construire un support optimal, cette solution n'est pas la meilleure, car la Kinect ne voit pas tout à faire tout le bac à sable. Il vaudrait mieux soit augmenter un peu la hauteur du support, soit placer la Kinect sur les profilés plutôt qu'au-dessous tel que je l'ai fait.

En ce qui concerne le sable proprement dit, j'ai utilisé du sable blanc de décoration. Il faut compter entre 50 et 75 Kg de sable.

Si comme moi vous avez un ordinateur sous Windows 10 avec un boot UEFI avec Secure Boot activé, il faut le désactiver sinon le pilote Linux de la carte graphique NVidia refusera de se charger.

Pour cela, aller dans les paramètres UEFI (shift + reboot puis suivre les menus) et une fois dans le menu de paramétrage UEFI:

• Affecter un Manager Password (et notez le!)
• Vous pourrez alors désactiver Secure Boot (sans Manager Password on ne peut pas le désactiver)

L'installation et la compilation des logiciels n'est pas vraiment problématique, même s'il vaut mieux connaitre un peu Linux pour être plus à l'aise.

La procédure de calibration, bien que très bien documentée (pour qui lit et comprend l'anglais) est plus compliquée. Enfin il ne m'a quand même fallu que deux tentatives pour que ça fonctionne parfaitement.

J'ai suivi la procédure décrite ici avec des ajustements car l'image de mon projecteur ne couvre pas tout le bac à sable.

Une info importante qui n'est documentée que dans les commentaires de la vidéo:

• Pour déplacer l'image dans RawKinectViewer: il faut maintenir la touche z et déplacer la souris.
• Pour zoomer, il faut utiliser le zoom à deux doigts sur le touchpad.

Cette vidéo décrit bien tout le process en détail.

Quelques infos en vrac, qui peuvent être utiles (elles sont expliquées dans la vidéo):

• Pour assigner un bouton à une fonction il faut appuyer sur un bouton puis avec la souris sélectionner la fonction qu'on désire assigner.
• Quand on lance CalibrateProjector, il faut aller sur sa fenêtre (projecteur) et cliquer avec le bouton de gauche une fois, avant de pouvoir faire la procédure de calibration

Les étapes que j'ai adaptées à mon cas:

A l'étape 7, "calculate your sandbox base plane", j'ai simplement pris des mesures sur une zone plus petite que celle indiquée afin d'être sûr de ne mesurer que le fond du bac à sable (cette étape établit une équation du plan du fond du bac à sable par rapport à la Kinect).

A l'étape 8, "Measure the 3D extents of the sand surface", comme j'avais du mal à déterminer les limites de l'image sur la vue "depth image" de la Kinect, j'ai procédé ainsi:

J'ai utilisé un cylindre de 10cm de hauteur et 2 cm de diamètre, que j'ai placé pour chaque mesure, sur le coin dont on mesure les coordonnées (dans l'ordre spécifié par la doc, c'est indispensable).

Une fois les mesures sur les 4 coins réalisées, j'ai simplement ajouté 10 aux mesures de profondeur avant de les copier dans le fichier src/SARndbox/etc/SARndbox-2.8/BoxLayout.txt

ATTENTION: L'ordre des points de mesure doit absolument être: bas-gauche, bas-droite, haut-gauche, haut-droite, dans les positions telles qu'elles apparaissent dans RawKinectViewer (et non sur le bac à sable lui-même. Par ex avec ma position de Kinect (inversée), les positions sur le bac sont toutes autres que celles montrées par RawKinectViewer)

Après avoir complété le fichier src/SARndbox/etc/SARndbox-2.8/BoxLayout.txt avec les infos précédentes, le plus dur est fait.

Il reste alors à faire l'outil de calibrage indiqué, à l'aide d'un vieux CD, un peu de papier et de fil de fer, puis à procéder à la dernière partie du calibrage consistant à calibrer l'image vue par la Kinect et celle affichée par le projecteur (étape 10).

Une fois cette étape effectuée il ne reste plus qu'à lancer l'application SARndbox et à profiter de la magie d'un bac à sable augmenté!

~/src/SARndbox/bin/SARndbox -uhm -fpv -evr -0.002

-evr 0.002 est le taux d'évaporation de l'eau (s'il est jugé trop rapide on peut le diviser par deux, ou inversement s'il est trop lent).

J'ai ensuite suivi la procédure décrite ici pour que la sandbox passe automatiquement en plein écran et pour affecter la touche R à la pluie et D à l'assèchement (Rain / Drain).

Mon fichier SARndbox.cfg est le suivant:

section Vrui
    section Desktop
        section MouseAdapter
            mouseIdleTimeout 5.0
        endsection
        
        section Window
            windowFullscreen true
        endsection
        
        section Tools
            section DefaultTools
                section WaterTool
                    toolClass GlobalWaterTool
                    bindings ((Mouse, r, d))
                endsection
            endsection
        endsection
    endsection
endsection

Je n'ai pas documenté cette partie, mais les boutons sont connectés à une carte à base de microcontroleur ATMega 32U4 Mini, genre ceci.

Cette carte est simplement programmée avec un sketch d'émulation de clavier USB et envoie les touches R et D selon le bouton pressé.

Le code est rudimentaire:

#include <Keyboard.h>
#include <Bounce2.h>

#define BUTTON_PIN_1 A0
#define BUTTON_PIN_2 A1
#define DEBOUNCE_INTERVAL 5

#define CHAR_1 'r'
#define CHAR_2 'd' 

Bounce debouncer1 = Bounce(); 
Bounce debouncer2 = Bounce(); 

void setup() {
  pinMode(BUTTON_PIN_1,INPUT_PULLUP);
  debouncer1.attach(BUTTON_PIN_1);
  debouncer1.interval(DEBOUNCE_INTERVAL);

  pinMode(BUTTON_PIN_2,INPUT_PULLUP);
  debouncer2.attach(BUTTON_PIN_2);
  debouncer2.interval(DEBOUNCE_INTERVAL);

  Keyboard.begin();
}

void loop() {
  debouncer1.update();
  debouncer2.update();

  if(debouncer1.read() == LOW){
    Keyboard.press(CHAR_1);
  }
  if(debouncer1.rose()){
    Keyboard.release(CHAR_1);
  }
  if(debouncer2.read() == LOW){
    Keyboard.press(CHAR_2);
  }
  if(debouncer2.rose()){
    Keyboard.release(CHAR_2);
  }
}
 

Il commence à faire chaud dans mon bureau et dans mes combles et j'avais envie de pouvoir mesurer la température avec plus de précision que le bout de mon nez :)

L'ESP8266 est une solution remarquablement adaptée pour cela avec sa connectivité wifi (et HTTPS) intégrée et son faible coût.

J'utilise la version NodeMCU (programmée en C) car pour seulement quelques euros de plus j'ai un port USB et une alimentation 5V via l'USB.

Le capteur de température est un DHT22, bien plus précis qu'un DHT11 et pas beaucoup plus cher.

Les broches D0 et Reset sont connectées entre elles afin de permettre à l'ESP8266 de se réveiller correctement après avoir été mis en deep-sleep.

Le DHT22 est connecté sur la broche D4 (GPIO02). Allez comprendre la numérotation des broches!

Concernant le stockage et la visualisation des données, j'ai cherché plusieurs solutions.

J'ai commencé par jeter un oeil à Thingspeak. C'est très simple à utiliser (un simple post HTTPS (voire HTTP mais c'est pas recommandé niveau sécu) et ça fournit une visualisation rudimentaire, extensible via différents moyens mais pas super bien documentée à mon goût (au choix via MathLab ou via HighCharts et un éditeur javascript/HTML intégré).

J'ai découvert il y a peu le PaaS IoT d'OVH (sur leur plateforme de "labs" Runabove).

Ils mettent à disposition un serveur OpenTDSB (protocole open-source de base de données temporelle). Il n'y a pas d'IHM de consultation, mais pour cela on peut utiliser Grafana, qu'il faut alors installer chez soi ou sur un cloud quelconque.

J'ai donc installé Grafana et j'y ai configuré un tableau de bord qui m'affiche des graphes et métriques de température et d'humidité de mes deux thermo-hygromètres connectés (un chez moi et un au boulot).

Voici ce que ça donne par exemple:

Le code source est disponible sur mon GitHub.

Il nécessite l'IDE Arduino avec la carte supplémentaire ESP8266.

La visualisation des données est faite avec Grafana, qui parle directement au PaaS IoT d'OVH avec le protocole OpenTSDB.