Mur interactif

De fablab
Aller à : navigation, rechercher

Informations générales

Encadrant: Stan Borkowski

Elèves: PIERSON Romain, DUMAS Arthur


Lieu : le projet aura lieu dans les ateliers d'Amiqual4Home ainsi qu'au fabMSTIC

Ce projet a été réalisé par un groupe de 2 étudiants et portait sur des IHM et des environnements intelligents.


Contexte

Ce projet s'inscrit dans le cadre plus général d'un projet appelé “Amiqual4Home” qui vise à soutenir la recherche et innovation dans le domaine d’habitat intelligent ou habitat connecté.

Amiqual4Home dispose d’une plateforme d’expérimentation sous forme d’un appartement instrumenté, lequel est utilisé pour des expérimentations mettant en ouvre des nouvelles technologies dans un contexte d’habitat.

Exemple des capteurs et actionneurs disponibles dans l’appartement : localisation 3D, capteur de mouvement, luminosité, qualité de l’air, température, reconnaissance de la parole, compteurs électriques, compteurs d’eau.

L’objectif de ce projet est d’enrichir l’environnement de l’appartement d’Amiqual4Home avec un mur interactif.


Sujet

Les étudiants développerons un mur interactif intégré dans l’environnement informatique de l’appartement d’Amiqual4Home. Il permettra de contrôler divers actionneurs existants, tels que les multimédia, les lumières ou les stores.

Le dispositif sera composé des panneaux décoratifs équipés des capteurs capacitif et piézoélectriques.

La conception des panneaux sera réalisé par un désigner en parallèle de votre travail.


Compétences qui seront acquises / mises en oeuvre

  • étude de fonctionnement des capteurs capacitifs pour la capture de proximité et des gestes de l’utilisateur
  • programmation en Arduino sur microcontrôleur compatible
  • design et fabrication du dispositif avec les machines d'un FabLab (électronique, modélisation 3D)
  • conception d’une API pour le dispositif
  • intégration du dispositif dans un environment domotique sous OpenHAB
  • (optionnel) programmation Android d’une application de configuration et de contrôle


Exemple d’un scénario d’utilisation du mur

Incrustation-s.jpg
Scenario.jpg


Environnement de travail

Dans le but de téléverser et d'exécuter du code sur le microcontrôleur donné, il faut développer sous Arduino. Une fois l'IDE installé et lancé, il faut sélectionner le bon type de carte.

Il faut préalablement ajouter l'url suivante [1] dans Fichier, Préférences puis URL de gestionnaire de cartes supplémentaires. Ensuite, l'onglet Outils puis Type de carte puis Gestionnaire de carte permet d'ouvrir le catalogue des plateformes disponibles. Rechercher esp8266 et cliquer sur Installer.

Maintenant nous pouvons développer et téléverser du code sur notre puce.

Mais les possibilités sont limitées, et dans le cadre de ce projet, nous allons avoir besoin de manipuler des LEDs avec l'API NeoPixelBus. La bibliothèque à installer doit cette fois être importée depuis l'onglet Croquis, Inclure une bibliothèque, Gérer les bibliothèques puis en recherchant NeoPixelBus by Makuna. Nous sommes prêts à développer.

Etapes du projet

Découverte du détecteur et des capteurs

Fdc.png
Capteurs

La puce fournie par Stan Borkowski est nommée FDC 2214 EVM. C'est un processeur relié à des capteurs capacitifs, qui permet de mesurer la capacité de ces capteurs. Cette capacité étant dépendante de l'environnement des capteurs et en particuliers des mains, membres humains qui sont reliés au sol donc à la terre, permettent de détecter leur présence avec différentes mesures. Il est donc possible de détecter des déplacements précis avec suffisamment de capteurs, et une présence même relativement loin avec un capteur plus large. La documentation de ce matériel est présente sur le site: http://www.ti.com/lit/ds/symlink/fdc2212.pdf. Nous avons pu avec un logiciel adapté (Sensing solution EVM GUI), des capteurs disposés sur la carte fournie et des capteurs en aluminium tester ce principe. En effet, ce logiciel nous a permis de voir que la capacité chutait drastiquement lors d'un contact (humain) avec le capteur et augmentait modérément lors d'une approche sans contact. Malheureusement, cette première idée était propre au logiciel puisque des analyses ultérieures ont démontrées qu'en fait la capacité diminuait aussi lors d'une approche sans contact.

Découverte du microcontrôleur

Node-mcu.jpg
Microcontrôleur Node MCU

Le microcontrôleur ESP 8266 est programmable et compatible avec l'Arduino. Malgré des soucis de compatibilité avec les machines linux de l'IDE Arduino, nous avons réussit à téléverser du code sur cette puce grâce à Windows. Cependant il fallait désormais relier correctement la puce et le capteur. Pour ce faire, nous avons étudié longuement la documentation du détecteur et celle du microcontrôleur trouvée sur github (http://esp8266.github.io/Arduino/versions/2.1.0/doc/reference.html).

Esp8266-node-mcu-pinout.png
Pin map du microcontrôleur

Voici le mapping final (microcontrôleur <= capteur) :

 - D1 <= SCL
 - D2 <= SDA
 - D6 <= SD
 - D7 <= ADDR
 - GND <= GND
 - 3.3V <= 3.3V

Le port INTB côté capteur ne nous intéresse pas puisqu'il concerne les interruptions.

Pour vérifier que nos branchements étaient corrects, nous avons utilisé la LED interne au microcontrôleur. Dans un premier temps pour voir si l'on pouvait la faire clignoter sans utiliser les capteurs, puis si en lisant les valeurs en provenance des capteurs nous pouvions faire la même chose.

Ajout du banc de LEDs

Neopixelbus.jpg
LEDs associées à la librairie NeoPixelBus

Deux difficultés ici. La première consistait à brancher correctement le câble de DATA des LEDs. Notre première approche consistait à tester les ports les plus probables et de voir si nous arrivions à allumer une LED, mais la deuxième difficulté (nous y reviendrons) nous en empêchait. Une (longue) lecture des documentations de la puce et des LEDs a finalement permit d'identifier que c'est le port GPIO3 de la puce qui doit recevoir les données, puis que ce port a un deuxième nom qui est RX.

Le mapping (microcontrôleur <= LEDs) est donc :

 - RX <= DATA
 - GND <= GND
 - Vin <= 5V

La deuxième difficulté était de voir (et de lire) que l'usage du moniteur de debug intégré au logiciel Arduino, ou plutôt son initialisation, nuit à l'initialisation du banc de LEDs.

En clair, il faut d'abord initialiser le moniteur puis les LEDs, car celle du moniteur effectue un reset forcé sur tous les ports de la puce et annule donc tous les réglages effectués en ce sens.

  Serial.begin(9600); //écran de debug   
  strip.Begin(); //initialisation des LEDs

Le code Arduino

Presque toutes les macros (variables et paramètres globaux) peuvent être modifiées en début de code. Le code peut être retrouvé sur https://github.com/romzie/MurInteractif/

Initialisation des valeurs

L'idée est la suivante : il faut étalonner les capteurs au lancement du programme. Pour cela, on utilise la moyenne d'un échantillon de valeurs lues pour chaque capteurs. On soustrait ensuite une marge d'erreur qui correspond à un pourcentage (45% semblait bien) de la différence entre la moyenne et la valeur minimale lue pendant l'étalonnage.

Ceci permet de ne pas détecter les légères variations de capacité lorsque l'utilisateur est éloigné, qui pourrait être interprétées comme ses mouvements.

Une deuxième précaution concernant les valeurs de référence consiste à attendre 2 secondes avant l'étalonnage pour éviter les valeurs farfelues dues au démarrage du système.

Valeurs mesurées

Même principe que pour l'initialisation, on fait une moyenne d'un échantillon de valeurs de taille prédéfinie avec une macro.

Slider à 2 électrodes

L'idée est de faire en sorte que les LEDs suivent le mouvement d'un doigt (ou d'une main) qui se déplace entre les capteurs.

Le calcul de la position de la main se fait de la manière suivante : en supposant que les valeurs de référence sont du même ordre de grandeur, on calcul la différence avec la valeur mesurée, puis on calcul la fraction de cette différence sur la somme des différences, ce qui nous donne un ratio.

Ensuite, ce ratio est converti en numéro de LED, qui représente la position de la main. Pour plus de beauté visuelle, on fait également un dégradé de couleurs depuis le position de la main vers les extrémités. Les deux couleurs sont prédéfinies dans le code pour cet exemple.

Slider2.png
Schéma du slider à 2 électrodes

Slider circulaire à 3 électrodes avec bouton

Slider-lum.png
Schéma du prototype

Disposition plus complexe : 3 électrodes sont disposées de manière à couvrir un cercle et une quatrième est disposée à côté de façon à simuler un bouton. Les LEDs sont disposées à l'intérieur du cercle, en cercle aussi. On utilise la même technique de ratio afin de situer la main sur le cercle, mais avec trois électrodes.

Le bouton permet de passer au mode suivant en s'en approchant ou en le touchant selon l'ordre établi ci-dessous. L'appui sur le bouton fait donc aussi office de validation de la sélection pour les modes de sélection.

Nous avons 4 scénarii pour un total de 4 modes :

- mode veille (standby) : la couleur prédéfinie ou sélectionnée par l'utilisateur voit sa luminosité augmenter et diminuer à la façon d'une respiration

- mode sélection de couleur : le cercle permet de choisir la teinte de la couleur voulue, pour des valeurs allant de 1 à 360 (commodité du cercle). La teinte choisie est alors enregistrée au nouveau touché du bouton (lors du changement de mode)

- mode sélection de la luminosité : chaque demi-cercle permet de changer la luminosité allant de 0 à 1 tout en étant continue

- mode slider : suivi de la main de l'utilisateur ; la LED en face de la main s'allume et la luminosité des autres LEDs décroit en partant de celle en face jusque l'opposée où la LED est éteinte


Select-teinte.png
Schéma du mode de sélection de teinte
Slider3.png
Schéma du mode de sélection de luminosité
Slider-circulaire.png
Schéma du mode slider interactif

Après fabrication du prototype et essais, voici le résultat :

Prototype-slider-3.jpg


Fichier:Video-veille.mp4 Vidéo du mode veille

Fichier:Video-teinte.mp4 Vidéo du mode sélection de teinte

Fichier:Video-globale.mp4 Vidéo d'exécution de tous les modes