Les croquettes du Chat en iot

La puce ESP8266 est un micro-contrôleur qui embarque une fonction WIFI qui a le gros avantage de ne pas coûter grand chose. Il existe plusieurs modules basés sur cette puce. La plus économique coûte moins de 4€, doit être alimentée en 3.3V (pas de régulateur) et tous les GPIO ne sont pas accéssibles (à moins de savoir souder directement sur la puce, ce que mes yeux et mes mains m’empêchent de faire : beaucoup trop petit!).
Je préfère travailler sur un module un peut plus pratique : le module nodemcu (6.11$ sur Ebay). Pour l’écart de prix, ça vaut vraiment la peine : un port usb, un régulateur de tension, l’accés à tous les GPIO. Par contre ce module est un peu plus gros : prévu pour du prototypage. Il existe aussi les modules WeMos qui sont très bien (mes nouveaux projets sont avec eux).

Ces modules peuvent se programmer en LUA avec environnement de développement autour de nodemcu (voir http://www.nodemcu.com/) avec :

Un driver windows https://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx
Un firmware a personnaliser soit même : http://frightanic.com/nodemcu-custom-build/
Un flasher : https://github.com/nodemcu/nodemcu-flasher
un module de développement : http://esp8266.ru/esplorer/
Le problème principale étant la mémoire vive disponible, il faut bien choisir le firmware dont on a besoin avec uniquement les modules nécessaires pour faire tourner son programme. Dans notre cas, nous avons besoin de :

file
GPIO
net
node
timer
UART
WIFI
MQTT
i2c
Je vous laisse installer tous ça…

Pour l’affichage, j’ai utilisé un écran LCD 2×16 caractères avec une interface i2c intégrée.

Pour sa gestion en LUA avec le microcontroleur, j’utilise un module emprunté à Vladimir Dronnikov : https://github.com/dvv/nodemcu-thingies/blob/master/lcd1602.lua

Mon utilisation : (voir i2c_lcd.lua & params.lua)
A l’utilisation, on envoie un message mqtt au module contenant un json du type
{
clear:true, (ou omis, ou false) pour effacer l’écran.
led:true,(ou false pour éteindre)
column:0,
row:1,
text:text
}
Et ça affiche le texte à l’endroit décrit. Avec éventuellement allumage ou extinction du rétroéclairage

Ce petit module est un détecteur de geste de la main.
A voir : http://www.seeedstudio.com/wiki/Grove_-_Gesture_v1.0

J’ai fait un module en lua pour lire les gestes : paj7620.lua
Et un petit programme pour envoyer un message mqtt à chaque détection : i2c_geste.lua

Le câblage super simple :
– les 0V ensemble
– les Vcc sur le 5 Volts du module
– les 2 SDA sur le D5 du module
– les 2 SCI sur le D6 du module

J’ai développé un tas de fonctionnalités autours de ces petits micro-contrôleurs.
Tous les programmes communs sont à la racine du projet sur Github : https://github.com/FredThx/nodemcu_iot.git

Il n’y a qu’un seul fichier qui change d’un projet à l’autre : params.lua . Dans le cas présent, il faut prendre celui dans le répertoire ./croquettes .

C’est ce fichier que nous allons adapter à votre installation.

Pour dégoguer :

LOGGER = false
Si true : un fichier log.txt est créé et toutes les print y sont écrits.

Le hard :

— display et grove gesture en i2c
pin_sda = 5
pin_scl = 6

Pour les modules à charger, se limiter au strict minimum :
modules={“i2c_lcd”, “i2c_geste”}

“”
}
Pour d’autres projets, on peut ajouter les modules suivants :

433_switch Pour piloter des prises électriques en 433 Mhz
BMP_reader Pour lire la pression et la température d’un capteur BMP180
DTH_reader Pour lire un capteur Température-humidité DTH11 ou DTH22
i2c_display Pour piloter un écran oled en i2c
ds1820_reader Pour lire un capteur Température ds1820
mcp3008 Pour lire les entrées analogiques d’un convertisseur MCP3008 (ou 3004)

Paramètres WIFI :

SSID = {“WIFI_THOME1”,’WIFI_THOME2′}
PASSWORD = “xxxx”
HOST = “NODE-CUISINE”
wifi_time_retry = 10 — minutes
(maintenant vous connaissez mon code WIFI!!!, vous n’avez plus qu’a trouver l’adresse!)
Pour le SSID, soit vous n’avez qu’un réseau, dans ce cas SSID = “MON_WIFI” est suffisant. Si comme moi, vous avez plusieurs points d’accés avec des SSID distinct, utiliser une table pour lister les SSID. Si tous les points d’accés ont le même mot de passe, PASSWORD = “xxxx” est suffisant, sinon PASSWORD = {“code1″,”code2”}.
Le microcontrôleur se connectera au premier réseau WIFI qui répond.

Paramètres MQTT :

mqtt_host = “192.168.10.155”
mqtt_port = 1883
mqtt_user = “aaaa”
mqtt_pass = “xxx”
mqtt_client_name = HOST

Adapter a votre serveur MQTT (IP, PORT, user).
Adapter à votre arborescence de messages MQTT.

GEST_TOPIC = “T-HOME/CROQ/GESTE”

—————————————-
–Gestion du display : mqtt(json)=>affichage
—————————————-
mqtt_in_topics[“T-HOME/CROQ/DISPLAY”]=function(data)
disp_add_data(data)
end

Avec ESPlorer,
– charger tous les fichiers du répertoire standard_projet dans le micro-contrôleur (même s’ils ne servent pas, autant tout charger, il y a de la place dans la mémoire flash).
– charger votre fichier /croquettes/params.lua dans le micro-contrôleur.
– exécuter ‘compile.lua’ (les programmes chargés prendront un peu moins de place en mémoire).
– rebooter le module.

Sauf si l’entrée D0 est à 0V, le programme démarre (pratique pour stopper l’exécution du programme s’il plante). A noter que certains module (dont le nodecmu) a un bouton qui permet de passer D0 à la masse : si on appuie dessus quand le module boot : nos programmes ne sont pas exécutés.
Sinon, le module se connecte au wifi et est prêt à recevoir des messages mqtt pour l’affichage et envoie des messages mqtt dés que vous passez la main devant le capteur.

Maintenant notre objet est prêt a communiquer en envoyant et recevant des messages mqtt via votre réseau domestique.
Pour gérer les messages mqtt, il vous faut un serveur (en fait on appelle ça un broker) qui va jouer le rôle de facteur pour livrer le courrier aux abonnés.
Soit vous utiliser un broker en ligne (pour tester ça peut être une option).
Soit vous en installer un à la maison. Sur un raspberry pi par exemple.
Il en existe plusieurs. Pour ma part, j’utilise mosquitto.
Je vous conseil cet article pour bien comprendre (et surtout installer) : http://www.framboise314.fr/linternet-des-objets-iot-sur-raspberry-pi-avec-mqtt

Node-red est un outil open source développé par IBM et installé par défaut sur les dernières distributions raspian. Il est très léger : le plus simple est de le faire tourner sur un raspberry pi. Sinon, ça tourne sur tout ce qui peut faire fonctionner node.js.

Vous vous débrouillez pour installer tout ça…

Avec Node-red, on gère des flux entre des “node” qui de repassent un objet msg.
C’est assez simple et bien documenté.
Il existe des nodes de base + des nodes communautaires (regroupés dans une Library). Si ce n’est pas suffisant, il est possible de créer ses propres nodes.
Le tout se code en javascript.

Pour partager entre nous des flow, c’est super simple :
– ouvrer le .json ci-dessous
– copier le texte
– dans node-red : menu/import/clipboard
– coller

Je vous laisse modifier, adapter, simplifier, améliorer tout ça.

Si vous préférez le plastique au carton, libre à vous d’imprimer une belle boîte en forme de chat pour y loger tout ça.
Pour ma part, une boite en carton qui trainait plus 8 petits aimants et une image du chat de geluck ont suffit.

Depuis quelques semaines, cet objet est utilisé tous les jours et personne ne s’en plaint, sauf peut-être le chat.

Je continue à penser que ce type d’architecture est bonne (stable et facile à maintenir) :
– juste le minimum pour gérer le matériel sur le microcontrôleur
– node-red pour gérer les actions et intéractions
– mqtt pour la messagerie entre objets.

Reste à inventer d’autre applications possible pour cet objet qui sait lire des gestes et afficher 32 caractères.
– une télécommande pour le salon
– une commande pour les volets
– une interface pour visualiser
– les températures mesurées par d’autre objets connectés
– des messages
– …
– une commande pour la chaudière
– …